cudalib.h

// cudalib.h -- wrappers for CUDA to hide NVidia stuff
//
// F. Seide, V-hansu

#pragma once

#include "cudabasetypes.h"
#include <vector>
#include <memory>
#include <stdexcept>

namespace msra { namespace cuda {

// helper functions
void join(); // wait until current launch or other async operation is completed

// memory allocation and copying
void *mallocbytes(size_t nelem, size_t sz);
void freebytes(void *p);
template <typename T>
cuda_ptr<T> malloc(size_t nelem)
{
    return (T *) mallocbytes(nelem, sizeof(T));
}
template <typename T>
void free(cuda_ptr<T> p)
{
    if (p.get() != NULL)
        freebytes((void *) p.get());
}

void memcpyh2d(void *dst, size_t byteoffset, const void *src, size_t nbytes);
void memcpyd2h(void *dst, const void *src, size_t byteoffset, size_t nbytes);
template <typename T>
void memcpy(cuda_ptr<T> dst, size_t dstoffset, const T *src, size_t nelem)
{
    memcpyh2d((void *) dst.get(), dstoffset * sizeof(T), (const void *) src, nelem * sizeof(T));
}
template <typename T>
void memcpy(T *dst, const cuda_ptr<T> src, size_t srcoffset, size_t nelem)
{
    memcpyd2h((void *) dst, (const void *) src.get(), srcoffset * sizeof(T), nelem * sizeof(T));
}
// [v-hansu] for debug use, change false to true to activate
template <typename T>
void peek(vectorref<T> v)
{
    bool dopeek = false;
    if (dopeek)
    {
        std::vector<T> vp(v.size());
        memcpy(&vp[0], v.get(), 0, v.size());
        T vp0 = vp[0]; // for reference
        vp[0] = vp0;
    }
}
template <typename T>
void peek(matrixref<T> v)
{
    bool dopeek = false;
    if (dopeek)
    {
        std::vector<T> vp(v.cols() * v.rows());
        memcpy(&vp[0], v.get(), 0, v.cols() * v.rows());
        T vp0 = vp[0]; // for reference
        vp[0] = vp0;
    }
}
};
};