コード例 #1
0
PUBLIC cl_int
clGetProgramBuildInfo(cl_program prog, cl_device_id dev,
                      cl_program_build_info param,
                      size_t size, void *buf, size_t *size_ret) {
   if (!prog)
      return CL_INVALID_PROGRAM;

   if (!prog->ctx.has_device(dev))
      return CL_INVALID_DEVICE;

   switch (param) {
   case CL_PROGRAM_BUILD_STATUS:
      return scalar_property<cl_build_status>(buf, size, size_ret,
                                              prog->build_status(dev));

   case CL_PROGRAM_BUILD_OPTIONS:
      return string_property(buf, size, size_ret, prog->build_opts(dev));

   case CL_PROGRAM_BUILD_LOG:
      return string_property(buf, size, size_ret, prog->build_log(dev));

   default:
      return CL_INVALID_VALUE;
   }
}
コード例 #2
0
PUBLIC cl_int
clBuildProgram(cl_program prog, cl_uint count, const cl_device_id *devs,
               const char *opts, void (*pfn_notify)(cl_program, void *),
               void *user_data) try {
   if (!prog)
      throw error(CL_INVALID_PROGRAM);

   if (bool(count) != bool(devs) ||
       (!pfn_notify && user_data))
      throw error(CL_INVALID_VALUE);

   if (devs) {
      if (any_of([&](const cl_device_id dev) {
               return !prog->ctx.has_device(dev);
            }, devs, devs + count))
         throw error(CL_INVALID_DEVICE);

      prog->build({ devs, devs + count });
   } else {
      prog->build(prog->ctx.devs);
   }

   return CL_SUCCESS;

} catch (error &e) {
   return e.get();
}
コード例 #3
0
ファイル: freeocl.cpp プロジェクト: Agorath/freeocl
	bool is_valid(cl_program p)
	{
		global_mutex.lock();
		const bool r = valid_programs.count(p) != 0 && p->valid();
		if (r)
			p->lock();
		global_mutex.unlock();
		return r;
	}
