cuda By exmaple所用到的代码

 
 
gl_helper.h http://code.google.com/p/snp-gpgpu/source/browse/trunk/f/common/gl_helper.h?r=4
 /* 
 * Copyright 1993-2010 NVIDIA Corporation.  All rights reserved. 
 * 
 *
 NVIDIA Corporation and its licensors retain all intellectual property and 
 * proprietary rights in and to this software and related documentation. 
 *
 Any use, reproduction, disclosure, or distribution of this software 
 * and related documentation without an express license agreement from 
 *
 NVIDIA Corporation is strictly prohibited. 
 * 
 * Please refer to the applicable NVIDIA end user license agreement
 (EULA) 
 * associated with this source code for terms and conditions that govern 
 * your use of this NVIDIA software. 
 * 
 */ 
#ifndef __GL_HELPER_H__ 
#define __GL_HELPER_H__ 
/* 
 
  On 64-bit Windows, we need to prevent GLUT from automatically linking against 
   glut32. We do this by defining GLUT_NO_LIB_PRAGMA. This means that we need to 
 
  manually add opengl32.lib and glut64.lib back to the link using pragmas. 
   Alternatively, this could be done on the compilation/link command-line, but 
 
  we chose this so that compilation is identical between 32- and 64-bit Windows. 
*/ 
#ifdef _WIN64 
#define GLUT_NO_LIB_PRAGMA 
#pragma comment (lib, "opengl32.lib")  /*
 link with Microsoft OpenGL lib */ 
#pragma comment (lib, "glut64.lib")  
  /* link with Win64 GLUT lib */ 
#endif //_WIN64 
#ifdef _WIN32 
/*
 On Windows, include the local copy of glut.h and glext.h */ 
#include "GL/glut.h" 
#include "GL/glext.h" 
#define GET_PROC_ADDRESS( str ) wglGetProcAddress( str ) 
#else 
/*
 On Linux, include the system's copy of glut.h, glext.h, and glx.h */ 
#include <GL/glut.h> 
#include <GL/glext.h> 
#include <GL/glx.h> 
#define GET_PROC_ADDRESS( str ) glXGetProcAddress( (const GLubyte *)str ) 
#endif //_WIN32 
#endif //__GL_HELPER_H__' 

 
 
_-————————————————————————————————————————————————————————
 
 
book.h
 
http://code.google.com/p/snp-gpgpu/source/browse/trunk/f/common/book.h?r=4

     
     

      
      
 
       
 
        
 
         
              
              
/* 
 *
 Copyright 1993-2010 NVIDIA Corporation.  All rights reserved. 
 * 
 * NVIDIA Corporation and its licensors retain
 all intellectual property and 
 * proprietary rights in and to this software and related documentation. 
 * Any
 use, reproduction, disclosure, or distribution of this software 
 * and related documentation without an express license agreement from 
 *
 NVIDIA Corporation is strictly prohibited. 
 * 
 * Please refer to the applicable NVIDIA end user license agreement
 (EULA) 
 * associated with this source code for terms and conditions that govern 
 * your use of this NVIDIA software. 
 * 
 */ 
#ifndef __BOOK_H__ 
#define __BOOK_H__ 
#include <stdio.h> 
static void HandleError( cudaError_t
 err, 
                         const char *file, 
 
                        int line ) { 
 
   if (err != cudaSuccess) { 
 
       printf( "%s in %s at line %d/n", cudaGetErrorString( err ), 
 
               file, line ); 
        exit( EXIT_FAILURE ); 
 
   } 
} 
#define HANDLE_ERROR( err ) (HandleError( err, __FILE__, __LINE__ )) 
#define HANDLE_NULL( a ) {if (a == NULL) { / 
 
                           printf( "Host memory failed in %s at line %d/n", / 
 
                                   __FILE__, __LINE__ ); / 
 
                           exit( EXIT_FAILURE );}} 
