一步一步写一个简单通用的makefile(三)

// newTutorial1.cpp : Defines the entry point for the console application.
//

//#include "stdafx.h"
#include <CL/cl.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <iostream>
#include <fstream>
#include <string.h>
#include <string>
#include <pthread.h>
using namespace std;
#pragma comment (lib,"OpenCL.lib")

#define WIDTH 1920
#define HEIGHT 1080
#define FRAMES 1
typedef unsigned char   uint8_t;

static double now_ms(void) {
  struct timespec res;
  clock_gettime(CLOCK_REALTIME, &res);
  return 1000.0 * res.tv_sec + (double) res.tv_nsec / 1e6;
}


static int filter0(uint8_t *src, uint8_t *dst, uint8_t *ocl, int w, int h) {
  printf("filter 0 ,w=%d, h=%d\n",w, h);
  double start, end;
  int i =1;
  int j =1;
  if(w > WIDTH || h > HEIGHT)
    return 1;
  //start = now_ms();
  for (i = 1; i < h - 1; ++i) {
    for (j = 1; j < w - 1; ++j) {
      int index = j + i * w;
      uint8_t lu = src[index - 1 - w];
      uint8_t lm = src[index - 1];
      uint8_t ld = src[index - 1 + w];
      uint8_t mu = src[index - w];
      uint8_t mm = src[index];
      uint8_t md = src[index + w];
      uint8_t ru = src[index + 1 - w];
      uint8_t rm = src[index + 1];
      uint8_t rd = src[index + 1 + w];
      int sum = lu + lm + ld + mu + mm + md + ru + rm + rd;
     // printf("%d, %d, %d, %d, %d, %d, %d %d, %d,\n",lu, lm, ld, mu, mm, md, ru, rm, rd);
      dst[index] = (uint8_t)sum / 9 + 1;
     // printf(" dst[%d] =%d",index, dst[index]);
      if(ocl[index] != dst[index])
        printf("index[%d] differ \n", index);
    }
  //  printf("\n");
  }
  end = now_ms();
  //printf("filter 0 %f \n", end - start);
  return 0;
}  


//°ÑÎıŸÎÄŒþ¶ÁÈëÒ»?östringÖÐ
int convertToString(const char *filename, std::string& s)
{
    size_t size;
    char*  str;

    std::fstream f(filename, (std::fstream::in | std::fstream::binary));

    if(f.is_open())
    {
        size_t fileSize;
        f.seekg(0, std::fstream::end);
        size = fileSize = (size_t)f.tellg();
        f.seekg(0, std::fstream::beg);

        str = new char[size+1];
        if(!str)
        {
            f.close();
            return NULL;
        }

        f.read(str, fileSize);
        f.close();
        str[size] = ‘\0‘;

        s = str;
        delete[] str;
        return 0;
    }
    printf("Error: Failed to open file %s\n", filename);
    return 1;
}

int main(int argc, char* argv[])
{
  int i, ret;
  double start, end;
  uint8_t * inputBuf;
  uint8_t * dstBuf1;
  uint8_t * dstBuf2;
  inputBuf =(uint8_t *)malloc(WIDTH * HEIGHT * sizeof(uint8_t));
  dstBuf1 =(uint8_t *)malloc(WIDTH * HEIGHT * sizeof(uint8_t));
  dstBuf2 =(uint8_t *)malloc(WIDTH * HEIGHT * sizeof(uint8_t));
  memset(dstBuf1,0,WIDTH * HEIGHT * sizeof(uint8_t));
  memset(dstBuf2,0,WIDTH * HEIGHT * sizeof(uint8_t));

  srand( (unsigned)time( NULL ) ); 
  for(i = 0; i < WIDTH * HEIGHT; i++) {
      inputBuf[i] = rand()%255;
    //printf("[%d] =%d\n", i, inputBuf[i]);  
  }
  
  //return 0;
    cl_uint status;
    cl_platform_id platform;

    //??œšÆœÌš¶ÔÏó
    status = clGetPlatformIDs( 1, &platform, NULL );

    cl_device_id device;

    //??œšGPUÉè±?
    clGetDeviceIDs( platform, CL_DEVICE_TYPE_GPU,
        1,
        &device,
        NULL);
    cl_uint maxComputeUnits;
    status = clGetDeviceInfo(device,CL_DEVICE_MAX_COMPUTE_UNITS,
      sizeof(cl_uint),
      &maxComputeUnits,
      NULL);
    printf("maxComputeUnits = %d\n" ,maxComputeUnits);


    //??œšcontext
    cl_context context = clCreateContext( NULL,
        1,
        &device,
        NULL, NULL, NULL);
    //??œšÃüÁî¶ÓÁÐ
    cl_command_queue queue = clCreateCommandQueue( context,
        device,
        CL_QUEUE_PROFILING_ENABLE, NULL );

    //??œšÈý?öOpenCLÄÚ?æ¶ÔÏó
    cl_mem clinbuf = clCreateBuffer(context,
        CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
        WIDTH*HEIGHT*sizeof(cl_uchar),inputBuf,
        NULL );
    
    cl_mem cloutbuf = clCreateBuffer( context,
        CL_MEM_WRITE_ONLY,
        WIDTH*HEIGHT * sizeof(cl_uchar),
        NULL, NULL );

    const char * filename  = "convolve.cl";
    std::string  sourceStr;
    status = convertToString(filename, sourceStr);
    const char * source    = sourceStr.c_str();
    size_t sourceSize[]    = { strlen(source) };

    //??œš³ÌÐò¶ÔÏó
    cl_program program = clCreateProgramWithSource(
        context, 
        1, 
        &source,
        sourceSize,
        NULL);
    //±àÒë³ÌÐò¶ÔÏó
    status = clBuildProgram( program, 1, &device, NULL, NULL, NULL );
    if(status != 0)
    {
        printf("clBuild failed:%d\n", status);
        char tbuf[0x10000];
        clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG, 0x10000, tbuf, NULL);
        printf("\n%s\n", tbuf);
        return -1;
    }

    cl_int dimx = WIDTH;
    cl_int dimy = HEIGHT;
    cl_event ev;
    cl_kernel kernel;
    cl_ulong startTime, endTime;
    cl_ulong kernelExecTimeNs;
    float *op_data = 0;
    
