Referência MQL5Trabalhando com OpenCLCLBufferWrite

CLBufferWrite

Escreve para o buffer OpenCL e retorna o número de elementos escritos.

uint  CLBufferWrite(
   int          buffer,                    // Um manipulador para o buffer OpenCL
   const void&  data[],                    // Uma array de valores
   uint         buffer_offset=0,           // Um deslocamento no buffer OpenCL em bites, 0 por padrão
   uint         data_offset=0,             // Um deslocamento na array de elementos, 0 por padrão
   uint         data_count=WHOLE_ARRAY     // O número de valores a partir do array para a escrita, to array inteiro por padrão
   );

Existem também versões para trabalhar com matrizes e vetores.

Escreve os valores do array para o buffer e retorna true se bem-sucedido.

uint  CLBufferWrite(
   int           buffer,                    // Um manipulador para o buffer OpenCL
   uint          buffer_offset,             // O deslocamento no buffer OpenCL em bytes
   matrix<T>     &mat                       // O array de valores para registro no buffer
   );

Escreve valores para o buffer a partir do vetor e retorna true se bem sucedido.

uint  CLBufferWrite(
   int           buffer,                    // Um manipulador para o buffer OpenCL
   uint          buffer_offset,             // O deslocamento no buffer OpenCL em bytes
   vector<T>     &vec                       // O vetor de valores a serem escritos no buffer
   );

Parâmetros

buffer

[in] O manipulador do buffer OpenCL.

data[]

[in] Um array de valores que deve ser escrito no buffer OpenCL. Passado por referência.

buffer_offset

[in] Uma compensação no buffer OpenCL em bites, a partir do qual começa a escrita. Por padrão, a escrita começa com o início do buffer.

data_offset

[in] O índice do primeiro elemento array, começando a partir do qual valores de array são escritos no buffer OpenCL. Por padrão, são tomados os valores desde o início do array.

data_count

[in] O número de valores que devem ser escritos. Todos os valores do array, por padrão.

mat

[out] O array para a leitura dos dados do buffer pode ser de qualquer um dos três tipos – matrix, matrixf ou matrixc.

vec

[out] O vetor de leitura dos dados do buffer pode ser de qualquer um dos três tipos – vector, vectorf ou vectorc.

Valor do Retorno

O número de elementos escritos. 0 (zero) é devolvido em caso de erro. Para obter informações sobre o erro, utilize a função GetLastError().

true quando executado com sucesso ao trabalhar com uma matriz ou vetor, no caso de um erro, ele retorna false.

Observação

Para arrays unidimensionais, o número do elemento, com o qual a leitura de dados para a escrita num buffer de OpenCL começa, é calculado tendo em conta os sinalizadores AS_SERIES.

Um array de duas ou mais dimensões é apresentado como unidimensional. Neste caso, data_offset é o número de elementos que devem ser ignorados na apresentação, e não o número de elementos na primeira dimensão.

Exemplo de multiplicação de arrray por meio do método MatMul e computação paralela em OpenCL

#define M       3000      // O número de filas no primeiro array
#define K       2000      // O número de colunas no primeiro array é igual ao número de filas no segundo
#define N       3000      // O número de colunas no segundo array

