Jungfraujoch/common/CUDAWrapper.cpp

// SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
// SPDX-License-Identifier: GPL-3.0-only

#include "CUDAWrapper.h"

#include <condition_variable>
#include <mutex>

// Build-independent: the CUDA build gets get_gpu_names() from CUDAWrapper.cu, the CPU-only build from
// the stub below, and this collapses whichever list came back. Four identical cards read better as
// "4x <name>" than as the same name four times, and a mixed machine keeps one group per model.
std::string get_gpu_description() {
    const auto names = get_gpu_names();

    std::string out;
    for (size_t i = 0; i < names.size();) {
        size_t n = 1;
        while (i + n < names.size() && names[i + n] == names[i])
            n++;
        if (!out.empty())
            out += ", ";
        if (n > 1)
            out += std::to_string(n) + "x ";
        out += names[i];
        i += n;
    }
    return out;
}

namespace {
    std::mutex gpu_work_beside_mutex;
    std::condition_variable gpu_work_beside_done;
    int gpu_work_beside = 0;
}

GPUWorkBeside::GPUWorkBeside() {
    std::lock_guard lock(gpu_work_beside_mutex);
    ++gpu_work_beside;
}

GPUWorkBeside::~GPUWorkBeside() {
    {
        std::lock_guard lock(gpu_work_beside_mutex);
        --gpu_work_beside;
    }
    gpu_work_beside_done.notify_all();
}

bool wait_for_gpu_work_beside(std::chrono::seconds timeout) {
    std::unique_lock lock(gpu_work_beside_mutex);
    return gpu_work_beside_done.wait_for(lock, timeout, [] { return gpu_work_beside == 0; });
}

#ifndef JFJOCH_USE_CUDA

int32_t get_gpu_count() {
    return 0;
}

std::vector<std::string> get_gpu_names() {
    return {};
}

void set_gpu(int32_t dev_id) {}

void pin_gpu() {}

void pin_gpu(int32_t dev_id) {}

void enable_gpu_numa_binding() {}

void set_gpu_blocking_sync() {}

void cuda_clear_error() {}

void cuda_throw_if_context_lost() {}

#endif