template< typename T > 
void swap( T& a, T& b ) { 
 
   T t = a; 
    a = b; 
 
   b = t; 
} 
void* big_random_block( int size ) { 
 
   unsigned char *data = (unsigned char*)malloc( size ); 
 
   HANDLE_NULL( data ); 
    for (int i=0; i<size; i++) 
 
       data[i] = rand(); 
 
   return data; 
} 
int* big_random_block_int( int size ) { 
 
   int *data = (int*)malloc( size * sizeof(int) ); 
 
   HANDLE_NULL( data ); 
    for (int i=0; i<size; i++) 
 
       data[i] = rand(); 
 
   return data; 
} 
//
 a place for common kernels - starts here 
__device__ unsigned char value( float n1, float n2, int hue ) { 
 
   if (hue > 360)      hue -= 360; 
 
   else if (hue < 0)  
 hue += 360; 
 
   if (hue < 60) 
 
       return (unsigned char)(255 * (n1 + (n2-n1)*hue/60)); 
 
   if (hue < 180) 
 
       return (unsigned char)(255 * n2); 
 
   if (hue < 240) 
 
       return (unsigned char)(255 * (n1 + (n2-n1)*(240-hue)/60)); 
 
   return (unsigned char)(255 * n1); 
} 
__global__ void float_to_color( unsigned char *optr, 
 
                             const float *outSrc ) { 
 
   // map from threadIdx/BlockIdx to pixel position 
    int x = threadIdx.x + blockIdx.x * blockDim.x; 
 
   int y = threadIdx.y + blockIdx.y * blockDim.y; 
 
   int offset = x + y * blockDim.x * gridDim.x; 
 
   float l = outSrc[offset]; 
 
   float s = 1; 
 
   int h = (180 + (int)(360.0f * outSrc[offset])) % 360; 
 
   float m1, m2; 
 
   if (l <= 0.5f) 
 
       m2 = l * (1 + s); 
 
   else 
        m2 = l + s - l * s; 
 
   m1 = 2 * l - m2; 
 
   optr[offset*4 + 0] = value( m1, m2, h+120 ); 
 
   optr[offset*4 + 1] = value( m1, m2, h ); 
 
   optr[offset*4 + 2] = value( m1, m2, h -120 ); 
 
   optr[offset*4 + 3] = 255; 
} 
__global__ void float_to_color( uchar4 *optr, 
 
                             const float *outSrc ) { 
 
   // map from threadIdx/BlockIdx to pixel position 
    int x = threadIdx.x + blockIdx.x * blockDim.x; 
 
   int y = threadIdx.y + blockIdx.y * blockDim.y; 
 
   int offset = x + y * blockDim.x * gridDim.x; 
 
   float l = outSrc[offset]; 
 
   float s = 1; 
 
   int h = (180 + (int)(360.0f * outSrc[offset])) % 360; 
 
   float m1, m2; 
 
   if (l <= 0.5f) 
 
       m2 = l * (1 + s); 
 
   else 
        m2 = l + s - l * s; 
 
   m1 = 2 * l - m2; 
 
   optr[offset].x = value( m1, m2, h+120 ); 
 
   optr[offset].y = value( m1, m2, h ); 
 
   optr[offset].z = value( m1, m2, h -120 ); 
 
   optr[offset].w = 255; 
} 
#if
 _WIN32 
    //Windows threads. 
 
   #include <windows.h> 
 
   typedef HANDLE CUTThread; 
    typedef unsigned (WINAPI *CUT_THREADROUTINE)(void *); 
 
   #define CUT_THREADPROC unsigned WINAPI 
    #define  CUT_THREADEND return 0 
#else 
 
   //POSIX threads. 
    #include <pthread.h> 
 
   typedef pthread_t CUTThread; 
    typedef void *(*CUT_THREADROUTINE)(void *); 
 
   #define CUT_THREADPROC void 
    #define  CUT_THREADEND 
#endif 
//Create
 thread. 
CUTThread start_thread( CUT_THREADROUTINE, void *data ); 
//Wait
 for thread to finish. 
void end_thread( CUTThread thread ); 
//Destroy
 thread. 
