wrap.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2012 Josh Bialkowski (jbialk@mit.edu)
 *
 *  This file is part of mpblocks.
 *
 *  mpblocks is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  mpblocks is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with mpblocks.  If not, see <http://www.gnu.org/licenses/>.
 */
#ifndef MPBLOCKS_CUDA_WRAP_H_
#define MPBLOCKS_CUDA_WRAP_H_

#include <map>

namespace mpblocks {
namespace     cuda {


typedef cudaMemcpyKind      MemcpyKind;

struct FuncAttributes:
    public cudaFuncAttributes
{
    FuncAttributes();

    template <typename T>
    void getFrom( T* entry );
};


struct DeviceProp:
    public cudaDeviceProp
{
    DeviceProp();
    DeviceProp(int device);

    void getFrom( int device );
};


void checkResult( cudaError_t result, const std::string& where);

void* malloc(size_t size);

void* mallocPitch( size_t& pitch, size_t cols, size_t rows );

template <typename T>
T* mallocT( size_t nObjs );

template <typename T>
T* mallocPitchT( size_t& pitch, size_t obsPerRow, size_t cols );

void free(void* devPtr);

void memcpy( void *dst, const void *src, size_t count, MemcpyKind kind);

void memcpy2D(
        void*       dst,
        size_t      dpitch,
        const void* src,
        size_t      spitch,
        size_t      width,
        size_t      height,
        MemcpyKind  kind );

template <typename T>
void memcpy2DT(
        T*          dst,
        size_t      dpitchBytes,
        const T*    src,
        size_t      spitchBytes,
        size_t      widthObs,
        size_t      height,
        MemcpyKind  kind );

template <typename T>
void memcpyT( T* dst, const T* src,  size_t nObjs, MemcpyKind kind );

void memset( void* devPtr, int value, size_t count );

template <typename T>
void memset( T* devPtr, int value, size_t nObs );

void memset2D(
        void*   devPtr,
        size_t  pitch,
        int     value,
        size_t  width,
        size_t  height );

template <typename T>
void memset2DT(
        T*      devPtr,
        size_t  pitchBytes,
        int     value,
        size_t  widthObjs,
        size_t  height );

int getDeviceCount();

DeviceProp getDeviceProperties(int dev);

int getDevice();

void setDevice(int dev);

void deviceSynchronize();

void checkLastError(const std::string& msg="checkLastError");

template <class oiter>
void getDeviceList( oiter& out )
{
    int nDevices = getDeviceCount();
    for(int dev=0; dev < nDevices; dev++)
    {
        DeviceProp prop = getDeviceProperties(dev);
        *(out++) = prop.name;
    }
}

void printDeviceReport( std::ostream& out, int dev );
void printDeviceReport( std::ostream& out );

typedef std::map<std::string,FuncAttributes> fattrMap_t;
void printKernelReport( std::ostream& out, const fattrMap_t& attr );


} // namespace cuda
} // namespace mpblocks



#endif /* UTILS_H_ */