#if 1
    //??œšKernel¶ÔÏó
     kernel = clCreateKernel( program, "filter", NULL );

    //ÉèÖÃKernel²ÎÊý
    
    clSetKernelArg(kernel, 0, sizeof(cl_mem),  (void *)&clinbuf); 
       clSetKernelArg(kernel, 1, sizeof(cl_int),  (void *)&dimx);
    clSetKernelArg(kernel, 2, sizeof(cl_int),  (void *)&dimy);
    clSetKernelArg(kernel, 3, sizeof(cl_mem),  (void *)&cloutbuf);


    //Set local and global workgroup sizes
    size_t localws[2] = {1, 1} ; 
    size_t globalws[2] = {WIDTH,HEIGHT};

   
    //Ö?ÐÐkernel
    clEnqueueNDRangeKernel( 
        queue ,kernel, 
        2, 0, globalws, NULL, 
        0, NULL, &ev);

    clFinish( queue );
 //ŒÆËãkerenlÖ?ÐÐʱŒä 
    
    clGetEventProfilingInfo(ev, CL_PROFILING_COMMAND_START,
        sizeof(cl_ulong), &startTime, NULL);
    clGetEventProfilingInfo(ev, CL_PROFILING_COMMAND_END,
        sizeof(cl_ulong), &endTime, NULL);
    kernelExecTimeNs = endTime-startTime;
    printf("kernal exec time :%8.6f ms\n ", kernelExecTimeNs*1e-6 );

    //ÊýŸÝ¿œ»ØhostÄÚ?æ
    cl_uchar *ptr;
    ptr = (cl_uchar *) clEnqueueMapBuffer( queue,
        cloutbuf,
        CL_TRUE,
        CL_MAP_READ,
        0,
        WIDTH*HEIGHT * sizeof(cl_uchar),
        0, NULL, NULL, NULL );
   //œá¹ûÑéÖ€£¬ºÍcpuŒÆËãµÄœá¹û±ÈœÏ

    start = now_ms();
    for(i = 0; i< FRAMES; i++) {
      ret = filter0(inputBuf, dstBuf1, ptr,WIDTH, HEIGHT);
      if(ret)
        printf("filter Fail \n");
    }
    end = now_ms();
    printf("filter 0 %f \n", (end - start)/FRAMES);

    //ÑéÖ€GPUŒÆËãœá¹û
/*    for(i = 0; i < M*N; i++)
    {
        //printf("%d, %6.3f,%6.3f\n",i,outbuf[i],op_data[i]);
        if(abs(dstBuf1[i] - dstBuf2[i]) > 0.0001)
        {
            printf("check failed\n");
            break;
        }
    }    
    if(i == M*N)
        printf("check passed\n");   */
  #endif

    if(inputBuf)
        free(inputBuf);
    if(dstBuf1)
        free(dstBuf1);
    if(dstBuf2)
        free(dstBuf2);


    //ÉŸ³ýOpenCL×ÊÔ?¶ÔÏó
    clReleaseMemObject(clinbuf); 
    clReleaseMemObject(cloutbuf);
    clReleaseProgram(program);
    clReleaseCommandQueue(queue);
    clReleaseContext(context);
    return 0;
}