void destroy_thread( CUTThread thread ); 
//Wait
 for multiple threads. 
void wait_for_threads( const CUTThread *threads, int num ); 
#if
 _WIN32 
    //Create thread 
    CUTThread start_thread(CUT_THREADROUTINE
 func, void *data){ 
 
       return CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)func, data, 0, NULL); 
 
   } 
    //Wait for thread to finish 
 
   void end_thread(CUTThread thread){ 
 
       WaitForSingleObject(thread, INFINITE); 
 
       CloseHandle(thread); 
    } 
 
   //Destroy thread 
    void destroy_thread( CUTThread thread ){ 
 
       TerminateThread(thread, 0); 
 
       CloseHandle(thread); 
    } 
 
   //Wait for multiple threads 
    void wait_for_threads(const CUTThread * threads, int num){ 
 
       WaitForMultipleObjects(num, threads, true, INFINITE); 
 
       for(int i = 0; i < num; i++) 
 
           CloseHandle(threads[i]); 
 
   } 
#else 
 
   //Create thread 
    CUTThread start_thread(CUT_THREADROUTINE
 func, void * data){ 
 
       pthread_t thread; 
        pthread_create(&thread, NULL, func, data); 
 
       return thread; 
    } 
 
   //Wait for thread to finish 
    void end_thread(CUTThread thread){ 
 
       pthread_join(thread, NULL); 
 
   } 
    //Destroy thread 
 
   void destroy_thread( CUTThread thread ){ 
 
       pthread_cancel(thread); 
    } 
 
   //Wait for multiple threads 
    void wait_for_threads(const CUTThread * threads, int num){ 
 
       for(int i = 0; i < num; i++) 
 
           end_thread( threads[i] ); 
 
   } 
#endif 
#endif  //
 __BOOK_H__ 
              
              
——————————————————————————————————————————————————————————————
 
         
 
          
 
         
 
        
 
       
 
      
     
     
 
 
 
cpu_anim.h
                     http://code.google.com/p/snp-gpgpu/source/browse/trunk/f/common/cpu_anim.h?r=4

     
     
/*
 * Copyright 1993-2010 NVIDIA Corporation.  All rights reserved.
 *
 * NVIDIA Corporation and its licensors retain all intellectual property and
 * proprietary rights in and to this software and related documentation.
 * Any use, reproduction, disclosure, or distribution of this software
 * and related documentation without an express license agreement from
 * NVIDIA Corporation is strictly prohibited.
 *
 * Please refer to the applicable NVIDIA end user license agreement (EULA)
 * associated with this source code for terms and conditions that govern
 * your use of this NVIDIA software.
 *
 */


#ifndef __CPU_ANIM_H__
#define __CPU_ANIM_H__

#include "gl_helper.h"

#include <iostream>


struct CPUAnimBitmap {
    unsigned char    *pixels;
    int     width, height;
    void    *dataBlock;
    void (*fAnim)(void*,int);
    void (*animExit)(void*);
    void (*clickDrag)(void*,int,int,int,int);
    int     dragStartX, dragStartY;

    CPUAnimBitmap( int w, int h, void *d = NULL ) {
        width = w;
        height = h;
        pixels = new unsigned char[width * height * 4];
        dataBlock = d;
        clickDrag = NULL;
    }

    ~CPUAnimBitmap() {
        delete [] pixels;
    }

    unsigned char* get_ptr( void ) const   { return pixels; }
    long image_size( void ) const { return width * height * 4; }

    void click_drag( void (*f)(void*,int,int,int,int)) {
        clickDrag = f;
    }

