exampleOpenCLVectorAdd.cpp

/* 
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003, 2004    (see file CONTACTS for details)
  Multimediale Systeme der Informationsverarbeitung
  Institut fuer Informatik
  Christian-Albrechts-Universitaet Kiel


BIAS is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

BIAS 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include <OpenCLFramework/clfContext.hh>
#include <iostream>

using namespace BIAS;
using namespace std;

/**
 * @brief the simple example from all the internet tutorials for using opencl
 * 
 * in this example, we create two vectors with 1000 elements each. we then
 * add them together with opencl and store the result in a third vector
 * (C = A+b)
 *
 * @author fkellner 06/11
 */
int main() {
  // initialize vectors A and B (such that the sum of each element is 1000
  const int LIST_SIZE = 1000;
  int *A = new int[LIST_SIZE]; 
  int *B = new int[LIST_SIZE];
  for(int i = 0; i < LIST_SIZE; i++) {
      A[i] = i;
      B[i] = LIST_SIZE - i;
  }
  // create vector to store result
  int *C = new int[LIST_SIZE];

  // try/catch of OpenCLException is strongly recommended!
  try {
    // create context on first GPU found
    clfContext context;
    // print some info
    context.PrintPlatformsInfo();
    context.PrintDeviceInfo();
    
    // create a program in this context
    clfProgram *program = context.CreateProgram();
    
    // this is the source code for our compute kernel
    string source = ""
        "__kernel void vector_add(__global const int *A, __global const int *B, __global int *C) {\n"
        "  // element index\n"
        "  size_t v = get_global_id(0);\n"
        "  C[v] = A[v]+B[v];\n"
        "}\n";
    
    // add code to our program
    program->AddSourceFromString(source);
    // compile program
    program->Build();
    // we want to use the vector_add kernel
    program->AddKernel("vector_add");
    
    // allocate opencl buffers in the context
    clfBuffer *bufferA = context.CreateBuffer();
    bufferA->Allocate(LIST_SIZE * sizeof(int), true, false);
    clfBuffer *bufferB = context.CreateBuffer();
    bufferB->Allocate(LIST_SIZE * sizeof(int), true, false);
    clfBuffer *bufferC = context.CreateBuffer();
    bufferC->Allocate(LIST_SIZE * sizeof(int), false, true);
    // now write our local memory to the buffers
    // note that the Allocate functions allow different means of doing this
    bufferA->WriteToBuffer(A);
    bufferB->WriteToBuffer(B);
    
    // set the arguments of compute kernel vector_add. 
    program->KernelSetArgument( "vector_add", 0, *bufferA );
    program->KernelSetArgument( "vector_add", 1, *bufferB );
    program->KernelSetArgument( "vector_add", 2, *bufferC );
    
    // run the vector_add kernel on 1000 elements. each thread will handle one element
    // which is not very efficient! 
    context.RunOn1DRange( *program, "vector_add", LIST_SIZE);
    
    // read the result back to host memory
    bufferC->ReadFromBuffer(C);
    
    // check if each element of C is now 1000
    bool success = true;
    for(int i = 0; i < LIST_SIZE; i ++) {
      if (C[i] != 1000) {
        success = false;
      }
    }
    if (success) {
      cout << "computation successful." << endl;
    } else {
      cout << "error in computation!" << endl;
    }
    
  } catch (clfException &err) {
    // the detailed error string
    cout << err.GetDetailedString() << endl;
  }

  return 0;
}