コード例 #4
0
cl_int
clRetainProgram(cl_program program)
{
    if (!program->isA(Coal::Object::T_Program))
        return CL_INVALID_PROGRAM;

    program->reference();

    return CL_SUCCESS;
}
コード例 #5
0
ファイル: api_program.cpp プロジェクト: jakebolewski/clover
cl_int
clReleaseProgram(cl_program program)
{
    if (!program->isA(Coal::Object::T_Program))
        return CL_INVALID_PROGRAM;

    if (program->dereference())
        delete program;

    return CL_SUCCESS;
}
コード例 #6
0
ファイル: api_program.cpp プロジェクト: jakebolewski/clover
cl_int
clGetProgramInfo(cl_program         program,
                 cl_program_info    param_name,
                 size_t             param_value_size,
                 void *             param_value,
                 size_t *           param_value_size_ret)
{
    if (!program->isA(Coal::Object::T_Program))
        return CL_INVALID_PROGRAM;

    return program->info(param_name, param_value_size, param_value,
                         param_value_size_ret);
}
コード例 #7
0
PUBLIC cl_int
clGetProgramInfo(cl_program prog, cl_program_info param,
                 size_t size, void *buf, size_t *size_ret) {
   if (!prog)
      return CL_INVALID_PROGRAM;

   switch (param) {
   case CL_PROGRAM_REFERENCE_COUNT:
      return scalar_property<cl_uint>(buf, size, size_ret,
                                      prog->ref_count());

   case CL_PROGRAM_CONTEXT:
      return scalar_property<cl_context>(buf, size, size_ret,
                                         &prog->ctx);

   case CL_PROGRAM_NUM_DEVICES:
      return scalar_property<cl_uint>(buf, size, size_ret,
                                      prog->binaries().size());

   case CL_PROGRAM_DEVICES:
      return vector_property<cl_device_id>(
         buf, size, size_ret,
         map(keys<device *, module>,
             prog->binaries().begin(), prog->binaries().end()));

   case CL_PROGRAM_SOURCE:
      return string_property(buf, size, size_ret, prog->source());

   case CL_PROGRAM_BINARY_SIZES:
      return vector_property<size_t>(
         buf, size, size_ret,
         map([](const std::pair<device *, module> &ent) {
               compat::ostream::buffer_t bin;
               compat::ostream s(bin);
               ent.second.serialize(s);
               return bin.size();
            },
            prog->binaries().begin(), prog->binaries().end()));

   case CL_PROGRAM_BINARIES:
      return matrix_property<unsigned char>(
         buf, size, size_ret,
         map([](const std::pair<device *, module> &ent) {
               compat::ostream::buffer_t bin;
               compat::ostream s(bin);
               ent.second.serialize(s);
               return bin;
            },
            prog->binaries().begin(), prog->binaries().end()));

   default:
      return CL_INVALID_VALUE;
   }
}
コード例 #8
0
cl_int
clGetProgramBuildInfo(cl_program            program,
                      cl_device_id          device,
                      cl_program_build_info param_name,
                      size_t                param_value_size,
                      void *                param_value,
                      size_t *              param_value_size_ret)
{
    if (!program->isA(Coal::Object::T_Program))
        return CL_INVALID_PROGRAM;

    return program->buildInfo((Coal::DeviceInterface *)device, param_name,
                              param_value_size, param_value,
                              param_value_size_ret);
}
コード例 #9
0
cl_int
clReleaseProgram(cl_program program)
{
#ifdef DBG_API
  std::cerr << "Entering clReleaseProgram\n";
#endif
    if (!program->isA(Coal::Object::T_Program))
        return CL_INVALID_PROGRAM;

    if (program->dereference())
        delete program;
#ifdef DBG_API
    std::cerr << "Leaving clReleaseProgram\n";
#endif
    return CL_SUCCESS;
}
コード例 #10
0
cl_int
clGetProgramInfo(cl_program         program,
                 cl_program_info    param_name,
                 size_t             param_value_size,
                 void *             param_value,
                 size_t *           param_value_size_ret)
{
#ifdef DBG_API
  std::cerr << "clGetProgramInfo\n";
#endif

    if (!program->isA(Coal::Object::T_Program))
        return CL_INVALID_PROGRAM;

    return program->info(param_name, param_value_size, param_value,
                         param_value_size_ret);
}
コード例 #11
0
PUBLIC cl_int
clRetainProgram(cl_program prog) {
   if (!prog)
      return CL_INVALID_PROGRAM;

   prog->retain();
   return CL_SUCCESS;
}
コード例 #12
0
PUBLIC cl_int
clReleaseProgram(cl_program prog) {
   if (!prog)
      return CL_INVALID_PROGRAM;

   if (prog->release())
      delete prog;

   return CL_SUCCESS;
}
コード例 #13
0
cl_int
clBuildProgram(cl_program           program,
               cl_uint              num_devices,
               const cl_device_id * device_list,
               const char *         options,
               void (*pfn_notify)(cl_program program, void * user_data),
               void *               user_data)
{
#ifdef DBG_API
  std::cerr << "Entering clBuildProgram. Building for " << num_devices
    << " devices\n";
#endif
  
    if (!program->isA(Coal::Object::T_Program)) {
      std::cerr << "INVALID_PROGRAM\n";
        return CL_INVALID_PROGRAM;
    }

    if (!device_list && num_devices > 0) {
      std::cerr << "!device_list : INVALID_VALUE\n";
        return CL_INVALID_VALUE;
    }

    if (!num_devices && device_list) {
      std::cerr << "!num_devices : INVALID_VALUE\n";
        return CL_INVALID_VALUE;
    }

    if (!pfn_notify && user_data) {
      std::cerr << "!pfn_notify : INVALID_VALUE\n";
        return CL_INVALID_VALUE;
    }
    // We cannot try to build a previously-failed program
    if (program->state() != Coal::Program::Loaded)
      return CL_INVALID_OPERATION;

#ifdef DBG_API
    std::cerr << "Checking " << num_devices << " devices\n";
#endif
    // Check the devices for compliance
    //if (num_devices)
    //{
        cl_uint context_num_devices = 0;
        cl_device_id *context_devices;
        Coal::Context *context = (Coal::Context *)program->parent();
        cl_int result;

        result = context->info(CL_CONTEXT_NUM_DEVICES, sizeof(cl_uint),
                                     &context_num_devices, 0);

        if (result != CL_SUCCESS)
            return result;

        context_devices =
            (cl_device_id *)std::malloc(context_num_devices * sizeof(cl_device_id));

        result = context->info(CL_CONTEXT_DEVICES,
                                     context_num_devices * sizeof(cl_device_id),
                                     context_devices, 0);

        if (result != CL_SUCCESS) {
#ifdef DBG_API
          std::cerr << "context->info != CL_SUCCESS\n";
#endif
            return result;
        }

#ifdef DBG_API
        std::cerr << "Checking " << context_num_devices << " context devices\n";
#endif

        if (num_devices) {
          for (cl_uint i=0; i < num_devices; ++i) {
            bool found = false;
#ifdef DBG_API
            std::cerr << "device_list[" << i << "] addr = "
              << device_list[i] << std::endl;
#endif

            for (cl_uint j=0; j<context_num_devices; ++j)
            {
#ifdef DBG_API
              std::cerr << "context_device [" << j << "] addr = "
                << context_devices[j] << std::endl;
#endif
                if (device_list[i] == context_devices[j])
                {
                    found = true;
#ifdef DBG_API
                    std::cerr << "Found device, break out\n";
#endif
                    break;
                }
            }

            if (!found) {
              std::cerr << "INVALID_DEVICE\n";
              return CL_INVALID_DEVICE;
            }
        }
#ifdef DEBUCL
        std::cerr << "Leaving clBuildProgram after program->build\n";
#endif
        // Build program
        return program->build(options, pfn_notify, user_data, num_devices,
                              (Coal::DeviceInterface * const*)device_list);
      }
      // num devices wasn't specified and device_list is probably null, so
      // build for all associated devices
      else {
#ifdef DEBUCL
        std::cerr << "Leaving clBuildProgram after program->build\n";
#endif
        return program->build(options, pfn_notify, user_data,
                              context_num_devices,
                              context->getAllDevices());
      }
  return NULL;
}
コード例 #14
0
ファイル: api_program.cpp プロジェクト: jakebolewski/clover
cl_int
clBuildProgram(cl_program           program,
               cl_uint              num_devices,
               const cl_device_id * device_list,
               const char *         options,
               void (*pfn_notify)(cl_program program, void * user_data),
               void *               user_data)
{
    if (!program->isA(Coal::Object::T_Program))
        return CL_INVALID_PROGRAM;

    if (!device_list && num_devices > 0)
        return CL_INVALID_VALUE;

    if (!num_devices && device_list)
        return CL_INVALID_VALUE;

    if (!pfn_notify && user_data)
        return CL_INVALID_VALUE;

    // Check the devices for compliance
    if (num_devices)
    {
        cl_uint context_num_devices = 0;
        cl_device_id *context_devices;
        Coal::Context *context = (Coal::Context *)program->parent();
        cl_int result;

        result = context->info(CL_CONTEXT_NUM_DEVICES, sizeof(cl_uint),
                                     &context_num_devices, 0);

        if (result != CL_SUCCESS)
            return result;

        context_devices =
            (cl_device_id *)std::malloc(context_num_devices * sizeof(cl_device_id));

        result = context->info(CL_CONTEXT_DEVICES,
                                     context_num_devices * sizeof(cl_device_id),
                                     context_devices, 0);

        if (result != CL_SUCCESS)
            return result;

        for (cl_uint i=0; i<num_devices; ++i)
        {
            bool found = false;

            for (cl_uint j=0; j<context_num_devices; ++j)
            {
                if (device_list[i] == context_devices[j])
                {
                    found = true;
                    break;
                }
            }

            if (!found)
                return CL_INVALID_DEVICE;
        }
    }

    // We cannot try to build a previously-failed program
    if (program->state() != Coal::Program::Loaded)
        return CL_INVALID_OPERATION;

    // Build program
    return program->build(options, pfn_notify, user_data, num_devices,
                          (Coal::DeviceInterface * const*)device_list);
}