test/loader_test/test_buffer_object.c

   1 #include <stdlib.h>
   2
   3 #include <CL/cl.h>
   4 #include "param_struct.h"
   5 #include <platform/icd_test_log.h>
   6
   7 extern cl_mem buffer;
   8 extern cl_command_queue command_queue;
   9 extern cl_event event;
  10
  11 static int ret_val;
  12
  13 extern void CL_CALLBACK setmemobjectdestructor_callback(cl_mem _a, void* _b);
  14
  15 const struct clEnqueueReadBuffer_st clEnqueueReadBufferData[NUM_ITEMS_clEnqueueReadBuffer] =
  16 {
  17     {NULL, NULL, 0, 0, 0, NULL, 0, NULL, NULL}
  18 };
  19
  20 const struct clEnqueueWriteBuffer_st clEnqueueWriteBufferData[NUM_ITEMS_clEnqueueWriteBuffer] =
  21 {
  22     {NULL, NULL, 0, 0, 0, NULL, 0, NULL, NULL}
  23 };
  24
  25 const struct clEnqueueReadBufferRect_st clEnqueueReadBufferRectData[NUM_ITEMS_clEnqueueReadBufferRect] =
  26 {
  27     {NULL, NULL, 0, NULL, NULL, NULL, 0, 0, 0, 0, NULL, 0, NULL, NULL}
  28 };
  29
  30 const struct clEnqueueWriteBufferRect_st clEnqueueWriteBufferRectData[NUM_ITEMS_clEnqueueWriteBufferRect] =
  31 {
  32     {NULL, NULL, 0, NULL, NULL, NULL, 0, 0, 0, 0, NULL, 0, NULL, NULL}
  33 };
  34
  35 const struct clEnqueueFillBuffer_st clEnqueueFillBufferData[NUM_ITEMS_clEnqueueFillBuffer] =
  36 {
  37     {NULL, NULL, NULL, 0, 0, 0, 0, NULL, NULL}
  38 };
  39
  40 const struct clEnqueueCopyBuffer_st clEnqueueCopyBufferData[NUM_ITEMS_clEnqueueCopyBuffer] =
  41 {
  42     {NULL, NULL, NULL, 0, 0, 0, 0, NULL, NULL}
  43 };
  44
  45 const struct clEnqueueCopyBufferRect_st clEnqueueCopyBufferRectData[NUM_ITEMS_clEnqueueCopyBufferRect] =
  46 {
  47     {NULL, NULL, NULL, NULL, NULL, NULL, 0, 0, 0, 0, 0, NULL, NULL}
  48 };
  49
  50 const struct clEnqueueMapBuffer_st clEnqueueMapBufferData[NUM_ITEMS_clEnqueueMapBuffer] =
  51 {
  52     {NULL, NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL}
  53 };
  54
  55 const struct clRetainMemObject_st clRetainMemObjectData[NUM_ITEMS_clRetainMemObject] =
  56 {
  57     {NULL}
  58 };
  59
  60 const struct clSetMemObjectDestructorCallback_st clSetMemObjectDestructorCallbackData[NUM_ITEMS_clSetMemObjectDestructorCallback] =
  61 {
  62     {NULL, setmemobjectdestructor_callback, NULL}
  63 };
  64
  65 const struct clEnqueueUnmapMemObject_st clEnqueueUnmapMemObjectData[NUM_ITEMS_clEnqueueUnmapMemObject] =
  66 {
  67     {NULL, NULL, NULL, 0, NULL, NULL}
  68 };
  69
  70 const struct clGetMemObjectInfo_st clGetMemObjectInfoData[NUM_ITEMS_clGetMemObjectInfo] =
  71 {
  72     {NULL, 0, 0, NULL, NULL}
  73 };
  74
  75 int test_clEnqueueReadBuffer(const struct clEnqueueReadBuffer_st *data)
  76 {
  77     test_icd_app_log("clEnqueueReadBuffer(%p, %p, %u, %u, %u, %p, %u, %p, %p)\n",
  78                      command_queue,
  79                      buffer,
  80                      data->blocking_read,
  81                      data->offset,
  82                      data->cb,
  83                      data->ptr,
  84                      data->num_events_in_wait_list,
  85                      data->event_wait_list,
  86                      &event);
  87
  88     ret_val=clEnqueueReadBuffer(command_queue,
  89                                 buffer,
  90                                 data->blocking_read,
  91                                 data->offset,
  92                                 data->cb,
  93                                 data->ptr,
  94                                 data->num_events_in_wait_list,
  95                                 data->event_wait_list,
  96                                 &event);
  97
  98     test_icd_app_log("Value returned: %d\n", ret_val);
  99
 100     return 0;
 101 }
 102
 103 int test_clEnqueueWriteBuffer(const struct clEnqueueWriteBuffer_st *data)
 104 {
 105     test_icd_app_log("clEnqueueWriteBuffer(%p, %p, %u, %u, %u, %p, %u, %p, %p)\n",
 106                      command_queue,
 107                      buffer,
 108                      data->blocking_write,
 109                      data->offset,
 110                      data->cb,
 111                      data->ptr,
 112                      data->num_events_in_wait_list,
 113                      data->event_wait_list,
 114                      &event);
 115
 116     ret_val=clEnqueueWriteBuffer(command_queue,
 117                                 buffer,
 118                                 data->blocking_write,
 119                                 data->offset,
 120                                 data->cb,
 121                                 data->ptr,
 122                                 data->num_events_in_wait_list,
 123                                 data->event_wait_list,
 124                                 &event);
 125
 126     test_icd_app_log("Value returned: %d\n", ret_val);
 127
 128     return 0;
 129 }
 130
 131 int test_clEnqueueReadBufferRect(const struct clEnqueueReadBufferRect_st *data)
 132 {
 133     test_icd_app_log("clEnqueueReadBufferRect(%p, %p, %u, %p, %p, %p, %u, %u, %u, %u, %p, %u, %p, %p)\n",
 134                      command_queue,
 135                      buffer,
 136                      data->blocking_read,
 137                      data->buffer_offset,
 138                      data->host_offset,
 139                      data->region,
 140                      data->buffer_row_pitch,
 141                      data->buffer_slice_pitch,
 142                      data->host_row_pitch,
 143                      data->host_slice_pitch,
 144                      data->ptr,
 145                      data->num_events_in_wait_list,
 146                      data->event_wait_list,
 147                      &event);
 148
 149     ret_val=clEnqueueReadBufferRect(command_queue,
 150                                     buffer,
 151                                     data->blocking_read,
 152                                     data->buffer_offset,
 153                                     data->host_offset,
 154                                     data->region,
 155                                     data->buffer_row_pitch,
 156                                     data->buffer_slice_pitch,
 157                                     data->host_row_pitch,
 158                                     data->host_slice_pitch,
 159                                     data->ptr,
 160                                     data->num_events_in_wait_list,
 161                                     data->event_wait_list,
 162                                     &event);
 163
 164     test_icd_app_log("Value returned: %d\n", ret_val);
 165
 166     return 0;
 167
 168 }
 169
 170 int test_clEnqueueWriteBufferRect(const struct clEnqueueWriteBufferRect_st *data)
 171 {
 172     test_icd_app_log("clEnqueueWriteBufferRect(%p, %p, %u, %p, %p, %p, %u, %u, %u, %u, %p, %u, %p, %p)\n",
 173                      command_queue,
 174                      buffer,
 175                      data->blocking_write,
 176                      data->buffer_offset,
 177                      data->host_offset,
 178                      data->region,
 179                      data->buffer_row_pitch,
 180                      data->buffer_slice_pitch,
 181                      data->host_row_pitch,
 182                      data->host_slice_pitch,
 183                      data->ptr,
 184                      data->num_events_in_wait_list,
 185                      data->event_wait_list,
 186                      &event);
 187
 188     ret_val=clEnqueueWriteBufferRect(command_queue,
 189                                     buffer,
 190                                     data->blocking_write,
 191                                     data->buffer_offset,
 192                                     data->host_offset,
 193                                     data->region,
 194                                     data->buffer_row_pitch,
 195                                     data->buffer_slice_pitch,
 196                                     data->host_row_pitch,
 197                                     data->host_slice_pitch,
 198                                     data->ptr,
 199                                     data->num_events_in_wait_list,
 200                                     data->event_wait_list,
 201                                     &event);
 202
 203     test_icd_app_log("Value returned: %d\n", ret_val);
 204
 205     return 0;
 206 }
 207
 208 int test_clEnqueueFillBuffer(const struct clEnqueueFillBuffer_st *data)
 209 {
 210     test_icd_app_log("clEnqueueFillBuffer(%p, %p, %p, %u, %u, %u, %u, %p, %p)\n",
 211                      command_queue,
 212                      buffer,
 213                      data->pattern,
 214                      data->pattern_size,
 215                      data->offset,
 216                      data->cb,
 217                      data->num_events_in_wait_list,
 218                      data->event_wait_list,
 219                      &event);
 220
 221      ret_val=clEnqueueFillBuffer(command_queue,
 222                                 buffer,
 223                                 data->pattern,
 224                                 data->pattern_size,
 225                                 data->offset,
 226                                 data->cb,
 227                                 data->num_events_in_wait_list,
 228                                 data->event_wait_list,
 229                                 &event);
 230
 231     test_icd_app_log("Value returned: %d\n", ret_val);
 232
 233     return 0;
 234
 235 }
 236
 237 int test_clEnqueueCopyBuffer(const struct clEnqueueCopyBuffer_st *data)
 238 {
 239     test_icd_app_log("clEnqueueCopyBuffer(%p, %p, %p, %u, %u, %u, %u, %p, %p)\n",
 240                      command_queue,
 241                      data->src_buffer,
 242                      buffer,
 243                      data->src_offset,
 244                      data->dst_offset,
 245                      data->cb,
 246                      data->num_events_in_wait_list,
 247                      data->event_wait_list,
 248                      &event);
 249
 250      ret_val=clEnqueueCopyBuffer(command_queue,
 251                                 data->src_buffer,
 252                                 buffer,
 253                                 data->src_offset,
 254                                 data->dst_offset,
 255                                 data->cb,
 256                                 data->num_events_in_wait_list,
 257                                 data->event_wait_list,
 258                                 &event);
 259
 260     test_icd_app_log("Value returned: %d\n", ret_val);
 261
 262     return 0;
 263
 264 }
 265
 266 int test_clEnqueueCopyBufferRect(const struct clEnqueueCopyBufferRect_st *data)
 267 {
 268     test_icd_app_log("clEnqueueCopyBufferRect(%p, %p, %p, %p, %p, %p, %u, %u, %u, %u, %u, %p, %p)\n",
 269                      command_queue,
 270                      buffer,
 271                      buffer,
 272                      data->src_origin,
 273                      data->dst_origin,
 274                      data->region,
 275                      data->src_row_pitch,
 276                      data->src_slice_pitch,
 277                      data->dst_row_pitch,
 278                      data->dst_slice_pitch,
 279                      data->num_events_in_wait_list,
 280                      data->event_wait_list,
 281                      &event);
 282
 283     ret_val=clEnqueueCopyBufferRect(command_queue,
 284                                     buffer,
 285                                     buffer,
 286                                     data->src_origin,
 287                                     data->dst_origin,
 288                                     data->region,
 289                                     data->src_row_pitch,
 290                                     data->src_slice_pitch,
 291                                     data->dst_row_pitch,
 292                                     data->dst_slice_pitch,
 293                                     data->num_events_in_wait_list,
 294                                     data->event_wait_list,
 295                                     &event);
 296
 297     test_icd_app_log("Value returned: %d\n", ret_val);
 298
 299     return 0;
 300
 301 }
 302
 303 int test_clEnqueueMapBuffer(const struct clEnqueueMapBuffer_st *data)
 304 {
 305     void * return_value;
 306     test_icd_app_log("clEnqueueMapBuffer(%p, %p, %u, %x, %u, %u, %u, %p, %p, %p)\n",
 307                      command_queue,
 308                      buffer,
 309                      data->blocking_map,
 310                      data->map_flags,
 311                      data->offset,
 312                      data->cb,
 313                      data->num_events_in_wait_list,
 314                      data->event_wait_list,
 315                      &event,
 316                      data->errcode_ret);
 317
 318     return_value=clEnqueueMapBuffer(command_queue,
 319                                     buffer,
 320                                     data->blocking_map,
 321                                     data->map_flags,
 322                                     data->offset,
 323                                     data->cb,
 324                                     data->num_events_in_wait_list,
 325                                     data->event_wait_list,
 326                                     &event,
 327                                     data->errcode_ret);
 328
 329     test_icd_app_log("Value returned: %p\n", return_value);
 330
 331     free(return_value);
 332
 333     return 0;
 334
 335 }
 336
 337 int test_clRetainMemObject(const struct clRetainMemObject_st *data)
 338 {
 339     test_icd_app_log("clRetainMemObject(%p)\n", buffer);
 340
 341     ret_val=clRetainMemObject(buffer);
 342
 343     test_icd_app_log("Value returned: %d\n", ret_val);
 344
 345     return 0;
 346
 347 }
 348
 349 int test_clSetMemObjectDestructorCallback(const struct clSetMemObjectDestructorCallback_st *data)
 350 {
 351     test_icd_app_log("clSetMemObjectDestructorCallback(%p, %p, %p)\n",
 352                      buffer,
 353                      data->pfn_notify,
 354                      data->user_data);
 355
 356     ret_val=clSetMemObjectDestructorCallback(buffer,
 357                                             data->pfn_notify,
 358                                             data->user_data);
 359
 360     test_icd_app_log("Value returned: %d\n", ret_val);
 361
 362     return 0;
 363
 364 }
 365
 366 int test_clEnqueueUnmapMemObject(const struct clEnqueueUnmapMemObject_st *data)
 367 {
 368     test_icd_app_log("clEnqueueUnmapMemObject(%p, %p, %p, %u, %p, %p)\n",
 369                      command_queue,
 370                      buffer,
 371                      data->mapped_ptr,
 372                      data->num_events_in_wait_list,
 373                      data->event_wait_list,
 374                      &event);
 375
 376     ret_val=clEnqueueUnmapMemObject(command_queue,
 377                                     buffer,
 378                                     data->mapped_ptr,
 379                                     data->num_events_in_wait_list,
 380                                     data->event_wait_list,
 381                                     &event);
 382
 383     test_icd_app_log("Value returned: %d\n", ret_val);
 384
 385     return 0;
 386
 387 }
 388
 389
 390 int test_clGetMemObjectInfo (const struct clGetMemObjectInfo_st *data)
 391 {
 392     test_icd_app_log("clGetMemObjectInfo(%p, %u, %u, %p, %p)\n",
 393                       buffer,
 394                       data->param_name,
 395                       data->param_value_size,
 396                       data->param_value,
 397                       data->param_value_size_ret);
 398
 399     ret_val=clGetMemObjectInfo(buffer,
 400                                data->param_name,
 401                                data->param_value_size,
 402                                data->param_value,
 403                                data->param_value_size_ret);
 404
 405     test_icd_app_log("Value returned: %d\n",ret_val);
 406
 407     return 0;
 408 }
 409
 410 int test_buffer_object()
 411 {
 412     int i;
 413     for (i=0; i<NUM_ITEMS_clEnqueueReadBuffer; i++) {
 414         test_clEnqueueReadBuffer(&clEnqueueReadBufferData[i]);
 415     }
 416
 417     for (i=0; i<NUM_ITEMS_clEnqueueWriteBuffer; i++) {
 418         test_clEnqueueWriteBuffer(&clEnqueueWriteBufferData[i]);
 419     }
 420
 421     for (i=0; i<NUM_ITEMS_clEnqueueReadBufferRect; i++) {
 422         test_clEnqueueReadBufferRect(&clEnqueueReadBufferRectData[i]);
 423     }
 424
 425     for (i=0; i<NUM_ITEMS_clEnqueueWriteBufferRect; i++) {
 426         test_clEnqueueWriteBufferRect(&clEnqueueWriteBufferRectData[i]);
 427     }
 428
 429     for (i=0; i<NUM_ITEMS_clEnqueueFillBuffer; i++) {
 430         test_clEnqueueFillBuffer(&clEnqueueFillBufferData[i]);
 431     }
 432
 433     for (i=0; i<NUM_ITEMS_clEnqueueCopyBuffer; i++) {
 434         test_clEnqueueCopyBuffer(&clEnqueueCopyBufferData[i]);
 435     }
 436
 437     for (i=0; i<NUM_ITEMS_clEnqueueCopyBufferRect; i++) {
 438         test_clEnqueueCopyBufferRect(&clEnqueueCopyBufferRectData[i]);
 439     }
 440
 441     for (i=0; i<NUM_ITEMS_clEnqueueMapBuffer; i++) {
 442         test_clEnqueueMapBuffer(&clEnqueueMapBufferData[i]);
 443     }
 444
 445     for (i=0; i<NUM_ITEMS_clRetainMemObject; i++) {
 446         test_clRetainMemObject(&clRetainMemObjectData[i]);
 447     }
 448
 449     for (i=0; i<NUM_ITEMS_clSetMemObjectDestructorCallback; i++) {
 450         test_clSetMemObjectDestructorCallback(&clSetMemObjectDestructorCallbackData[i]);
 451     }
 452
 453     for (i=0; i<NUM_ITEMS_clEnqueueUnmapMemObject; i++) {
 454         test_clEnqueueUnmapMemObject(&clEnqueueUnmapMemObjectData[i]);
 455     }
 456
 457     for (i=0; i<NUM_ITEMS_clGetMemObjectInfo; i++) {
 458          test_clGetMemObjectInfo(&clGetMemObjectInfoData[i]);
 459     }
 460
 461     return 0;
 462 }
 463