common.hpp

#pragma once
 
// macro for registering functions to CUDA (if used)
#ifdef __CUDACC__
#define cudaFn __device__ __host__
#else
#define cudaFn
#endif
 
template <typename T>
using stateFunc = void (*)(T*, const unsigned int, const unsigned int);
 
template <typename T>
using kernelFunc = void (*)(T*, const unsigned int);
 
namespace CellularAutomata
{
    enum Device
    {
        CPU,
        CUDA,
    };
 
    template <typename T>
    class State
    {
    public:
        T* curr;
 
        T* next;
 
        const unsigned int height;
 
        const unsigned int width;
 
        const Device device;
 
        State(const unsigned int height, const unsigned int width, stateFunc<T> fn, Device device);
 
        ~State();
 
        void copyTo(State<T>* to);
 
        void swap();
 
        void print();
 
    private:
        void initCPU(stateFunc<T> fn);
        void initCUDA(stateFunc<T> fn);
        void freeCPU();
        void freeCUDA();
    };
 
    template <typename T>
    class Kernel
    {
    public:
        T* kernel;
        const unsigned int size;
        const Device device;
 
        Kernel(const unsigned int size, kernelFunc<T> fn, Device device);
 
        ~Kernel();
 
        void copyTo(Kernel<T>* to);
 
        void print();
 
    private:
        void initCPU(kernelFunc<T> fn);
        void initCUDA(kernelFunc<T> fn);
        void freeCPU();
        void freeCUDA();
    };
 
}
 
#include "common.inl"