C++ (Cpp) poclu_write_file Beispiele

Beispiel #1

Datei: test_kernel_cache_includes.c Projekt: larsmans/pocl

int main(int argc, char **argv)
{
  cl_int err;
  const char *krn_src;
  cl_program program, program2;
  cl_context ctx;
  cl_command_queue queue;
  cl_device_id did;
  cl_kernel kernel, kernel2;

  poclu_get_any_device(&ctx, &did, &queue);
  TEST_ASSERT(ctx);
  TEST_ASSERT(did);
  TEST_ASSERT(queue);

  krn_src = poclu_read_file(SRCDIR "/tests/runtime/test_kernel_cache_includes.cl");
  TEST_ASSERT(krn_src);

  err = poclu_write_file(SRCDIR "/tests/runtime/test_include.h", first_include,
                         sizeof(first_include)-1);
  TEST_ASSERT(err == 0);

  program = clCreateProgramWithSource(ctx, 1, &krn_src, NULL, &err);
  CHECK_OPENCL_ERROR_IN("clCreateProgramWithSource");

  err = clBuildProgram(program, 0, NULL, NULL, NULL, NULL);
  CHECK_OPENCL_ERROR_IN("clBuildProgram 1");

  kernel = clCreateKernel(program, "testk", &err);
  CHECK_OPENCL_ERROR_IN("clCreateKernel 1");

  size_t off[3] = {0,0,0};
  size_t ws[3] = {1,1,1};

  err = clEnqueueNDRangeKernel(queue, kernel, 3, off, ws, ws, 0, NULL, 0);
  CHECK_OPENCL_ERROR_IN("clEnqueueNDRangeKernel 1");

  err = clFinish(queue);
  CHECK_OPENCL_ERROR_IN("clFinish 1");

  /***************************************/

  program2 = clCreateProgramWithSource(ctx, 1, &krn_src, NULL, &err);
  CHECK_OPENCL_ERROR_IN("clCreateProgramWithSource 2");

  err = poclu_write_file(SRCDIR "/tests/runtime/test_include.h", second_include,
                         sizeof(second_include)-1);
  TEST_ASSERT(err == 0);

  err = clBuildProgram(program2, 0, NULL, NULL, NULL, NULL);
  CHECK_OPENCL_ERROR_IN("clBuildProgram 2");

  kernel2 = clCreateKernel(program2, "testk", &err);
  CHECK_OPENCL_ERROR_IN("clCreateKernel 2");

  err = clEnqueueNDRangeKernel(queue, kernel2, 3, off, ws, ws, 0, NULL, 0);
  CHECK_OPENCL_ERROR_IN("clEnqueueNDRangeKernel 2");

  err = clFinish(queue);
  CHECK_OPENCL_ERROR_IN("clFinish 2");

  return 0;
}

Beispiel #2

Datei: poclcc.c Projekt: wincle626/POCL-Odroid-XU3

int
main(int argc, char **argv)
{
//MANAGEMENT OF ARGUMENTS
  options_help = options;
  int arg_num=1;
  if (argc < 2)
    return poclcc_error("Invalid argument!\n");

  while (arg_num < argc-1)
    if (process_arg(&arg_num, argv, argc))
      return -1;

  if (arg_num >= argc && list_devices)
    list_devices_only = 1;
  else if (arg_num >= argc)
    poclcc_error("Invalid arguments!\n");
  else
    {
      int current_process = search_process(argv[arg_num]);
      if (current_process == -1 && process_kernel_file(arg_num, argv, argc))
        return -1;
      else if (current_process != -1)
        {
          process_arg(&arg_num, argv, argc);
          list_devices_only = 1;
        }
    }

//OPENCL STUFF
  cl_platform_id cpPlatform;
  cl_device_id device_ids[NUM_OF_DEVICE_ID];
  cl_context context;
  cl_program program;
  cl_int err;
  cl_uint num_devices, i;

  CHECK_CL_ERROR(clGetPlatformIDs(1, &cpPlatform, NULL));

  CHECK_CL_ERROR(clGetDeviceIDs(cpPlatform, opencl_device,
                                NUM_OF_DEVICE_ID, device_ids, &num_devices));

  if (opencl_device_id >= num_devices)
    return poclcc_error("Invalid opencl device_id!\n");

  if (list_devices)
    {
      context = clCreateContext(0, num_devices, device_ids, NULL, NULL, &err);
      CHECK_CL_ERROR2(err, clCreateContext);

      printf("LIST OF DEVICES:\n");
      for (i=0; i<num_devices; i++)
        {
          char str[DEVICE_INFO_MAX_LENGTH];
          CHECK_CL_ERROR(clGetDeviceInfo(device_ids[i], CL_DEVICE_VENDOR,
                                         DEVICE_INFO_MAX_LENGTH, str, NULL));

          printf("%i: %s --- ", i, str);

          CHECK_CL_ERROR(clGetDeviceInfo(device_ids[i], CL_DEVICE_NAME,
                                         DEVICE_INFO_MAX_LENGTH, str, NULL));
          printf("%s\n", str);
        }

      clReleaseContext(context);
    }
  if (list_devices_only)
    return 0;

  context = clCreateContext(0, 1, &device_ids[opencl_device_id], NULL, NULL, &err);
  CHECK_CL_ERROR2(err, clCreateContext);

  program = clCreateProgramWithSource(context, 1, (const char **)&kernel_source, NULL, &err);
  CHECK_CL_ERROR2(err, clCreateProgramWithSource);

  CHECK_CL_ERROR(clBuildProgram(program, 0, NULL, build_options, NULL, NULL));

  size_t binary_sizes;
  char *binary;

  CHECK_CL_ERROR(clGetProgramInfo(program, CL_PROGRAM_BINARY_SIZES,
                                  sizeof(size_t), &binary_sizes, NULL));

  binary = malloc(sizeof(char)*binary_sizes);
  if (!binary)
    {
      printf("malloc(binary) failed\n");
      exit(1);
    }

  CHECK_CL_ERROR(clGetProgramInfo(program, CL_PROGRAM_BINARIES,
                                  sizeof(unsigned char*), &binary, NULL));

  CHECK_CL_ERROR(clReleaseProgram(program));
  CHECK_CL_ERROR(clReleaseContext(context));

  if (poclu_write_file(output_file, binary, binary_sizes))
    ERRNO_EXIT(output_file);

  free(binary);

  return 0;
}