random_quda.h

Go to the documentation of this file.

#ifndef RANDOM_GPU_H
#define RANDOM_GPU_H

//#include <stdio.h>
//#include <string.h>
//#include <iostream>
#include <curand_kernel.h>

namespace quda {

#if defined(XORWOW)
typedef struct curandStateXORWOW cuRNGState;
#elif defined(MRG32k3a)
typedef struct curandStateMRG32k3a cuRNGState;
#else
typedef struct curandStateMRG32k3a cuRNGState;
#endif

class RNG {
public:
    RNG(int rng_sizes, int seedin, const int XX[4]);
    RNG(int rng_sizes, int seedin);
    void Release(); 
    void Init();
    int Size(){ return rng_size;};
    int Node_Offset(){ return node_offset;};
    int Seed(){ return seed;};
    __host__ __device__ __inline__ cuRNGState* State(){ return state;};
    void restore();
    void backup();
private:
    cuRNGState *state;
    cuRNGState *backup_state;
    int seed;
    int rng_size;  
    int node_offset;
    int X[4];
    void AllocateRNG();
    void INITRNG(int rng_sizes, int seedin, int offsetin);
};





template<class Real>
inline  __device__ Real Random(cuRNGState &state, Real a, Real b){
    Real res;
    return res;
}
 
template<>
inline  __device__ float Random<float>(cuRNGState &state, float a, float b){
    return a + (b - a) * curand_uniform(&state);
}

template<>
inline  __device__ double Random<double>(cuRNGState &state, double a, double b){
    return a + (b - a) * curand_uniform_double(&state);
}

template<class Real>
inline  __device__ Real Random(cuRNGState &state){
    Real res;
    return res;
}
 
template<>
inline  __device__ float Random<float>(cuRNGState &state){
    return curand_uniform(&state);
}

template<>
inline  __device__ double Random<double>(cuRNGState &state){
    return curand_uniform_double(&state);
}


template<class Real>
struct uniform { };
template<>
struct uniform<float> {
    __device__
        static inline float rand(cuRNGState &state) {
        return curand_uniform(&state);
    }
};
template<>
struct uniform<double> {
    __device__
        static inline double rand(cuRNGState &state) {
        return curand_uniform_double(&state);
    }
};



template<class Real>
struct normal { };
template<>
struct normal<float> {
    __device__
        static inline float rand(cuRNGState &state) {
        return curand_normal(&state);
    }
};
template<>
struct normal<double> {
    __device__
        static inline double rand(cuRNGState &state) {
        return curand_normal_double(&state);
    }
};


}

#endif