CudaArray.h

#pragma once
#include "common.hpp"

template <class T> 
class CudaArray
{
public:
        CudaArray(void) : m_length(0), m_host(0), m_read_buffer(0), m_write_buffer(1), setmemdev(0)
        {
                m_dev = new T*[2];
                m_dev[0] = 0;
                m_dev[1] = 0;

                m_vbo = new unsigned int[2];
            m_vbo[0] = 0;
                m_vbo[1] = 0;

                m_cuda_vbo[0] = 0;
                m_cuda_vbo[1] = 0;
        }       

        ~CudaArray(void)
        {
                std::cout << "Delete CudaArray begin" << std::endl;
                delete[] m_host;
                m_host = 0;
                
                std::cout << "Delete Buffer" << std::endl;
                if(m_use_vbo)   
                {
                        cutilSafeCall(cudaGraphicsUnregisterResource(m_cuda_vbo[0]));
                        glDeleteBuffers(1, &m_vbo[0]);
                        m_vbo[0] = 0;
                }
                else
                {
                        if(setmemdev)   cutilSafeCall(cudaFree(m_dev[0]));;
                }
                
                std::cout << "Delete PingPong Buffer" << std::endl;
                if(m_pingpong)
                {
                        if(m_use_vbo)   
                        {
                                cutilSafeCall(cudaGraphicsUnregisterResource(m_cuda_vbo[1]));
                                glDeleteBuffers(1, &m_vbo[1]);
                                m_vbo[1] = 0;
                        }
                        else
                        {
                                if(setmemdev)   cutilSafeCall(cudaFree(m_dev[1]));
                        }
                }

                if(m_use_vbo)   
                {
                        delete[] m_cuda_vbo;
                        delete[] m_vbo;
                }
                else
                {
                        delete[] m_dev;
                }

                std::cout << "Delete CudaArray end" << std::endl;
        }

        void CreateBuffer(size_t size, bool vbo=false, bool pingpong=false)
        {
                m_length = size;
                m_use_vbo = vbo;
                m_pingpong = pingpong;
    
                if(pingpong)    m_write_buffer = 1;             
                
                SetMemHost();
            
                if(m_use_vbo)   SetMemVBO();
                else                    SetMemDev();
        };

        /*
         * Returns Length of Buffer
         * @param Length of Buffer
         */
        unsigned int GetLength()
        {
                return m_length;
        };

        GLuint CreateVBO(size_t size)
        {
                GLuint tmp_vbo;
                glGenBuffers(1, &tmp_vbo);
                glBindBuffer(GL_ARRAY_BUFFER, tmp_vbo);
                glBufferData(GL_ARRAY_BUFFER, size, m_host, GL_DYNAMIC_DRAW);
                glBindBuffer(GL_ARRAY_BUFFER, 0);

                return tmp_vbo;
        };

        void BindVBO()
        {
                if(m_vbo[0]) 
                {
                        cutilSafeCall(cudaGraphicsMapResources(1, &m_cuda_vbo[0], 0));
                        size_t num_bytes; 
                        cutilSafeCall(cudaGraphicsResourceGetMappedPointer((void **)&m_dev[0], &num_bytes,  m_cuda_vbo[0]));
            } 
                if(m_pingpong && m_vbo[1]) 
                {
                        cutilSafeCall(cudaGraphicsMapResources(1, &m_cuda_vbo[1], 0));
                        size_t num_bytes; 
                        cutilSafeCall(cudaGraphicsResourceGetMappedPointer((void **)&m_dev[1], &num_bytes,  m_cuda_vbo[1]));
                }
        };

        void UnbindVBO()
        {
                if(m_vbo[0]) 
                {
                        cutilSafeCall(cudaGraphicsUnmapResources(1, &m_cuda_vbo[0], 0));
                        m_dev[0] = 0;
                }

                if(m_pingpong && m_vbo[1]) 
                {
                        cutilSafeCall(cudaGraphicsUnmapResources(1, &m_cuda_vbo[1], 0));
                m_dev[1] = 0;
                }
        };