    void anim_and_exit( void (*f)(void*,int), void(*e)(void*) ) {
        CPUAnimBitmap**   bitmap = get_bitmap_ptr();
        *bitmap = this;
        fAnim = f;
        animExit = e;
        // a bug in the Windows GLUT implementation prevents us from
        // passing zero arguments to glutInit()
        int c=1;
        char* dummy = "";
        glutInit( &c, &dummy );
        glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGBA );
        glutInitWindowSize( width, height );
        glutCreateWindow( "bitmap" );
        glutKeyboardFunc(Key);
        glutDisplayFunc(Draw);
        if (clickDrag != NULL)
            glutMouseFunc( mouse_func );
        glutIdleFunc( idle_func );
        glutMainLoop();
    }

    // static method used for glut callbacks
    static CPUAnimBitmap** get_bitmap_ptr( void ) {
        static CPUAnimBitmap*   gBitmap;
        return &gBitmap;
    }

    // static method used for glut callbacks
    static void mouse_func( int button, int state,
                            int mx, int my ) {
        if (button == GLUT_LEFT_BUTTON) {
            CPUAnimBitmap*   bitmap = *(get_bitmap_ptr());
            if (state == GLUT_DOWN) {
                bitmap->dragStartX = mx;
                bitmap->dragStartY = my;
            } else if (state == GLUT_UP) {
                bitmap->clickDrag( bitmap->dataBlock,
                                   bitmap->dragStartX,
                                   bitmap->dragStartY,
                                   mx, my );
            }
        }
    }

    // static method used for glut callbacks
    static void idle_func( void ) {
        static int ticks = 1;
        CPUAnimBitmap*   bitmap = *(get_bitmap_ptr());
        bitmap->fAnim( bitmap->dataBlock, ticks++ );
        glutPostRedisplay();
    }

    // static method used for glut callbacks
    static void Key(unsigned char key, int x, int y) {
        switch (key) {
            case 27:
                CPUAnimBitmap*   bitmap = *(get_bitmap_ptr());
                bitmap->animExit( bitmap->dataBlock );
                //delete bitmap;
                exit(0);
        }
    }

    // static method used for glut callbacks
    static void Draw( void ) {
        CPUAnimBitmap*   bitmap = *(get_bitmap_ptr());
        glClearColor( 0.0, 0.0, 0.0, 1.0 );
        glClear( GL_COLOR_BUFFER_BIT );
        glDrawPixels( bitmap->width, bitmap->height, GL_RGBA, GL_UNSIGNED_BYTE, bitmap->pixels );
        glutSwapBuffers();
    }
};


#endif  // __CPU_ANIM_H__




__________________________________________________________________


cpu_bitmap.h
http://code.google.com/p/snp-gpgpu/source/browse/trunk/f/common/cpu_bitmap.h?r=4



 
         
/*
 * Copyright 1993-2010 NVIDIA Corporation.  All rights reserved.
 *
 * NVIDIA Corporation and its licensors retain all intellectual property and
 * proprietary rights in and to this software and related documentation.
 * Any use, reproduction, disclosure, or distribution of this software
 * and related documentation without an express license agreement from
 * NVIDIA Corporation is strictly prohibited.
 *
 * Please refer to the applicable NVIDIA end user license agreement (EULA)
 * associated with this source code for terms and conditions that govern
 * your use of this NVIDIA software.
 *
 */


#ifndef __CPU_BITMAP_H__
#define __CPU_BITMAP_H__

#include "gl_helper.h"

struct CPUBitmap {
    unsigned char    *pixels;
    int     x, y;
    void    *dataBlock;
    void (*bitmapExit)(void*);

    CPUBitmap( int width, int height, void *d = NULL ) {
        pixels = new unsigned char[width * height * 4];
        x = width;
        y = height;
        dataBlock = d;
    }

    ~CPUBitmap() {
        delete [] pixels;
    }

    unsigned char* get_ptr( void ) const   { return pixels; }
    long image_size( void ) const { return x * y * 4; }

    void display_and_exit( void(*e)(void*) = NULL ) {
        CPUBitmap**   bitmap = get_bitmap_ptr();
        *bitmap = this;
        bitmapExit = e;
        // a bug in the Windows GLUT implementation prevents us from
        // passing zero arguments to glutInit()
        int c=1;
        char* dummy = "";
        glutInit( &c, &dummy );
        glutInitDisplayMode( GLUT_SINGLE | GLUT_RGBA );
        glutInitWindowSize( x, y );
        glutCreateWindow( "bitmap" );
        glutKeyboardFunc(Key);
        glutDisplayFunc(Draw);
        glutMainLoop();
    }

