test/loader_test/test_kernel.c

   1 #ifndef CL_USE_DEPRECATED_OPENCL_1_1_APIS
   2 #define CL_USE_DEPRECATED_OPENCL_1_1_APIS
   3 #endif
   4
   5 #ifndef CL_USE_DEPRECATED_OPENCL_1_2_APIS
   6 #define CL_USE_DEPRECATED_OPENCL_1_2_APIS
   7 #endif
   8
   9 #include <CL/cl.h>
  10 #include "param_struct.h"
  11 #include <platform/icd_test_log.h>
  12
  13 extern cl_kernel kernel;
  14 extern cl_event event;
  15 extern cl_context  context;
  16 extern cl_command_queue command_queue;
  17 extern cl_device_id devices;
  18 int ret_val;
  19 extern void CL_CALLBACK setevent_callback(cl_event _a, cl_int _b, void* _c);
  20 extern void CL_CALLBACK setprintf_callback(cl_context _a, cl_uint _b, char* _c, void* _d );
  21
  22 struct clRetainKernel_st clRetainKernelData[NUM_ITEMS_clRetainKernel] =
  23 {
  24         {NULL}
  25 };
  26
  27 int test_clRetainKernel(const struct clRetainKernel_st* data)
  28 {
  29     test_icd_app_log("clRetainKernel(%p)\n", kernel);
  30
  31     ret_val=clRetainKernel(kernel);
  32
  33     test_icd_app_log("Value returned: %d\n", ret_val);
  34
  35     return 0;
  36 }
  37
  38 struct clSetKernelArg_st clSetKernelArgData[NUM_ITEMS_clSetKernelArg] =
  39 {
  40         {NULL, 0, 0, NULL}
  41 };
  42
  43 int test_clSetKernelArg(const struct clSetKernelArg_st* data)
  44 {
  45     test_icd_app_log("clSetKernelArg(%p, %u, %u, %p)\n",
  46                      kernel,
  47                      data->arg_index,
  48                      data->arg_size,
  49                      data->arg_value);
  50
  51     ret_val=clSetKernelArg(kernel,
  52                            data->arg_index,
  53                            data->arg_size,
  54                            data->arg_value);
  55
  56     test_icd_app_log("Value returned: %d\n", ret_val);
  57
  58     return 0;
  59 }
  60
  61 struct clGetKernelInfo_st clGetKernelInfoData[NUM_ITEMS_clGetKernelInfo] =
  62 {
  63         {NULL, 0, 0, NULL, NULL}
  64 };
  65
  66 int test_clGetKernelInfo(const struct clGetKernelInfo_st* data)
  67 {
  68     test_icd_app_log("clGetKernelInfo(%p, %u, %u, %p, %p)\n",
  69                      kernel,
  70                      data->param_name,
  71                      data->param_value_size,
  72                      data->param_value,
  73                      data->param_value_size_ret);
  74
  75     ret_val=clGetKernelInfo(kernel,
  76                                     data->param_name,
  77                                     data->param_value_size,
  78                                     data->param_value,
  79                                     data->param_value_size_ret);
  80
  81     test_icd_app_log("Value returned: %d\n", ret_val);
  82
  83         return 0;
  84 }
  85
  86 struct clGetKernelArgInfo_st clGetKernelArgInfoData[NUM_ITEMS_clGetKernelArgInfo] =
  87 {
  88     {NULL, 0, 0, 0, NULL, NULL}
  89 };
  90
  91 int test_clGetKernelArgInfo(const struct clGetKernelArgInfo_st* data)
  92 {
  93     test_icd_app_log("clGetKernelArgInfo(%p, %u, %u, %u, %p, %p)\n",
  94                      kernel,
  95                      data->arg_indx,
  96                      data->param_name,
  97                      data->param_value_size,
  98                      data->param_value,
  99                      data->param_value_size_ret);
 100
 101     ret_val=clGetKernelArgInfo(kernel,
 102             data->arg_indx,
 103             data->param_name,
 104             data->param_value_size,
 105             data->param_value,
 106             data->param_value_size_ret);
 107
 108     test_icd_app_log("Value returned: %d\n", ret_val);
 109
 110     return 0;
 111 }
 112
 113 struct clGetKernelWorkGroupInfo_st clGetKernelWorkGroupInfoData[NUM_ITEMS_clGetKernelWorkGroupInfo] =
 114 {
 115     {NULL, NULL, 0, 0, NULL, NULL}
 116 };
 117
 118 int test_clGetKernelWorkGroupInfo(const struct clGetKernelWorkGroupInfo_st* data)
 119 {
 120     test_icd_app_log("clGetKernelWorkGroupInfo(%p, %p, %u, %u, %p, %p)\n",
 121                      kernel,
 122                      devices,
 123                      data->param_name,
 124                      data->param_value_size,
 125                      data->param_value,
 126                      data->param_value_size_ret);
 127
 128     ret_val=clGetKernelWorkGroupInfo(kernel,
 129             devices,
 130             data->param_name,
 131             data->param_value_size,
 132             data->param_value,
 133             data->param_value_size_ret);
 134
 135     test_icd_app_log("Value returned: %d\n", ret_val);
 136
 137     return 0;
 138 }
 139
 140 struct clEnqueueMigrateMemObjects_st clEnqueueMigrateMemObjectsData[NUM_ITEMS_clEnqueueMigrateMemObjects] =
 141 {
 142     {NULL, 0, NULL, 0x0, 0, NULL, NULL}
 143 };
 144
 145 int test_clEnqueueMigrateMemObjects(const struct clEnqueueMigrateMemObjects_st* data)
 146 {
 147     test_icd_app_log("clEnqueueMigrateMemObjects(%p, %u, %p, %x, %u, %p, %p)\n",
 148                      command_queue,
 149                      data->num_mem_objects,
 150                      data->mem_objects,
 151                      data->flags,
 152                      data->num_events_in_wait_list,
 153                      data->event_wait_list,
 154                      &event);
 155
 156     ret_val=clEnqueueMigrateMemObjects(command_queue,
 157             (cl_uint)data->num_mem_objects,
 158             data->mem_objects,
 159             data->flags,
 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 struct clEnqueueNDRangeKernel_st clEnqueueNDRangeKernelData[NUM_ITEMS_clEnqueueNDRangeKernel] =
 170 {
 171     {NULL, NULL, 0, NULL, NULL, NULL, 0, NULL}
 172 };
 173
 174 int test_clEnqueueNDRangeKernel(const struct clEnqueueNDRangeKernel_st* data)
 175 {
 176     test_icd_app_log("clEnqueueNDRangeKernel(%p, %p, %u, %p, %p, %p, %u, %p, %p)\n",
 177                      command_queue,
 178                      kernel,
 179                      data->work_dim,
 180                      data->global_work_offset,
 181                      data->global_work_size,
 182                      data->local_work_size,
 183                      data->num_events_in_wait_list,
 184                      data->event_wait_list,
 185                      &event);
 186
 187     ret_val=clEnqueueNDRangeKernel(command_queue,
 188             kernel,
 189             data->work_dim,
 190             data->global_work_offset,
 191             data->global_work_size,
 192             data->local_work_size,
 193             data->num_events_in_wait_list,
 194             data->event_wait_list,
 195             &event);
 196
 197     test_icd_app_log("Value returned: %d\n", ret_val);
 198
 199     return 0;
 200 }
 201
 202 struct clEnqueueTask_st clEnqueueTaskData[NUM_ITEMS_clEnqueueTask] =
 203 {
 204     {NULL, NULL, 0, NULL, NULL}
 205 };
 206
 207 int test_clEnqueueTask(const struct clEnqueueTask_st* data)
 208 {
 209     test_icd_app_log("clEnqueueTask(%p, %p, %u, %p, %p)\n",
 210                      command_queue,
 211                      kernel,
 212                      data->num_events_in_wait_list,
 213                      data->event_wait_list,
 214                      &event);
 215
 216     ret_val=clEnqueueTask(command_queue,
 217             kernel,
 218             data->num_events_in_wait_list,
 219             data->event_wait_list,
 220             &event);
 221
 222     test_icd_app_log("Value returned: %d\n", ret_val);
 223
 224     return 0;
 225 }
 226 struct clEnqueueNativeKernel_st clEnqueueNativeKernelData[NUM_ITEMS_clEnqueueNativeKernel] =
 227 {
 228     {NULL, NULL, NULL, 0, 0, NULL, NULL, 0, NULL, NULL}
 229 };
 230
 231 int test_clEnqueueNativeKernel(const struct clEnqueueNativeKernel_st* data) {
 232     test_icd_app_log("clEnqueueNativeKernel(%p, %p, %p, %u, %u, %p, %p, %u, %p, %p)\n",
 233                      command_queue,
 234                      data->user_func,
 235                      data->args,
 236                      data->cb_args,
 237                      data->num_mem_objects,
 238                      data->mem_list,
 239                      data->args_mem_loc,
 240                      data->num_events_in_wait_list,
 241                      data->event_wait_list,
 242                      &event);
 243
 244     ret_val=clEnqueueNativeKernel(command_queue,
 245             data->user_func,
 246             data->args,
 247             data->cb_args,
 248             data->num_mem_objects,
 249             data->mem_list,
 250             data->args_mem_loc,
 251             data->num_events_in_wait_list,
 252             data->event_wait_list,
 253             &event);
 254
 255     test_icd_app_log("Value returned: %d\n", ret_val);
 256     return 0;
 257 }
 258
 259 struct clSetUserEventStatus_st clSetUserEventStatusData[NUM_ITEMS_clSetUserEventStatus] =
 260 {
 261     {NULL, 0}
 262 };
 263
 264 int test_clSetUserEventStatus(const struct clSetUserEventStatus_st* data)
 265 {
 266     test_icd_app_log("clSetUserEventStatus(%p, %d)\n",
 267                      event,
 268                      data->execution_status);
 269
 270     ret_val=clSetUserEventStatus(event,
 271             data->execution_status);
 272
 273     test_icd_app_log("Value returned: %d\n", ret_val);
 274     return 0;
 275 }
 276
 277 struct clWaitForEvents_st clWaitForEventsData[NUM_ITEMS_clWaitForEvents] =
 278 {
 279     {1, NULL}
 280 };
 281
 282 int test_clWaitForEvents(const struct clWaitForEvents_st* data)
 283 {
 284     test_icd_app_log("clWaitForEvents(%u, %p)\n",
 285                      data->num_events,
 286                      &event);
 287
 288     ret_val=clWaitForEvents(data->num_events,
 289             &event);
 290
 291     test_icd_app_log("Value returned: %d\n", ret_val);
 292     return 0;
 293 }
 294
 295 struct clGetEventInfo_st clGetEventInfoData[NUM_ITEMS_clGetEventInfo] =
 296 {
 297     {NULL, 0, 0, NULL, NULL}
 298 };
 299
 300 int test_clGetEventInfo(const struct clGetEventInfo_st* data){
 301     test_icd_app_log("clGetEventInfo(%p, %u, %u, %p, %p)\n",
 302                      event,
 303                      data->param_name,
 304                      data->param_value_size,
 305                      data->param_value,
 306                      data->param_value_size_ret);
 307
 308     ret_val=clGetEventInfo(event,
 309             data->param_name,
 310             data->param_value_size,
 311             data->param_value,
 312             data->param_value_size_ret);
 313
 314     test_icd_app_log("Value returned: %d\n", ret_val);
 315
 316     return 0;
 317 }
 318
 319 struct clSetEventCallback_st clSetEventCallbackData[NUM_ITEMS_clSetEventCallback] =
 320 {
 321     {NULL, 0, setevent_callback, NULL}
 322 };
 323
 324 int test_clSetEventCallback(const struct clSetEventCallback_st* data)
 325 {
 326     test_icd_app_log("clSetEventCallback(%p, %d, %p, %p)\n",
 327                      event,
 328                      data->command_exec_callback_type,
 329                      data->pfn_event_notify,
 330                      data->user_data);
 331
 332     ret_val=clSetEventCallback(event,
 333             data->command_exec_callback_type,
 334             data->pfn_event_notify,
 335             data->user_data);
 336
 337     test_icd_app_log("Value returned: %d\n", ret_val);
 338     return 0;
 339 }
 340
 341 struct clRetainEvent_st clRetainEventData[NUM_ITEMS_clRetainEvent] =
 342 {
 343     {NULL}
 344 };
 345
 346 int test_clRetainEvent(const struct clRetainEvent_st* data)
 347 {
 348     test_icd_app_log("clRetainEvent(%p)\n", event);
 349
 350     ret_val=clRetainEvent(event);
 351
 352     test_icd_app_log("Value returned: %d\n", ret_val);
 353
 354     return 0;
 355 }
 356
 357 struct clEnqueueMarker_st clEnqueueMarkerData[NUM_ITEMS_clEnqueueMarker] =
 358 {
 359     {NULL, NULL}
 360 };
 361
 362 int test_clEnqueueMarker(const struct clEnqueueMarker_st* data)
 363 {
 364     test_icd_app_log("clEnqueueMarker(%p, %p)\n", command_queue, &event);
 365
 366     ret_val = clEnqueueMarker(command_queue, &event);
 367
 368     test_icd_app_log("Value returned: %d\n", ret_val);
 369
 370     return 0;
 371 }
 372
 373 struct clEnqueueMarkerWithWaitList_st clEnqueueMarkerWithWaitListData[NUM_ITEMS_clEnqueueMarkerWithWaitList] =
 374 {
 375     {NULL, 0, NULL, NULL}
 376 };
 377
 378 int test_clEnqueueMarkerWithWaitList(const struct clEnqueueMarkerWithWaitList_st* data)
 379 {
 380     test_icd_app_log("clEnqueueMarkerWithWaitList(%p, %u, %p, %p)\n",
 381                      command_queue,
 382                      data->num_events_in_wait_list,
 383                      data->event_wait_list,
 384                      &event);
 385
 386     ret_val=clEnqueueMarkerWithWaitList(command_queue,
 387             data->num_events_in_wait_list,
 388             data->event_wait_list,
 389             &event);
 390
 391     test_icd_app_log("Value returned: %d\n", ret_val);
 392
 393     return 0;
 394 }
 395
 396 struct clEnqueueBarrierWithWaitList_st clEnqueueBarrierWithWaitListData[NUM_ITEMS_clEnqueueBarrierWithWaitList] =
 397 {
 398     {NULL, 0, NULL, NULL}
 399 };
 400 int test_clEnqueueBarrierWithWaitList(const struct clEnqueueBarrierWithWaitList_st* data)
 401 {
 402     test_icd_app_log("clEnqueueBarrierWithWaitList(%p, %u, %p, %p)\n",
 403                      command_queue,
 404                      data->num_events_in_wait_list,
 405                      data->event_wait_list,
 406                      &event);
 407
 408     ret_val=clEnqueueBarrierWithWaitList(command_queue,
 409             data->num_events_in_wait_list,
 410             data->event_wait_list,
 411             &event);
 412
 413     test_icd_app_log("Value returned: %d\n", ret_val);
 414
 415     return 0;
 416 }
 417
 418 struct clEnqueueWaitForEvents_st clEnqueueWaitForEventsData[NUM_ITEMS_clEnqueueWaitForEvents] =
 419 {
 420     {NULL, 0, NULL}
 421 };
 422
 423 int test_clEnqueueWaitForEvents(const struct clEnqueueWaitForEvents_st* data)
 424 {
 425     test_icd_app_log("clEnqueueWaitForEvents(%p, %u, %p)\n",
 426                      command_queue,
 427                      data->num_events,
 428                      data->event_list);
 429
 430     ret_val = clEnqueueWaitForEvents(command_queue,
 431             data->num_events,
 432             data->event_list);
 433
 434     test_icd_app_log("Value returned: %d\n", ret_val);
 435
 436     return 0;
 437 }
 438
 439 struct clEnqueueBarrier_st clEnqueueBarrierData[NUM_ITEMS_clEnqueueBarrier] =
 440 {
 441     {NULL}
 442 };
 443
 444 int test_clEnqueueBarrier(const struct clEnqueueBarrier_st* data)
 445 {
 446     test_icd_app_log("clEnqueueBarrier(%p)\n", command_queue);
 447
 448     ret_val = clEnqueueBarrier(command_queue);
 449
 450     test_icd_app_log("Value returned: %d\n", ret_val);
 451
 452     return 0;
 453 }
 454 struct clGetEventProfilingInfo_st clGetEventProfilingInfoData[NUM_ITEMS_clGetEventProfilingInfo] =
 455 {
 456     {NULL, 0, 0, NULL, NULL}
 457 };
 458
 459 int test_clGetEventProfilingInfo(const struct clGetEventProfilingInfo_st* data)
 460 {
 461     test_icd_app_log("clGetEventProfilingInfo(%p, %u, %u, %p, %p)\n",
 462                      event,
 463                      data->param_name,
 464                      data->param_value_size,
 465                      data->param_value,
 466                      data->param_value_size_ret);
 467
 468     ret_val=clGetEventProfilingInfo(event,
 469             data->param_name,
 470             data->param_value_size,
 471             data->param_value,
 472             data->param_value_size_ret);
 473
 474     test_icd_app_log("Value returned: %d\n", ret_val);
 475
 476     return 0;
 477 }
 478
 479 struct clFlush_st clFlushData[NUM_ITEMS_clFlush] =
 480 {
 481     {NULL}
 482 };
 483
 484 int test_clFlush(const struct clFlush_st* data)
 485 {
 486     test_icd_app_log("clFlush(%p)\n", command_queue);
 487
 488     ret_val=clFlush(command_queue);
 489
 490     test_icd_app_log("Value returned: %d\n", ret_val);
 491
 492     return 0;
 493 }
 494
 495 struct clFinish_st clFinishData[NUM_ITEMS_clFinish] =
 496 {
 497     {NULL}
 498 };
 499
 500 int test_clFinish(const struct clFinish_st* data)
 501 {
 502     test_icd_app_log("clFinish(%p)\n", command_queue);
 503
 504     ret_val=clFinish(command_queue);
 505
 506     test_icd_app_log("Value returned: %d\n", ret_val);
 507
 508     return 0;
 509 }
 510
 511 int test_kernel()
 512 {
 513     int i;
 514
 515     for (i=0; i<NUM_ITEMS_clRetainKernel; i++) {
 516         test_clRetainKernel(&clRetainKernelData[i]);
 517     }
 518
 519     for (i=0; i<NUM_ITEMS_clSetKernelArg; i++) {
 520         test_clSetKernelArg(&clSetKernelArgData[i]);
 521     }
 522
 523     for (i=0; i<NUM_ITEMS_clGetKernelInfo; i++) {
 524         test_clGetKernelInfo(&clGetKernelInfoData[i]);
 525     }
 526
 527     for (i=0; i<NUM_ITEMS_clGetKernelArgInfo; i++) {
 528         test_clGetKernelArgInfo(&clGetKernelArgInfoData[i]);
 529     }
 530
 531     for (i=0; i<NUM_ITEMS_clGetKernelWorkGroupInfo; i++) {
 532         test_clGetKernelWorkGroupInfo(&clGetKernelWorkGroupInfoData[i]);
 533     }
 534
 535     for (i=0; i<NUM_ITEMS_clEnqueueMigrateMemObjects; i++) {
 536         test_clEnqueueMigrateMemObjects(&clEnqueueMigrateMemObjectsData[i]);
 537     }
 538
 539     for (i=0; i<NUM_ITEMS_clEnqueueNDRangeKernel; i++) {
 540         test_clEnqueueNDRangeKernel(&clEnqueueNDRangeKernelData[i]);
 541     }
 542
 543     for (i=0; i<NUM_ITEMS_clEnqueueTask; i++) {
 544         test_clEnqueueTask(&clEnqueueTaskData[i]);
 545     }
 546
 547     for (i=0; i<NUM_ITEMS_clEnqueueNativeKernel; i++) {
 548         test_clEnqueueNativeKernel(&clEnqueueNativeKernelData[i]);
 549     }
 550
 551     for (i=0; i<NUM_ITEMS_clSetUserEventStatus; i++) {
 552         test_clSetUserEventStatus(&clSetUserEventStatusData[i]);
 553     }
 554
 555     for (i=0; i<NUM_ITEMS_clWaitForEvents; i++) {
 556         test_clWaitForEvents(&clWaitForEventsData[i]);
 557     }
 558
 559     for (i=0; i<NUM_ITEMS_clGetEventInfo; i++) {
 560         test_clGetEventInfo(&clGetEventInfoData[i]);
 561     }
 562
 563     for (i=0; i<NUM_ITEMS_clSetEventCallback; i++) {
 564         test_clSetEventCallback(&clSetEventCallbackData[i]);
 565     }
 566
 567     for (i=0; i<NUM_ITEMS_clRetainEvent; i++) {
 568         test_clRetainEvent(&clRetainEventData[i]);
 569     }
 570
 571     for (i=0; i<NUM_ITEMS_clEnqueueMarker; i++) {
 572         test_clEnqueueMarker(&clEnqueueMarkerData[i]);
 573     }
 574
 575     for (i=0; i<NUM_ITEMS_clEnqueueBarrier; i++) {
 576         test_clEnqueueBarrier(&clEnqueueBarrierData[i]);
 577     }
 578
 579     for (i=0; i<NUM_ITEMS_clEnqueueMarkerWithWaitList; i++) {
 580         test_clEnqueueMarkerWithWaitList(&clEnqueueMarkerWithWaitListData[i]);
 581     }
 582
 583     for (i=0; i<NUM_ITEMS_clEnqueueBarrierWithWaitList; i++) {
 584         test_clEnqueueBarrierWithWaitList(&clEnqueueBarrierWithWaitListData[i]);
 585     }
 586
 587     for (i=0; i<NUM_ITEMS_clGetEventProfilingInfo; i++) {
 588         test_clGetEventProfilingInfo(&clGetEventProfilingInfoData[i]);
 589     }
 590
 591     for (i=0; i<NUM_ITEMS_clFlush; i++) {
 592         test_clFlush(&clFlushData[i]);
 593     }
 594
 595     for (i=0; i<NUM_ITEMS_clFinish; i++) {
 596         test_clFinish(&clFinishData[i]);
 597     }
 598
 599     return 0;
 600 }