OpenCL 操作

ENUM_OPENCL_HANDLE_TYPE  CLHandleType(
  int  handle     // OpenCL オブジェクトのハンドル
  );

long  CLGetInfoInteger(
  int  handle,                           // OpenCL オブジェクトのハンドルまたはOpenCL デバイスの番号
  ENUM_OPENCL_PROPERTY_INTEGER  prop     // リクエストされたプロパティ
  );

void OnStart()
 {
  int cl_ctx;
//— OpenCL コンテキストを初期化する
  if((cl_ctx=CLContextCreate(CL_USE_GPU_ONLY))==INVALID_HANDLE)
    {
    Print("OpenCL not found");
    return;
    }
//— OpenCL デバイスの一般的な情報を表示する
  Print("OpenCL type: ",EnumToString((ENUM_CL_DEVICE_TYPE)CLGetInfoInteger(cl_ctx,CL_DEVICE_TYPE)));
  Print("OpenCL vendor ID: ",CLGetInfoInteger(cl_ctx,CL_DEVICE_VENDOR_ID));
  Print("OpenCL units: ",CLGetInfoInteger(cl_ctx,CL_DEVICE_MAX_COMPUTE_UNITS));
  Print("OpenCL freq: ",CLGetInfoInteger(cl_ctx,CL_DEVICE_MAX_CLOCK_FREQUENCY)," MHz");
  Print("OpenCL global mem: ",CLGetInfoInteger(cl_ctx,CL_DEVICE_GLOBAL_MEM_SIZE)," bytes");
  Print("OpenCL local mem: ",CLGetInfoInteger(cl_ctx,CL_DEVICE_LOCAL_MEM_SIZE)," bytes");
//—
 }

bool  CLGetInfoString(
  int  handle,                           // OpenCL オブジェクトハンドルまたはOpenCL デバイス番号
  ENUM_OPENCL_PROPERTY_STRING prop,     // リクエストされたプロパティ
  string&  value                         // 参照された文字列
  );

void OnStart()
 {
  int cl_ctx;
  string str;
//— OpenCL コンテキストを初期化する
  if((cl_ctx=CLContextCreate(CL_USE_GPU_ONLY))==INVALID_HANDLE)
    {
    Print("OpenCL not found");
    return;
    }
//— プラットフォームの情報を表示する
  if(CLGetInfoString(cl_ctx,CL_PLATFORM_NAME,str))
    Print("OpenCL platform name: ",str);
  if(CLGetInfoString(cl_ctx,CL_PLATFORM_VENDOR,str))
    Print("OpenCL platform vendor: ",str);
  if(CLGetInfoString(cl_ctx,CL_PLATFORM_VERSION,str))
    Print("OpenCL platform ver: ",str);
  if(CLGetInfoString(cl_ctx,CL_PLATFORM_PROFILE,str))
    Print("OpenCL platform profile: ",str);
  if(CLGetInfoString(cl_ctx,CL_PLATFORM_EXTENSIONS,str))
    Print("OpenCL platform ext: ",str);
//— デバイスの情報を表示する
  if(CLGetInfoString(cl_ctx,CL_DEVICE_NAME,str))
    Print("OpenCL device name: ",str);
  if(CLGetInfoString(cl_ctx,CL_DEVICE_PROFILE,str))
    Print("OpenCL device profile: ",str);
  if(CLGetInfoString(cl_ctx,CL_DEVICE_BUILT_IN_KERNELS,str))
    Print("OpenCL device kernels: ",str);
  if(CLGetInfoString(cl_ctx,CL_DEVICE_EXTENSIONS,str))
    Print("OpenCL device ext: ",str);
  if(CLGetInfoString(cl_ctx,CL_DEVICE_VENDOR,str))
    Print("OpenCL device vendor: ",str);
  if(CLGetInfoString(cl_ctx,CL_DEVICE_VERSION,str))
    Print("OpenCL device ver: ",str);
  if(CLGetInfoString(cl_ctx,CL_DEVICE_OPENCL_C_VERSION,str))
    Print("OpenCL open c ver: ",str);
//— OpenCL デバイスの一般的な情報を表示する
  Print("OpenCL type: ",EnumToString((ENUM_CL_DEVICE_TYPE)CLGetInfoInteger(cl_ctx,CL_DEVICE_TYPE)));
  Print("OpenCL vendor ID: ",CLGetInfoInteger(cl_ctx,CL_DEVICE_VENDOR_ID));
  Print("OpenCL units: ",CLGetInfoInteger(cl_ctx,CL_DEVICE_MAX_COMPUTE_UNITS));
  Print("OpenCL freq: ",CLGetInfoInteger(cl_ctx,CL_DEVICE_MAX_CLOCK_FREQUENCY));
  Print("OpenCL global mem: ",CLGetInfoInteger(cl_ctx,CL_DEVICE_GLOBAL_MEM_SIZE));
  Print("OpenCL local mem: ",CLGetInfoInteger(cl_ctx,CL_DEVICE_LOCAL_MEM_SIZE));
//—
 }

