cuda_la.h

//------------------------------------------------------------------------------
/* vim: set ts=8 sw=8 sts=8 noexpandtab cindent: */
//------------------------------------------------------------------------------
#ifndef _CUDA_LA_H
#define _CUDA_LA_H

#include <errno.h>
#ifdef CUDALA
#undef MATPTR
#include "cublas.h"
#endif

#include "la_traits.h"

namespace LA {

#ifdef CUDALA
#define CPU_GPU(x,y) {if((x)!=cpu && (y)!=cpu) laerror("one operand must be in CPU memory");}
#define NOT_GPU(x) {if((x).getlocation()!=cpu) laerror("Operation not implemented on GPU (yet). Use .moveto(0) first.");}
#define NOT_CPU(x) {if((x).getlocation()==cpu) laerror("Operation not implemented on CPU (yet). Use .moveto(>0) first.");}
#define SAME_LOC(x,y) {if((x).getlocation()!=(y).getlocation()) laerror("Operands have different location. Use .moveto() first.");}
#define SAME_LOC3(x,y,z) {if((x).getlocation()!=(y).getlocation() || (x).getlocation()!=(z).getlocation()) laerror("Operands have different location. Use .moveto() first.");}
#else
#define CPU_GPU(x,y) {}
#define NOT_GPU(x) {}
#define SAME_LOC(x,y) {}
#define SAME_LOC3(x,y,z) {}
#endif

#ifdef DEBUG
        #ifdef __GNUG__
                #define TEST_CUBLAS(X) { if(cublasGetError() != CUBLAS_STATUS_SUCCESS){ laerror2(#X, __PRETTY_FUNCTION__); } }
        #else
                #define TEST_CUBLAS(X) { if(cublasGetError() != CUBLAS_STATUS_SUCCESS){ laerror2(#X, __func__); } }
        #endif
#else
        #define TEST_CUBLAS(X) {}
#endif

typedef enum {undefined=-1, cpu=0, gpu1=1, gpu2=2, gpu3=3, gpu4=4} GPUID;

#ifdef CUDALA

//global static instantiation of this class will provide automatic init/shutdown of GPU
class GPU_START {
public:
        GPU_START(void)
                {
                cublasStatus status = cublasInit();
                if (status != CUBLAS_STATUS_SUCCESS) laerror("Cannot init GPU for CUBLAS");
                errno = 0;
                }
        ~GPU_START(void)
                {
                cublasStatus status = cublasShutdown();
                if (status != CUBLAS_STATUS_SUCCESS) laerror("Cannot cleanly shutdown GPU");
                }
};

extern void *gpualloc(size_t size);
extern void gpufree(void *ptr);
extern void gpuget(size_t n, size_t elsize, const void *from, void *to);
extern void gpuput(size_t n, size_t elsize, const void *from, void *to);
extern double *gpuputdouble(const double &x);
extern complex<double> *gpuputcomplex(const complex<double> &x);

void set_default_loc(const GPUID loc);

template <typename T>
void smart_gpu_set(size_t n, const T& val, void *gpu_to, size_t _step = 1){
        void *ptr(NULL);
        if(sizeof(T)%sizeof(float) != 0){ laerror("memory alignment error"); }

        cublasAlloc(1, sizeof(T), &ptr);
        TEST_CUBLAS("cublasAlloc");

        cublasSetVector(1, sizeof(T), &val, 1, ptr, 1);
        TEST_CUBLAS("cublasSetVector");

        if(sizeof(T) == sizeof(float)){
                cublasScopy(n, (float*)ptr, 0, ((float*)gpu_to), _step);
                TEST_CUBLAS("cublasScopy");

        }else if(sizeof(T) == sizeof(double)){
                cublasDcopy(n, (double*)ptr, 0, ((double*)gpu_to), _step);
                TEST_CUBLAS("cublasDcopy");

        }else if(sizeof(T) == sizeof(complex<double>)){
                cublasZcopy(n, (cuDoubleComplex*)ptr, 0, (cuDoubleComplex*)gpu_to, _step);
                TEST_CUBLAS("cublasZcopy");

        }else{
                for(register int i=0; i<sizeof(T)/sizeof(float); i++){
                        cublasScopy(n, (float*)ptr + i, 0, ((float*)gpu_to) + i, sizeof(T)/sizeof(float)*_step);
                        TEST_CUBLAS("cublasScopy");
                }
        }

        cublasFree(ptr);
        TEST_CUBLAS("cublasFree");
}

extern GPUID DEFAULT_LOC;

#endif
}
#endif

LA library home page http://www.pittnerovi.com/la .