//+------------------------------------------------------------------+
const string clSrc=
  "#define N     "+IntegerToString(N)+"                              \r\n"
  "#define K     "+IntegerToString(K)+"                              \r\n"
  "                                                                  \r\n"
  "__kernel void matricesMul( __global float *in1,                   \r\n"
  "                           __global float *in2,                   \r\n"
  "                           __global float *out  )                 \r\n"
  "{                                                                 \r\n"
  "  int m = get_global_id( 0 );                                     \r\n"
  "  int n = get_global_id( 1 );                                     \r\n"
  "  float sum = 0.0;                                                \r\n"
  "  for( int k = 0; k < K; k ++ )                                   \r\n"
  "     sum += in1[ m * K + k ] * in2[ k * N + n ];                  \r\n"
  "  out[ m * N + n ] = sum;                                         \r\n"
  "}                                                                 \r\n";
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
{
//--- Inicializa o gerador de números aleatórios
  MathSrand((int)TimeCurrent());
//--- preenche o array de um determinado tamanho com valores aleatórios
  matrixf mat1(M, K, MatrixRandom) ;    // O primeiro array
  matrixf mat2(K, N, MatrixRandom);     // O segundo arraty

//--- Calcula o produto dos arrays de uma maneira ingênua
  uint start=GetTickCount();
  matrixf matrix_naive=matrixf::Zeros(M, N);// aqui escrevemos o resultado da multiplicação de dois arrays
  for(int m=0; m<M; m++)
    for(int k=0; k<K; k++)
      for(int n=0; n<N; n++)
        matrix_naive[m][n]+=mat1[m][k]*mat2[k][n];
  uint time_naive=GetTickCount()-start;

//--- Calcula o produto dos arrays por meio de MatMull
  start=GetTickCount();
  matrixf matrix_matmul=mat1.MatMul(mat2);
  uint time_matmul=GetTickCount()-start;

//--- Calculamos o produto de dois arrays em OpenCL
  matrixf matrix_opencl=matrixf::Zeros(M, N);
  int cl_ctx;             // O manipulador do contexto
  if((cl_ctx=CLContextCreate(CL_USE_GPU_ONLY))==INVALID_HANDLE)
   {
    Print("OpenCL não encontrado, saímos");
    return;
   }
  int cl_prg;             // O manipulador do programa
  int cl_krn;             // O manipulador do kernel
  int cl_mem_in1;         // O manipulador do primeiro buffer (de saída)
  int cl_mem_in2;         // O manipulador do segundo buffer (de saída)
  int cl_mem_out;         // O manipulador do terceiro buffer (de saída)
//--- Cria o programa e o kernel
  cl_prg = CLProgramCreate(cl_ctx, clSrc);
  cl_krn = CLKernelCreate(cl_prg, "matricesMul");
//--- Cria os três buffers para os três arrays
  cl_mem_in1=CLBufferCreate(cl_ctx, M*K*sizeof(float), CL_MEM_READ_WRITE);
  cl_mem_in2=CLBufferCreate(cl_ctx, K*N*sizeof(float), CL_MEM_READ_WRITE);
//--- terceiro array - de saída
  cl_mem_out=CLBufferCreate(cl_ctx, M*N*sizeof(float), CL_MEM_READ_WRITE);
//--- Define o argumento do kernel
  CLSetKernelArgMem(cl_krn, 0, cl_mem_in1);
  CLSetKernelArgMem(cl_krn, 1, cl_mem_in2);
  CLSetKernelArgMem(cl_krn, 2, cl_mem_out);
//--- Escreve os arrays nos buffers do dispositivo
  CLBufferWrite(cl_mem_in1, 0, mat1);
  CLBufferWrite(cl_mem_in2, 0, mat2);
  CLBufferWrite(cl_mem_out, 0, matrix_opencl);
//--- Início do tempo de execução do código OpenCL
  start=GetTickCount();
//--- Define os parâmetros da área de trabalho e executa o programa OpenCL
  uint  offs[2] = {0, 0};
  uint works[2] = {M, N};
  start=GetTickCount();
  bool ex=CLExecute(cl_krn, 2, offs, works);
//--- Calcula o resultado no array
  if(CLBufferRead(cl_mem_out, 0, matrix_opencl))
    PrintFormat("Matriz lida [%d x %d]: ", matrix_opencl.Rows(), matrix_opencl.Cols());
   else
      Print("CLBufferRead(cl_mem_out, 0, matrix_opencl failed. Error ",GetLastError());
  uint time_opencl=GetTickCount()-start;
  Print("Comparamos o tempo de cálculo com cada método");
  PrintFormat("Naive product time = %d ms",time_naive);
  PrintFormat("MatMul product time = %d ms",time_matmul);
  PrintFormat("OpenCl product time = %d ms",time_opencl);
//--- Libera todos os contextos OpenCL
  CLFreeAll(cl_ctx, cl_prg, cl_krn, cl_mem_in1, cl_mem_in2, cl_mem_out);

//--- Compara todos os arrays de resultados obtidos uns com os outros
  Print("Quantos erros de divergência existem entre os arrays de resultados?");
  ulong errors=matrix_naive.Compare(matrix_matmul,(float)1e-12);
  Print("matrix_direct.Compare(matrix_matmul,1e-12)=",errors);
  errors=matrix_matmul.Compare(matrix_opencl,float(1e-12));
  Print("matrix_matmul.Compare(matrix_opencl,1e-12)=",errors);
/*
  Resultado:

   Matriz lida [3000 x 3000]:
  Compara o tempo de cálculo com cada método
   Naive product time = 54750 ms
   MatMul product time = 4578 ms
   OpenCl product time = 922 ms
   Quantos erros de divergência existem entre os arrays de resultados?
   matrix_direct.Compare(matrix_matmul,1e-12)=0
   matrix_matmul.Compare(matrix_opencl,1e-12)=0
*/
}
//+------------------------------------------------------------------+
//| Preenche o array com valores aleatórios                          |
//+------------------------------------------------------------------+
void MatrixRandom(matrixf& m)
{
  for(ulong r=0; r<m.Rows(); r++)
   {
    for(ulong c=0; c<m.Cols(); c++)
     {
      m[r][c]=(float)((MathRand()-16383.5)/32767.);
     }
   }
}
//+------------------------------------------------------------------+
//| Libera todos os contextos OpenCL                                   |
//+------------------------------------------------------------------+
void CLFreeAll(int cl_ctx, int cl_prg, int cl_krn,
               int cl_mem_in1, int cl_mem_in2, int cl_mem_out)
{
//--- Remove qualquer contexto OpenCL criado em ordem inversa
  CLBufferFree(cl_mem_in1);
  CLBufferFree(cl_mem_in2);
  CLBufferFree(cl_mem_out);
  CLKernelFree(cl_krn);
  CLProgramFree(cl_prg);
  CLContextFree(cl_ctx);
}

CLBufferFree

CLBufferRead