     // static method used for glut callbacks
    static CPUBitmap** get_bitmap_ptr( void ) {
        static CPUBitmap   *gBitmap;
        return &gBitmap;
    }

   // static method used for glut callbacks
    static void Key(unsigned char key, int x, int y) {
        switch (key) {
            case 27:
                CPUBitmap*   bitmap = *(get_bitmap_ptr());
                if (bitmap->dataBlock != NULL && bitmap->bitmapExit != NULL)
                    bitmap->bitmapExit( bitmap->dataBlock );
                exit(0);
        }
    }

    // static method used for glut callbacks
    static void Draw( void ) {
        CPUBitmap*   bitmap = *(get_bitmap_ptr());
        glClearColor( 0.0, 0.0, 0.0, 1.0 );
        glClear( GL_COLOR_BUFFER_BIT );
        glDrawPixels( bitmap->x, bitmap->y, GL_RGBA, GL_UNSIGNED_BYTE, bitmap->pixels );
        glFlush();
    }
};

#endif  // __CPU_BITMAP_H__





_______________________________________________________


gpu_anim.h
http://code.google.com/p/snp-gpgpu/source/browse/trunk/f/common/gpu_anim.h?r=4


 
             
/*
 * Copyright 1993-2010 NVIDIA Corporation.  All rights reserved.
 *
 * NVIDIA Corporation and its licensors retain all intellectual property and
 * proprietary rights in and to this software and related documentation.
 * Any use, reproduction, disclosure, or distribution of this software
 * and related documentation without an express license agreement from
 * NVIDIA Corporation is strictly prohibited.
 *
 * Please refer to the applicable NVIDIA end user license agreement (EULA)
 * associated with this source code for terms and conditions that govern
 * your use of this NVIDIA software.
 *
 */


#ifndef __GPU_ANIM_H__
#define __GPU_ANIM_H__

#include "gl_helper.h"

#include "cuda.h"
#include "cuda_gl_interop.h"
#include <iostream>


PFNGLBINDBUFFERARBPROC    glBindBuffer     = NULL;
PFNGLDELETEBUFFERSARBPROC glDeleteBuffers  = NULL;
PFNGLGENBUFFERSARBPROC    glGenBuffers     = NULL;
PFNGLBUFFERDATAARBPROC    glBufferData     = NULL;


struct GPUAnimBitmap {
    GLuint  bufferObj;
    cudaGraphicsResource *resource;
    int     width, height;
    void    *dataBlock;
    void (*fAnim)(uchar4*,void*,int);
    void (*animExit)(void*);
    void (*clickDrag)(void*,int,int,int,int);
    int     dragStartX, dragStartY;

    GPUAnimBitmap( int w, int h, void *d = NULL ) {
        width = w;
        height = h;
        dataBlock = d;
        clickDrag = NULL;

        // first, find a CUDA device and set it to graphic interop
        cudaDeviceProp  prop;
        int dev;
        memset( &prop, 0, sizeof( cudaDeviceProp ) );
        prop.major = 1;
        prop.minor = 0;
        HANDLE_ERROR( cudaChooseDevice( &dev, &prop ) );
        cudaGLSetGLDevice( dev );

        // a bug in the Windows GLUT implementation prevents us from
        // passing zero arguments to glutInit()
        int c=1;
        char* dummy = "";
        glutInit( &c, &dummy );
        glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGBA );
        glutInitWindowSize( width, height );
        glutCreateWindow( "bitmap" );

        glBindBuffer    = (PFNGLBINDBUFFERARBPROC)GET_PROC_ADDRESS("glBindBuffer");
        glDeleteBuffers = (PFNGLDELETEBUFFERSARBPROC)GET_PROC_ADDRESS("glDeleteBuffers");
        glGenBuffers    = (PFNGLGENBUFFERSARBPROC)GET_PROC_ADDRESS("glGenBuffers");
        glBufferData    = (PFNGLBUFFERDATAARBPROC)GET_PROC_ADDRESS("glBufferData");

