brick-gpu.h

Go to the documentation of this file.

 
#ifndef BRICK_GPU_FUNCS_H
#define BRICK_GPU_FUNCS_H
 
#if !(defined(BRICK_BRICK_CUDA_H) || defined(BRICK_BRICK_HIP_H))
#error "Include either brick-cuda.h or brick-hip.h for generic GPU defines"
#endif
 
#include <cassert>
#include <brick.h>
 
#ifndef NDEBUG
 
#define gpuCheck(x) x
 
#else // defined(NDEBUG)
 
#include <cstdio>
#define gpuCheck(x) _gpuCheck(x, #x, __FILE__, __LINE__)
 
#endif // NDEBUG
 
template<typename T>
void _gpuCheck(T e, const char *func, const char *call, const int line) {
    if (e != gpuSuccess) {
        printf("\"%s\" at %d in %s\n\treturned %d\n-> %s\n", func, line, call, (int) e, gpuGetErrorString(e));
        exit(EXIT_FAILURE);
    }
}
 
template<unsigned dims>
BrickInfo<dims> movBrickInfo(BrickInfo<dims> &bInfo, gpuMemcpyKind kind) {
    assert(kind == gpuMemcpyHostToDevice || kind == gpuMemcpyDeviceToHost);
 
    BrickInfo<dims> ret = bInfo;
    unsigned size = bInfo.nbricks * static_power<3, dims>::value * sizeof(unsigned);
    if (kind == gpuMemcpyHostToDevice) {
        gpuCheck(gpuMalloc(&ret.adj, size));
    } else {
        ret.adj = (unsigned (*)[(static_power<3, dims>::value)]) malloc(size);
    }
    gpuCheck(gpuMemcpy(ret.adj, bInfo.adj, size, kind));
    return ret;
}
 
template<unsigned dims>
BrickInfo<dims> *movBrickInfoDeep(BrickInfo<dims> &bInfo, gpuMemcpyKind kind) {
    BrickInfo<dims> *ret;
    BrickInfo<dims> temp = movBrickInfo(bInfo, kind);
    unsigned size = sizeof(BrickInfo<dims>);
    if (kind == gpuMemcpyHostToDevice) {
        gpuMalloc(&ret, size);
    } else {
        ret = (BrickInfo<dims> *) malloc(size);
    }
    gpuMemcpy(ret, &temp, size, kind);
    return ret;
}
 
inline BrickStorage movBrickStorage(BrickStorage &bStorage, gpuMemcpyKind kind) {
    assert(kind == gpuMemcpyHostToDevice || kind == gpuMemcpyDeviceToHost);
 
    bool isToDevice = (kind == gpuMemcpyHostToDevice);
    BrickStorage ret = bStorage;
    unsigned size = bStorage.step * bStorage.chunks * sizeof(bElem);
    bElem *datptr;
    if (isToDevice) {
        gpuCheck(gpuMalloc(&datptr, size));
    } else {
        datptr = (bElem *) malloc(size);
    }
    gpuCheck(gpuMemcpy(datptr, bStorage.dat.get(), size, kind));
    if (isToDevice) {
        ret.dat = std::shared_ptr<bElem>(datptr, [](bElem *p) { gpuFree(p); });
    } else {
        ret.dat = std::shared_ptr<bElem>(datptr, [](bElem *p) { free(p); });
    }
    return ret;
}
 
#include "dev_shl.h"
 
#endif // BRICK_GPU_FUNCS_H