        T* GetDevRead(){        return m_dev[m_read_buffer];    };
        T* GetDevWrite(){       return m_dev[m_write_buffer];   };
        
        unsigned int GetDevReadVBO(){   return m_vbo[m_read_buffer];    };
        unsigned int GetDevWriteVBO(){  return m_vbo[m_write_buffer];   };
        
        T* GetHost(){   return m_host;  }       

        void SetHost(T* tmp, unsigned int length)
        {
                m_host = tmp;
                m_length = length;
        }       

        void Swap()     {       std::swap(m_read_buffer, m_write_buffer);       }

        void SetMemVBO()
        {
                m_vbo[0] = CreateVBO(m_length*sizeof(T));
                cutilSafeCall(cudaGraphicsGLRegisterBuffer(&m_cuda_vbo[0], m_vbo[0], cudaGraphicsMapFlagsNone));
                
                if(m_pingpong) 
                {
                        m_vbo[1] = CreateVBO(m_length*sizeof(T));
                        cutilSafeCall(cudaGraphicsGLRegisterBuffer(&m_cuda_vbo[1], m_vbo[1], cudaGraphicsMapFlagsNone));            
                }
        };

        void SetMemHost()
        {
                m_host = (T *) new T[m_length];
        };

        void SetMemDev()
        {
                setmemdev = true;
                size_t size  = m_length*sizeof(T);

                cutilSafeCall(cudaMalloc((void **) &m_dev[0], size));
                if (m_pingpong) cutilSafeCall(cudaMalloc((void **) &m_dev[1], size));
                
        };

        void SetVBO(unsigned int id1)
        {
                m_vbo[0] = id1;
        };

        void SetVBO(unsigned int id1, unsigned int id2)
        {
                m_vbo[0] = id1;
                m_vbo[1] = id2;
        };

        void Copy(bool tohost, unsigned int start, unsigned int count, bool use_write_buffer = false)
        {
                if(use_write_buffer)
                {
                        BindVBO();
                        if(tohost)      cutilSafeCall(cudaMemcpy((void *) (m_host + start), (void *) (m_dev[m_write_buffer] + start), count*sizeof(T), cudaMemcpyDeviceToHost));
                        else            cutilSafeCall(cudaMemcpy((void *) (m_dev[m_write_buffer] + start), (void *) (m_host + start), count*sizeof(T), cudaMemcpyHostToDevice));
                        UnbindVBO();
                }
                else
                {
                        BindVBO();
                        if(tohost)      cutilSafeCall(cudaMemcpy((void *) (m_host + start), (void *) (m_dev[m_read_buffer] + start), count*sizeof(T), cudaMemcpyDeviceToHost));
                        else            cutilSafeCall(cudaMemcpy((void *) (m_dev[m_read_buffer] + start), (void *) (m_host + start), count*sizeof(T), cudaMemcpyHostToDevice));
                        UnbindVBO();
                }
        };

        void Debug(unsigned int start, unsigned int count)
        {
                if(count == 0) count = m_length;

                Copy(true, 0, count);

                //unsigned int maxindex = 128*128*128;
                for(unsigned int i=start; i<(start+count); i++) 
                {
                        //if(abs(m_host[i].x+m_host[i].y+m_host[i].z) > 0.0)  printf("(%f) (%f) (%f) \n", m_host[i].x, m_host[i].y, m_host[i].z );
                        //if(m_host[i].w >= 0.0)        printf("(%.4f) (%.4f) (%.4f) (%.4f) \n", m_host[i].x, m_host[i].y, m_host[i].z, m_host[i].w );
                        unsigned int tmp = m_host[i];
                        if(tmp < 0xffffffff)printf("%d \n", m_host[i]);
                        //if( m_host[i] < maxindex) printf("%d \n", m_host[i]);
                }
        };

private:
        unsigned int m_length;

        bool m_pingpong;
        bool m_use_vbo;

        unsigned int m_read_buffer;
        unsigned int m_write_buffer;

        unsigned int* m_vbo;
        T** m_dev;
        T* m_host;

        struct cudaGraphicsResource *m_cuda_vbo[2];

        bool setmemdev;
};