        glGenBuffers( 1, &bufferObj );
        glBindBuffer( GL_PIXEL_UNPACK_BUFFER_ARB, bufferObj );
        glBufferData( GL_PIXEL_UNPACK_BUFFER_ARB, width * height * 4,
                      NULL, GL_DYNAMIC_DRAW_ARB );

        HANDLE_ERROR( cudaGraphicsGLRegisterBuffer( &resource, bufferObj, cudaGraphicsMapFlagsNone ) );
    }

    ~GPUAnimBitmap() {
        free_resources();
    }

    void free_resources( void ) {
        HANDLE_ERROR( cudaGraphicsUnregisterResource( resource ) );

        glBindBuffer( GL_PIXEL_UNPACK_BUFFER_ARB, 0 );
        glDeleteBuffers( 1, &bufferObj );
    }


    long image_size( void ) const { return width * height * 4; }

    void click_drag( void (*f)(void*,int,int,int,int)) {
        clickDrag = f;
    }

    void anim_and_exit( void (*f)(uchar4*,void*,int), void(*e)(void*) ) {
        GPUAnimBitmap**   bitmap = get_bitmap_ptr();
        *bitmap = this;
        fAnim = f;
        animExit = e;

        glutKeyboardFunc( Key );
        glutDisplayFunc( Draw );
        if (clickDrag != NULL)
            glutMouseFunc( mouse_func );
        glutIdleFunc( idle_func );
        glutMainLoop();
    }

    // static method used for glut callbacks
    static GPUAnimBitmap** get_bitmap_ptr( void ) {
        static GPUAnimBitmap*   gBitmap;
        return &gBitmap;
    }

    // static method used for glut callbacks
    static void mouse_func( int button, int state,
                            int mx, int my ) {
        if (button == GLUT_LEFT_BUTTON) {
            GPUAnimBitmap*   bitmap = *(get_bitmap_ptr());
            if (state == GLUT_DOWN) {
                bitmap->dragStartX = mx;
                bitmap->dragStartY = my;
            } else if (state == GLUT_UP) {
                bitmap->clickDrag( bitmap->dataBlock,
                                   bitmap->dragStartX,
                                   bitmap->dragStartY,
                                   mx, my );
            }
        }
    }

    // static method used for glut callbacks
    static void idle_func( void ) {
        static int ticks = 1;
        GPUAnimBitmap*  bitmap = *(get_bitmap_ptr());
        uchar4*         devPtr;
        size_t  size;

        HANDLE_ERROR( cudaGraphicsMapResources( 1, &(bitmap->resource), NULL ) );
        HANDLE_ERROR( cudaGraphicsResourceGetMappedPointer( (void**)&devPtr, &size, bitmap->resource) );

        bitmap->fAnim( devPtr, bitmap->dataBlock, ticks++ );

        HANDLE_ERROR( cudaGraphicsUnmapResources( 1, &(bitmap->resource), NULL ) );

        glutPostRedisplay();
    }

    // static method used for glut callbacks
    static void Key(unsigned char key, int x, int y) {
        switch (key) {
            case 27:
                GPUAnimBitmap*   bitmap = *(get_bitmap_ptr());
                if (bitmap->animExit)
                    bitmap->animExit( bitmap->dataBlock );
                bitmap->free_resources();
                exit(0);
        }
    }

    // static method used for glut callbacks
    static void Draw( void ) {
        GPUAnimBitmap*   bitmap = *(get_bitmap_ptr());
        glClearColor( 0.0, 0.0, 0.0, 1.0 );
        glClear( GL_COLOR_BUFFER_BIT );
        glDrawPixels( bitmap->width, bitmap->height, GL_RGBA,
                      GL_UNSIGNED_BYTE, 0 );
        glutSwapBuffers();
    }
};


#endif  // __GPU_ANIM_H__