int  CLContextCreate(
  int  device     // OpenCL デバイスのシリアル番号またはマクロ
  );

void  CLContextFree(
  int  context    // OpenCL コンテンツのハンドル
  );

bool  CLGetDeviceInfo(
  int    handle,         // OpenCL デバイスハンドル
  int     property_id,     // リクエストされたプロパティ識別子
  uchar& data[],         // データを受け取る配列
  uint&   size             // 配列要素のシフト（デフォルトでは0
  );

void OnStart()
 {
//—
  int dCount= CLGetInfoInteger(0,CL_DEVICE_COUNT);
  for(int i = 0; i<dCount; i++)
    {
    int clCtx=CLContextCreate(i);
    if(clCtx == -1)
        Print("ERROR in CLContextCreate");
    string device;
     CLGetInfoString(clCtx,CL_DEVICE_NAME,device);
    Print(i,": ",device);
    uchar data[1024];
    uint size;
    CLGetDeviceInfo(clCtx,CL_DEVICE_VENDOR,data,size);
    Print("size = ",size);
    string str=CharArrayToString(data);
    Print(str);
    }
 }
//— エキスパート操作ログエントリーの例
//  2013.07.24 10:50:48     opencl (EURUSD,H1)      2: Advanced Micro Devices, Inc.
//  2013.07.24 10:50:48     opencl (EURUSD,H1)      size = 32
//  2013.07.24 10:50:48     opencl (EURUSD,H1)      Tahiti
//  2013.07.24 10:50:48     opencl (EURUSD,H1)      Intel(R) Corporation
//  2013.07.24 10:50:48     opencl (EURUSD,H1)      size = 21
//  2013.07.24 10:50:48     opencl (EURUSD,H1)      1:        Intel(R) Core(TM) i7-3770 CPU @ 3.40GHz
//  2013.07.24 10:50:48     opencl (EURUSD,H1)      NVIDIA Corporation
//  2013.07.24 10:50:48     opencl (EURUSD,H1)      size = 19
//  2013.07.24 10:50:48     opencl (EURUSD,H1)      0: GeForce GTX 580

int  CLProgramCreate(
  int          context,    // OpenCL コンテキストのハンドル
  const string  source      // ソースコード
  );

int  CLProgramCreate(
  int          context,    // OpenCL コンテキストのハンドル
  const string  source,      // ソースコード
  string      &build_log    // コンパイルログを受け取る文字列
  );

//+——————————————————————+
//| OpenCL カーネル                                                     |
//+——————————————————————+
const string
cl_src=
      //— デフォルトでは double をサポートしない GPU がある
      //— cl_khr_fp64 directive が double の操作を有効にするために使用される
      "#pragma OPENCL EXTENSION cl_khr_fp64 : enable      \r\n"
      //— OpenCL カーネル関数
      "__kernel void Test_GPU(__global double *data,      \r\n"
      "                       const    int N,             \r\n"
      "                       const    int total_arrays)  \r\n"
      "  {                                                \r\n"
      "   uint kernel_index=get_global_id(0);             \r\n"
      "   if (kernel_index>total_arrays) return;          \r\n"
      "   uint local_start_offset=kernel_index*N;         \r\n"
      "   for(int i=0; i<N; i++)                          \r\n"
      "     {                                             \r\n"
      "       data[i+local_start_offset] *= 2.0;          \r\n"
      "     }                                             \r\n"
      "  }                                                \r\n";
//+——————————————————————+
//| Test_CPU                                                         |
//+——————————————————————+
bool Test_CPU(double &data[],const int N,const int id,const int total_arrays)
 {
//— 配列サイズをチェックする
  if(ArraySize(data)==0) return(false);
//— 配列インデックスをチェックする
  if(id>total_arrays) return(false);
//— インデックス id の配列のローカルオフセットを計算する
  int local_start_offset=id*N;
//— 要素を二倍にする
  for(int i=0; i<N; i++)
    {
     data[i+local_start_offset]*=2.0;
    }
  return true;
 }
//—
#define ARRAY_SIZE   100 // 配列サイズ
#define TOTAL_ARRAYS 5   // 全ての配列
//— OpenCL ハンドル
int cl_ctx; // OpenCL コンテキストハンドル
int cl_prg; // OpenCL プログラムハンドル
int cl_krn; // OpenCL カーネルハンドル
int cl_mem; // OpenCL バッファハンドル
//—
double DataArray1[]; // CPU 計算のためのデータ配列
double DataArray2[]; // GPU 計算のためのデータ配列
//+——————————————————————+
//| スクリプトプログラムを開始する関数                                          |
//+——————————————————————+
int OnStart()
 {
//— OpenCL オブジェクトを初期化する
//— OpenCL コンテキストを作成する
  if((cl_ctx=CLContextCreate())==INVALID_HANDLE)
    {
    Print("OpenCL not found. Error=",GetLastError());
    return(1);
    }
//— OpenCL プログラムを作成する
  if((cl_prg=CLProgramCreate(cl_ctx,cl_src))==INVALID_HANDLE)
    {
    CLContextFree(cl_ctx);
    Print("OpenCL program create failed. Error=",GetLastError());
    return(1);
    }
//— OpenCL カーネルを作成する
  if((cl_krn=CLKernelCreate(cl_prg,"Test_GPU"))==INVALID_HANDLE)
    {
    CLProgramFree(cl_prg);
    CLContextFree(cl_ctx);
    Print("OpenCL kernel create failed. Error=",GetLastError());
    return(1);
    }
//— OpenCL バッファを作成する
  if((cl_mem=CLBufferCreate(cl_ctx,ARRAY_SIZE*TOTAL_ARRAYS*sizeof(double),CL_MEM_READ_WRITE))==INVALID_HANDLE)
    {
    CLKernelFree(cl_krn);
    CLProgramFree(cl_prg);
    CLContextFree(cl_ctx);
    Print("OpenCL buffer create failed. Error=",GetLastError());
    return(1);
    }
//— OpenCL カーネルの定数パラメータを設定する
  CLSetKernelArgMem(cl_krn,0,cl_mem);
  CLSetKernelArg(cl_krn,1,ARRAY_SIZE);
  CLSetKernelArg(cl_krn,2,TOTAL_ARRAYS);
//— データ配列を準備する
  ArrayResize(DataArray1,ARRAY_SIZE*TOTAL_ARRAYS);
  ArrayResize(DataArray2,ARRAY_SIZE*TOTAL_ARRAYS);
//— データに配列を書き込む
  for(int j=0; j<TOTAL_ARRAYS; j++)
    {
    //— j 番目の配列のローカル開始オフセットを計算する
    uint local_offset=j*ARRAY_SIZE;
    //— インデックス j の配列を準備する
    for(int i=0; i<ARRAY_SIZE; i++)
       {
        //— MathCos(i+j) の結果を配列に書き込む
        DataArray1[i+local_offset]=MathCos(i+j);
        DataArray2[i+local_offset]=MathCos(i+j);
       }
    };
//— CPU 計算をテストする
  for(int j=0; j<TOTAL_ARRAYS; j++)
    {
    //— インデックス j の配列の計算
     Test_CPU(DataArray1,ARRAY_SIZE,j,TOTAL_ARRAYS);
    }
//— CLExecute パラメータを準備する
  uint  offset[]={0};
//— グローバルワークサイズ
  uint  work[]={TOTAL_ARRAYS};
//— OpenCL バッファにデータを書く
  CLBufferWrite(cl_mem,DataArray2);
//— OpenCL カーネルを実行する
  CLExecute(cl_krn,1,offset,work);
//— OpenCL バッファからデータを読む
  CLBufferRead(cl_mem,DataArray2);
//— エラーの合計
  double total_error=0;
//— 結果を比較してエラーを計算する
  for(int j=0; j<TOTAL_ARRAYS; j++)
    {
    //— j 番目の配列のローカルオフセットを計算する
    uint local_offset=j*ARRAY_SIZE;
    //— 結果を比較する
    for(int i=0; i<ARRAY_SIZE; i++)
       {
        double v1=DataArray1[i+local_offset];
        double v2=DataArray2[i+local_offset];
        double delta=MathAbs(v2-v1);
        total_error+=delta;
        //— 最初と最後の配列を表示する
        if((j==0) || (j==TOTAL_ARRAYS-1))
          PrintFormat("array %d of %d, element [%d]:  %f, %f, [error]=%f",j+1,TOTAL_ARRAYS,i,v1,v2,delta);
       }
    }
  PrintFormat("Total error: %f",total_error);
//— OpenCL オブジェクトを削除する
//— OpenCL バッファを解放する
  CLBufferFree(cl_mem);
//— OpenCL カーネルを解放する
  CLKernelFree(cl_krn);
//— OpenCL プログラムを解放する
  CLProgramFree(cl_prg);
//— OpenCL コンテキストを解放する
  CLContextFree(cl_ctx);
//—
  return(0);
 }

void  CLProgramFree(
  int  program    // OpenCL オブジェクトのハンドル
  );

int  CLKernelCreate(
  int          program,        // OpenCL オブジェクトのハンドル
  const string  kernel_name     // カーネル名
  );

void  CLKernelFree(
  int  kernel    // OpenCL プログラムカーネルのハンドル
  );

bool  CLSetKernelArg(
  int  kernel,        // OpenCL プログラムカーネルのハンドル
  uint arg_index,     // OpenCL 関数の引数の番号
  void  arg_value     // ソースコード
  );

bool  CLSetKernelArgMem(
  int  kernel,          // OpenCL プログラムカーネルのハンドル
  uint arg_index,        // OpenCL 関数の引数の番号
  int  cl_mem_handle     // OpenCL バッファハンドル
  );

bool  CLSetKernelArgMemLocal(
  int    kernel,          // OpenCLプログラムのカーネルへのハンドル
  uint   arg_index,        // OpenCL関数の引数の数
  ulong  local_mem_size   // バッファサイズ
  );

int  CLBufferCreate(
  int  context,    // OpenCL コンテンツのハンドル
  uint size,        // バッファサイズ
  uint  flags       // OpenCL バッファのプロパティを指定するフラグの組み合わせ
  );

void  CLBufferFree(
  int  buffer    // OpenCL バッファハンドル
  );

uint  CLBufferWrite(
  int          buffer,                   // OpenCL バッファハンドル
  const void&  data[],                   // 値の配列
  uint         buffer_offset=0,           // OpenCL バッファ内のバイト単位のオフセット（デフォルトで 0）
  uint         data_offset=0,             // OpenCL バッファ内の要素数でのオフセット（デフォルトで 0）
  uint        data_count=WHOLE_ARRAY     // 書かれる配列の値の数（デフォルトでは配列全体）
  );

uint  CLBufferRead(
  int          buffer,                   // OpenCL バッファハンドル
  const void&  data[],                   // 値の配列
  uint         buffer_offset=0,           // OpenCL バッファ内のバイト単位のオフセット（デフォルトで 0）
  uint         data_offset=0,             // OpenCL バッファ内の要素数でのオフセット（デフォルトで 0）
  uint        data_count=WHOLE_ARRAY     // バッファから読まれる値の数（デフォルトではバッファ全体）
  );

bool  CLExecute(
  int          kernel                   // OpenCL プログラムカーネルのハンドル
  );

bool  CLExecute(
  int          kernel,                  // OpenCL プログラムカーネルのハンドル
  uint        work_dim,                // 作業空間の寸法
  const uint&  global_work_offset[],    // 作業空間の初期オフセット
  const uint&  global_work_size[]        // 作業の数
  );

bool  CLExecute(
  int          kernel,                  // OpenCL プログラムカーネルのハンドル
  uint        work_dim,                // 作業空間の寸法
  const uint&  global_work_offset[],    // 作業空間の初期オフセット
  const uint&  global_work_size[],      // 作業の数
  const uint&  local_work_size[]        // ローカルグループの作業数
  );

int  CLExecutionStatus(
  int  kernel           // OpenCLプログラムのカーネルへのハンドル
  );