cl_context get_first_platform(){
cl_uint num_platforms;
cl_platform_id platform;
cl_int err = clGetPlatformIDs(1, &platform, &num_platforms);
if (check_cl_err(err, "Failed to find a platform") || num_platforms < 1){
return NULL;
}
char name[64];
err = clGetPlatformInfo(platform, CL_PLATFORM_NAME, 64, name, NULL);
//This error probably shouldn't happen, but check anyway
check_cl_err(err, "Failed to get platform name");
printf("Selecting platform: %s\n", name);
//Try to get a GPU context on the platform
cl_context_properties properties[] = {
CL_CONTEXT_PLATFORM, (cl_context_properties)platform, 0
};
cl_context context = clCreateContextFromType(properties, CL_DEVICE_TYPE_GPU,
cl_err_callback, NULL, &err);
if (check_cl_err(err, "Failed to create GPU context, retrying CPU")){
context = clCreateContextFromType(properties, CL_DEVICE_TYPE_CPU,
NULL, NULL, &err);
if (check_cl_err(err, "Failed to create a GPU or CPU context")){
return NULL;
}
}
return context;
}
cl_context CreateContext() {
cl_int errNum;
cl_uint numPlatforms;
cl_platform_id firstPlatformId;
cl_context context = NULL;
//Select platform to run on
errNum = clGetPlatformIDs(1, &firstPlatformId, &numPlatforms);
if(errNum != CL_SUCCESS || numPlatforms <= 0) {
printf("Failed to find an OpenCL platform");
return NULL;
}
//Create context on platform (try GPU if fails then CPU)
cl_context_properties contextProperties[] = {
CL_CONTEXT_PLATFORM,
(cl_context_properties)firstPlatformId,
0
};
context = clCreateContextFromType(contextProperties, CL_DEVICE_TYPE_GPU, NULL, NULL, &errNum);
if(errNum != CL_SUCCESS) {
context = clCreateContextFromType(contextProperties, CL_DEVICE_TYPE_CPU, NULL, NULL, &errNum);
if(errNum != CL_SUCCESS) {
printf("Failed to create an OpenCL context");
return NULL;
}
}
return context;
}
cl_context QHoneycombWidget::CreateContext()
{
cl_int errNum;
cl_uint numPlatforms;
cl_platform_id firstPlatformId;
cl_context context = NULL;
// First, select an OpenCL platform to run on. For this example, we
// simply choose the first available platform. Normally, you would
// query for all available platforms and select the most appropriate one.
errNum = clGetPlatformIDs(1, &firstPlatformId, &numPlatforms);
if (errNum != CL_SUCCESS || numPlatforms <= 0)
{
std::cerr << "Failed to find any OpenCL platforms." << std::endl;
return NULL;
}
// Next, create an OpenCL context on the platform. Attempt to
// create a GPU-based context, and if that fails, try to create
// a CPU-based context.
cl_context_properties contextProperties[] =
{
#ifdef _WIN32
CL_CONTEXT_PLATFORM,
(cl_context_properties)firstPlatformId,
CL_GL_CONTEXT_KHR,
(cl_context_properties)wglGetCurrentContext(),
CL_WGL_HDC_KHR,
(cl_context_properties)wglGetCurrentDC(),
#elif defined( __GNUC__)
CL_CONTEXT_PLATFORM, (cl_context_properties)clSelectedPlatformID,
CL_GL_CONTEXT_KHR, (cl_context_properties)glXGetCurrentContext(),
CL_GLX_DISPLAY_KHR, (cl_context_properties)glXGetCurrentDisplay(),
#elif defined(__APPLE__)
//todo
#endif
0
};
context = clCreateContextFromType(contextProperties, CL_DEVICE_TYPE_GPU,
NULL, NULL, &errNum);
if (errNum != CL_SUCCESS)
{
std::cout << "Could not create GPU context, trying CPU..." << std::endl;
context = clCreateContextFromType(contextProperties, CL_DEVICE_TYPE_CPU,
NULL, NULL, &errNum);
if (errNum != CL_SUCCESS)
{
std::cerr << "Failed to create an OpenCL GPU or CPU context." << std::endl;
return NULL;
}
}
return context;
}
cl_context CreateContext() {
cl_int errNum;
cl_uint numPlatforms;
cl_platform_id firstPlatformId;
cl_context context = NULL;
// First, select an OpenCL platform to run on. For this example, we
// simply choose the first available platform. Normally, you would
// query for all available platforms and select the most appropriate one.
errNum = clGetPlatformIDs(1, &firstPlatformId, &numPlatforms);
if (errNum != CL_SUCCESS || numPlatforms <= 0)
{
printf("Failed to find any OpenCL platforms.\n");
return NULL;
}
// Next, create an OpenCL context on the platform. Attempt to
// create a GPU-based context, and if that fails, try to create
// a CPU-based context.
cl_context_properties contextProperties[] = { CL_CONTEXT_PLATFORM, (cl_context_properties)firstPlatformId, 0 };
if (CPUGPUFLAG == 1)
{
context = clCreateContextFromType(contextProperties, CL_DEVICE_TYPE_GPU, NULL, NULL, &errNum);
if (errNum != CL_SUCCESS)
{
printf("Could not create GPU context.\n");
return NULL;
}
}
if (CPUGPUFLAG == 0)
{
context = clCreateContextFromType(contextProperties, CL_DEVICE_TYPE_CPU, NULL, NULL, &errNum);
if (errNum != CL_SUCCESS)
{
printf("Failed to create an OpenCL GPU or CPU context.\n");
return NULL;
}
}
return context;
}
cl_int OCL_Platform::init(cl_platform_id id)
{
cl_int err;
mID = id;
// store name
size_t nameSize;
OCL_RETURN_ON_ERR( clGetPlatformInfo( mID, CL_PLATFORM_NAME, 0, NULL, &nameSize ) );
sPlatformName = new char[nameSize];
OCL_RETURN_ON_ERR( clGetPlatformInfo( mID, CL_PLATFORM_NAME, nameSize, sPlatformName, NULL ) );
// store extensions
size_t extensionsSize;
OCL_RETURN_ON_ERR( clGetPlatformInfo( mID, CL_PLATFORM_EXTENSIONS, 0, NULL, &extensionsSize ) );
sPlatformExtensions = new char[extensionsSize];
OCL_RETURN_ON_ERR( clGetPlatformInfo( mID, CL_PLATFORM_EXTENSIONS, extensionsSize, sPlatformExtensions, NULL ) );
// default device type
cl_device_type deviceType = CL_DEVICE_TYPE_ALL;
cl_context_properties ctxProps[] =
{
CL_CONTEXT_PLATFORM,
(cl_context_properties)mID,
0
};
OCL_RETURN_ON_ERR( ( mContext = clCreateContextFromType( ctxProps, deviceType, NULL, NULL, &err ), err));
// Create array of devices
size_t dev_ids_size;
OCL_RETURN_ON_ERR( clGetContextInfo( mContext, CL_CONTEXT_DEVICES, 0, NULL, &dev_ids_size ) );
uiNumDevices = (cl_uint)dev_ids_size/sizeof(cl_device_id);
cl_device_id* pDeviceIDs = (cl_device_id*)calloc(1,dev_ids_size);
mpDevices = new OCL_DeviceAndQueue[uiNumDevices];
OCL_RETURN_ON_ERR( clGetContextInfo( mContext, CL_CONTEXT_DEVICES, dev_ids_size, pDeviceIDs, NULL ) );
for( cl_uint j=0; j<uiNumDevices; j++ )
{
OCL_RETURN_ON_ERR( mpDevices[j].init( mContext, pDeviceIDs[j] ) );
OCL_RETURN_ON_ERR(
(mpDevices[j].mContext = clCreateContextFromType( ctxProps, deviceType, NULL, NULL, &err )
,err ));
}
delete pDeviceIDs;
return CL_SUCCESS;
}
bool createContext()
{
cl_int err = 0;
cl_uint numberOfPlatforms = 0;
cl_platform_id firstPlatformID = 0;
/* Retrieve a single platform ID. */
err = clGetPlatformIDs(1, &firstPlatformID, &numberOfPlatforms);
if(err != CL_SUCCESS)
{
printf("Error: Failed clGetPlatformIds\n");
return false;
}
if (numberOfPlatforms <= 0)
{
printf("No OpenCL platforms found.\n");
return false;
}
/* Get a context with a GPU device from the platform found above. */
cl_context_properties contextProperties [] = {CL_CONTEXT_PLATFORM, (cl_context_properties)firstPlatformID, 0};
ocl.context = clCreateContextFromType(contextProperties, CL_DEVICE_TYPE_GPU, NULL, NULL, &err);
if (err != CL_SUCCESS)
{
printf("Creating an OpenCL context failed.\n");
return false;
}
return true;
}
oclHardware getOclHardware(cl_device_type type)
{
oclHardware hardware = {0, 0, 0, 0, 0, 0};
cl_platform_id platforms[16] = { 0 };
cl_device_id devices[16];
char platformName[256];
char deviceName[256];
cl_uint platformCount = 0;
cl_int err = clGetPlatformIDs(0, 0, &platformCount);
err = clGetPlatformIDs(16, platforms, &platformCount);
if (err != CL_SUCCESS) {
std::cout << oclErrorCode(err) << "\n";
return hardware;
}
for (cl_uint i = 0; i < platformCount; i++) {
err = clGetPlatformInfo(platforms[i], CL_PLATFORM_NAME, 256, platformName, 0);
if (err != CL_SUCCESS) {
std::cout << oclErrorCode(err) << "\n";
return hardware;
}
cl_uint deviceCount = 0;
err = clGetDeviceIDs(platforms[i], type, 16, devices, &deviceCount);
//err = clGetDeviceIDs(platforms[i], CL_DEVICE_TYPE_CPU, 16, devices, &deviceCount);
if ((err != CL_SUCCESS) || (deviceCount == 0)) {
continue;
}
err = clGetDeviceInfo(devices[0], CL_DEVICE_NAME, 256, deviceName, 0);
if (err != CL_SUCCESS) {
std::cout << oclErrorCode(err) << "\n";
return hardware;
}
cl_context_properties contextData[3] = {CL_CONTEXT_PLATFORM, (cl_context_properties)platforms[i], 0};
cl_context context = clCreateContextFromType(contextData, type, 0, 0, &err);
if (err != CL_SUCCESS) {
continue;
}
cl_command_queue queue = clCreateCommandQueue(context, devices[0], 0, &err);
if (err != CL_SUCCESS) {
std::cout << oclErrorCode(err) << "\n";
return hardware;
}
hardware.mPlatform = platforms[i];
hardware.mContext = context;
hardware.mDevice = devices[0];
hardware.mQueue = queue;
getDeviceVersion(hardware);
std::cout << "Platform = " << platformName << "\n";
std::cout << "Device = " << deviceName << "\n";
std::cout << "OpenCL Version = " << hardware.mMajorVersion << '.' << hardware.mMinorVersion << "\n";
return hardware;
}
return hardware;
}
static int initialize(int use_gpu)
{
cl_int result;
size_t size;
#ifndef POCL_HSA
// create OpenCL context
cl_platform_id platform_id;
if (clGetPlatformIDs(1, &platform_id, NULL) != CL_SUCCESS) { printf("ERROR: clGetPlatformIDs(1,*,0) failed\n"); return -1; }
cl_context_properties ctxprop[] = { CL_CONTEXT_PLATFORM, (cl_context_properties)platform_id, 0};
device_type = use_gpu ? CL_DEVICE_TYPE_GPU : CL_DEVICE_TYPE_CPU;
context = clCreateContextFromType( ctxprop, device_type, NULL, NULL, NULL );
#else
context = poclu_create_any_context();
#endif
if( !context ) { printf("ERROR: clCreateContextFromType(%s) failed\n", use_gpu ? "GPU" : "CPU"); return -1; }
// get the list of GPUs
result = clGetContextInfo( context, CL_CONTEXT_DEVICES, 0, NULL, &size );
num_devices = (int) (size / sizeof(cl_device_id));
if( result != CL_SUCCESS || num_devices < 1 ) { printf("ERROR: clGetContextInfo() failed\n"); return -1; }
device_list = new cl_device_id[num_devices];
if( !device_list ) { printf("ERROR: new cl_device_id[] failed\n"); return -1; }
result = clGetContextInfo( context, CL_CONTEXT_DEVICES, size, device_list, NULL );
if( result != CL_SUCCESS ) { printf("ERROR: clGetContextInfo() failed\n"); return -1; }
// create command queue for the first device
cmd_queue = clCreateCommandQueue( context, device_list[0], 0, NULL );
if( !cmd_queue ) { printf("ERROR: clCreateCommandQueue() failed\n"); return -1; }
return 0;
}
static int initialize(int use_device)
{
cl_int result;
size_t size;
// create OpenCL context
cl_platform_id platform_id;
if (clGetPlatformIDs(1, &platform_id, NULL) != CL_SUCCESS) { printf("ERROR: clGetPlatformIDs(1,*,0) failed\n"); return -1; }
cl_context_properties ctxprop[] = { CL_CONTEXT_PLATFORM, (cl_context_properties)platform_id, 0};
//device_type = use_device ? CL_DEVICE_TYPE_GPU : CL_DEVICE_TYPE_CPU;
switch(use_device) {
case 0: device_type = CL_DEVICE_TYPE_CPU; break;
case 1: device_type = CL_DEVICE_TYPE_GPU; break;
case 2: device_type = CL_DEVICE_TYPE_ACCELERATOR; break;
}
context = clCreateContextFromType( ctxprop, device_type, NULL, NULL, NULL );
if( !context ) { printf("ERROR: clCreateContextFromType(%s) failed\n", use_device ? "GPU" : "CPU"); return -1; }
// get the list of GPUs
result = clGetContextInfo( context, CL_CONTEXT_DEVICES, 0, NULL, &size );
num_devices = (int) (size / sizeof(cl_device_id));
printf("num_devices = %d\n", num_devices);
if( result != CL_SUCCESS || num_devices < 1 ) { printf("ERROR: clGetContextInfo() failed\n"); return -1; }
device_list = new cl_device_id[num_devices];
//device_list = (cl_device_id *)malloc(sizeof(cl_device_id)*num_devices);
if( !device_list ) { printf("ERROR: new cl_device_id[] failed\n"); return -1; }
result = clGetContextInfo( context, CL_CONTEXT_DEVICES, size, device_list, NULL );
if( result != CL_SUCCESS ) { printf("ERROR: clGetContextInfo() failed\n"); return -1; }
// create command queue for the first device
cmd_queue = clCreateCommandQueue( context, device_list[0], 0, NULL );
if( !cmd_queue ) { printf("ERROR: clCreateCommandQueue() failed\n"); return -1; }
return 0;
}
context(cl_device_type t, cl_context_properties *props = 0)
{
cl_int status;
impl_ = clCreateContextFromType(props, t, context::callback, this, &status);
if (status < 0)
OVXX_DO_THROW(exception("clCreateContextFromType", status));
}
nsresult dpoCContext::InitContext(cl_platform_id platform)
{
cl_int err_code;
cl_device_id *devices;
size_t cb;
cl_context_properties context_properties[3] = {CL_CONTEXT_PLATFORM, (cl_context_properties)platform, NULL};
context = clCreateContextFromType(context_properties, CL_DEVICE_TYPE_CPU, ReportCLError, this, &err_code);
if (err_code != CL_SUCCESS) {
DEBUG_LOG_ERROR("InitContext", err_code);
return NS_ERROR_NOT_AVAILABLE;
}
err_code = clGetContextInfo(context, CL_CONTEXT_DEVICES, 0, NULL, &cb);
if (err_code != CL_SUCCESS) {
DEBUG_LOG_ERROR("InitContext", err_code);
return NS_ERROR_NOT_AVAILABLE;
}
devices = (cl_device_id *)nsMemory::Alloc(sizeof(cl_device_id)*cb);
if (devices == NULL) {
DEBUG_LOG_STATUS("InitContext", "Cannot allocate device list");
return NS_ERROR_OUT_OF_MEMORY;
}
err_code = clGetContextInfo(context, CL_CONTEXT_DEVICES, cb, devices, NULL);
if (err_code != CL_SUCCESS) {
DEBUG_LOG_ERROR("InitContext", err_code);
nsMemory::Free(devices);
return NS_ERROR_NOT_AVAILABLE;
}
cmdQueue = clCreateCommandQueue(context, devices[0],
#ifdef CLPROFILE
CL_QUEUE_PROFILING_ENABLE |
#endif /* CLPROFILE */
#ifdef OUTOFORDERQUEUE
CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE |
#endif /* OUTOFORDERQUEUE */
0,
&err_code);
if (err_code != CL_SUCCESS) {
DEBUG_LOG_ERROR("InitContext", err_code);
nsMemory::Free(devices);
return NS_ERROR_NOT_AVAILABLE;
}
DEBUG_LOG_STATUS("InitContext", "queue is " << cmdQueue);
nsMemory::Free(devices);
kernelFailureMem = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(int), NULL, &err_code);
if (err_code != CL_SUCCESS) {
DEBUG_LOG_ERROR("InitContext", err_code);
return NS_ERROR_NOT_AVAILABLE;
}
return NS_OK;
}
cl_context OCLContexts::GetContextByPlatformName(
const std::string &platName, OCLContextProperties ctx_props) {
OCLErrorExp clerr;
cl_context found_ctx = m_contextMap[platName];
if ( found_ctx != NULL ) {
return found_ctx;
}
cl_platform_id platform = NULL;
for (size_t i=0; i<get_num_platforms(); i++) {
if (get_platform_name(i) == platName ) {
platform = m_platforms[i];
break;
}
}
ctx_props.AddProperty(CL_CONTEXT_PLATFORM, (cl_context_properties) platform);
found_ctx = clCreateContextFromType(ctx_props, CL_DEVICE_TYPE_ALL,
NULL, NULL, clerr);
clerr.CheckError();
if ( platform != NULL ) {
m_contextMap[platName] = found_ctx;
}
return found_ctx;
}
JNIContext::JNIContext(JNIEnv *jenv, jobject _kernelObject, jobject _openCLDeviceObject, jint _flags):
kernelObject(jenv->NewGlobalRef(_kernelObject)),
kernelClass((jclass)jenv->NewGlobalRef(jenv->GetObjectClass(_kernelObject))),
openCLDeviceObject(jenv->NewGlobalRef(_openCLDeviceObject)),
flags(_flags),
profileBaseTime(0),
passes(0),
exec(NULL),
deviceType(((flags&com_amd_aparapi_internal_jni_KernelRunnerJNI_JNI_FLAG_USE_GPU)==com_amd_aparapi_internal_jni_KernelRunnerJNI_JNI_FLAG_USE_GPU)?CL_DEVICE_TYPE_GPU:CL_DEVICE_TYPE_CPU),
profileFile(NULL),
valid(JNI_FALSE){
cl_int status = CL_SUCCESS;
jobject platformInstance = OpenCLDevice::getPlatformInstance(jenv, openCLDeviceObject);
cl_platform_id platformId = OpenCLPlatform::getPlatformId(jenv, platformInstance);
deviceId = OpenCLDevice::getDeviceId(jenv, openCLDeviceObject);
cl_device_type returnedDeviceType;
clGetDeviceInfo(deviceId, CL_DEVICE_TYPE, sizeof(returnedDeviceType), &returnedDeviceType, NULL);
//fprintf(stderr, "device[%d] CL_DEVICE_TYPE = %x\n", deviceId, returnedDeviceType);
cl_context_properties cps[3] = { CL_CONTEXT_PLATFORM, (cl_context_properties)platformId, 0 };
cl_context_properties* cprops = (NULL == platformId) ? NULL : cps;
context = clCreateContextFromType( cprops, returnedDeviceType, NULL, NULL, &status);
CLException::checkCLError(status, "clCreateContextFromType()");
if (status == CL_SUCCESS){
valid = JNI_TRUE;
}
}
cl_context get_platform(cl_device_type type){
cl_uint num_platforms;
cl_int err = clGetPlatformIDs(0, NULL, &num_platforms);
cl_platform_id *platforms = malloc(sizeof(cl_platform_id) * num_platforms);
err = clGetPlatformIDs(num_platforms, platforms, NULL);
if (check_cl_err(err, "Failed to find platforms") || num_platforms < 1){
return NULL;
}
cl_context_properties properties[] = {
CL_CONTEXT_PLATFORM, 0, 0
};
cl_context context = NULL;
for (size_t i = 0; i < num_platforms; ++i){
properties[1] = (cl_context_properties)platforms[i];
context = clCreateContextFromType(properties, type, cl_err_callback, NULL, &err);
if (err == CL_SUCCESS){
char name[64];
clGetPlatformInfo(platforms[i], CL_PLATFORM_NAME, 64, name, NULL);
printf("Selected platform: %s\n", name);
break;
}
}
free(platforms);
return context;
}
bool get_cl_context(cl_context *context, cl_device_id **devices, int num_platform)
{
if (context == NULL || devices == NULL) return false;
cl_platform_id *platforms = NULL;
// The iteration variable
int i;
cl_uint num;
check_err(clGetPlatformIDs(0, 0, &num), "Unable to get platforms");
platforms = (cl_platform_id *)malloc(sizeof(cl_platform_id) * num);
check_err(clGetPlatformIDs(num, platforms, NULL), "Unable to get platform ID");
check_err(clGetPlatformIDs(0, 0, &num), "Unable to get platforms");
printf("Found %d platforms:\n", num);
for (i = 0; i < num; i++) {
char str[1024];
clGetPlatformInfo(platforms[i], CL_PLATFORM_NAME, 1024, str, NULL);
printf("\t%d: %s\n", i, str);
}
cl_context_properties prop[3];
prop[0] = CL_CONTEXT_PLATFORM;
prop[1] = (cl_context_properties)platforms[num_platform];
prop[2] = 0;
cl_int err;
*context = clCreateContextFromType(prop, CL_DEVICE_TYPE_ALL, NULL, NULL, &err);
if (err != CL_SUCCESS) {
printf("Can't create OpenCL context\n");
return false;
}
size_t size_b;
int num_total_devices;
clGetContextInfo(*context, CL_CONTEXT_DEVICES, 0, NULL, &size_b);
*devices = (cl_device_id *)malloc(size_b);
clGetContextInfo(*context, CL_CONTEXT_DEVICES, size_b, *devices, 0);
if (size_b == 0) {
printf("Can't get devices\n");
return false;
}
num_total_devices = size_b / sizeof(cl_device_id);
printf("Found %d devices:\n", num_total_devices);
for (i = 0; i < num_total_devices; i++) {
char devname[16][256] = {};
clGetDeviceInfo(*devices[i], CL_DEVICE_NAME, 256, devname[i], 0);
printf("\t%d: %s", i, devname[i]);
clGetDeviceInfo(*devices[i], // Set the device info
CL_DEVICE_MAX_COMPUTE_UNITS,
sizeof(int),
&size_b,
0);
printf(" - %d\n", (int)size_b);
}
return true;
}
static cl_int create_opencl_context(cl_context *context, cl_platform_id *platform)
{
cl_context_properties cps[3] = { CL_CONTEXT_PLATFORM, (cl_context_properties)*platform, 0 };
cl_int status;
*context = clCreateContextFromType(cps, CL_DEVICE_TYPE_GPU, NULL, NULL, &status);
return status;
}
ClHelper::ClHelper()
: mContext((cl_context)0), mDeviceId((cl_device_id)0),
mCommandQueue((cl_command_queue)0), mProgram((cl_program)0),
mKernel((cl_kernel)0)
{
cl_int status;
// 플랫폼
cl_platform_id platforms[10];
cl_uint num_platforms;
status = clGetPlatformIDs(sizeof(platforms) / sizeof(platforms[0]),
platforms,
&num_platforms);
if (status != CL_SUCCESS || num_platforms <= 0) {
fprintf(stderr, "clGetPlatformIDs failed.\n");
printError(status);
throw MyError("failed to get platform IDs.", __FUNCTION__);
}
cl_context_properties properties[]
= {CL_CONTEXT_PLATFORM, (cl_context_properties)platforms[0], 0};
// 디바이스에 따른 컨텍스트 취득
mContext = clCreateContextFromType(properties,
// CL_DEVICE_TYPE_CPU, // CPUを使用
CL_DEVICE_TYPE_GPU, // GPUを使用
NULL,
NULL,
&status);
if (status != CL_SUCCESS) {
printError(status);
throw MyError("failed to create context.", __FUNCTION__);
}
// 디바이스 아이디 취득
cl_device_id devices[10];
status = clGetContextInfo(mContext,
CL_CONTEXT_DEVICES,
sizeof(devices),
devices,
NULL);
if (status != CL_SUCCESS) {
printError(status);
throw MyError("failed to get device id.", __FUNCTION__);
}
mDeviceId = devices[0];
// 커맨드 큐 생성
mCommandQueue = clCreateCommandQueue(mContext,
devices[0],
0,
&status);
if (status != CL_SUCCESS) {
printError(status);
throw MyError("failed to create command queue.", __FUNCTION__);
}
}
SEXP createContextFromType(SEXP deviceType){
//We need to look at this, because this does not seem to work...
std::string deviceString = Rcpp::as<std::string>(deviceType);
cl_context *context = new cl_context;
if(deviceString == "CL_DEVICE_TYPE_GPU"){
*context = clCreateContextFromType(NULL, CL_DEVICE_TYPE_GPU, NULL, NULL, NULL);
}
Rcpp::XPtr<cl_context> tempXPtr(context);
return tempXPtr;
}
///
// functions for preparing create opencl program, contains CreateContext, CreateProgram, CreateCommandQueue, CreateMemBuffer, and Cleanup
// Create an OpenCL context on the first available GPU platform.
cl_context CreateContext()
{
cl_context context = NULL;
cl_uint platformIdCount = 0;
cl_int errNum;
#ifndef POCL_HSA
// get number of platforms
clGetPlatformIDs (0, NULL, &platformIdCount);
std::vector<cl_platform_id> platformIds(platformIdCount);
clGetPlatformIDs (platformIdCount, platformIds.data(), NULL);
// In this example, first platform is a CPU, the second one is a GPU. we just choose the first available device.
cl_context_properties contextProperties[] =
{
CL_CONTEXT_PLATFORM,
(cl_context_properties)platformIds[1],
0
};
context = clCreateContextFromType(contextProperties, CL_DEVICE_TYPE_GPU,
NULL, NULL, &errNum);
if (errNum != CL_SUCCESS)
{
std::cout << "Could not create GPU context, trying CPU..." << std::endl;
context = clCreateContextFromType(contextProperties, CL_DEVICE_TYPE_CPU,
NULL, NULL, &errNum);
if (errNum != CL_SUCCESS)
{
std::cerr << "Failed to create an OpenCL GPU or CPU context." << std::endl;
return NULL;
}
}
#else
context = poclu_create_any_context();
#endif
return context;
}
cl_context CreateContext()
{
cl_int error_number;
cl_uint number_platforms;
cl_platform_id first_platform_id;
cl_context context = NULL;
error_number = clGetPlatformIDs(1, &first_platform_id, &number_platforms);
if (error_number != CL_SUCCESS || number_platforms <= 0)
{
std::cerr << "Failed to find any OpenCL platforms." << std::endl;
return NULL;
}
cl_context_properties context_properties[] = {
CL_CONTEXT_PLATFORM,
(cl_context_properties)first_platform_id,
0
};
context = clCreateContextFromType(context_properties,
CL_DEVICE_TYPE_GPU,
NULL,
NULL,
&error_number);
if (error_number != CL_SUCCESS)
{
std::cout << "Could not create GPU context, trying CPU..." << std::endl;
context = clCreateContextFromType(context_properties,
CL_DEVICE_TYPE_CPU,
NULL,
NULL,
&error_number);
if (error_number != CL_SUCCESS)
{
std::cerr << "Failed to create an OpenCL GPU or CPU context." << std::endl;
return NULL;
}
}
return context;
}
// Create an OpenCL context on the first available platform using
// either a GPU or CPU depending on what is available.
cl_context CreateContext(CLPlatform* platform)
{
// Create a context from the first platform (for now)
cl_context_properties contextProperties[] =
{
CL_CONTEXT_PLATFORM,
(cl_context_properties)platform->id,
0
};
cl_context context = NULL;
cl_int errNum;
context = clCreateContextFromType(contextProperties, CL_DEVICE_TYPE_ALL, NULL, NULL, &errNum);
return errNum == CL_SUCCESS ? context : NULL;
}
cl_int init_cl_context_from_gl(clctx_t *c, cl_platform_id platform)
{
cl_int ret=0;
ret = clewInit();
if (ret)
{
fprintf_rl(stderr, "clewInit() failed with code %d\n", ret);
return -1024;
}
#ifdef RL_OPENCL_GL
#if defined(_WIN32) // Windows from http://stackoverflow.com/a/30529217/1675589
cl_context_properties properties[] =
{
CL_GL_CONTEXT_KHR, (cl_context_properties)wglGetCurrentContext(),
CL_WGL_HDC_KHR, (cl_context_properties)wglGetCurrentDC(),
CL_CONTEXT_PLATFORM, (cl_context_properties)platform,
0
};
#elif defined(__APPLE__) // OS X
CGLContextObj kCGLContext = CGLGetCurrentContext();
CGLShareGroupObj kCGLShareGroup = CGLGetShareGroup(kCGLContext);
cl_context_properties properties[] =
{
CL_CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE,
(cl_context_properties) kCGLShareGroup,
0
};
#else // Linux
cl_context_properties properties[] =
{
CL_GL_CONTEXT_KHR, (cl_context_properties)glXGetCurrentContext(),
CL_GLX_DISPLAY_KHR, (cl_context_properties)glXGetCurrentDisplay(),
CL_CONTEXT_PLATFORM, (cl_context_properties)platform,
0
};
#endif
//c->context = clCreateContext(NULL, ret_num_devices, device_id, NULL, NULL, &ret);
c->context = clCreateContextFromType(properties, CL_DEVICE_TYPE_GPU, NULL, NULL, &ret);
CL_ERR_RET("clCreateContextFromType (in init_cl_context_from_gl)", ret);
#endif
return ret;
}
int createContext(cl_context* context)
{
cl_int errorNumber = 0;
cl_uint numberOfPlatforms = 0;
cl_platform_id firstPlatformID = 0;
/* Retrieve a single platform ID. */
clGetPlatformIDs(1, &firstPlatformID, &numberOfPlatforms);
/* Get a context with a GPU device from the platform found above. */
cl_context_properties contextProperties [] = {CL_CONTEXT_PLATFORM, (cl_context_properties)firstPlatformID, 0};
*context = clCreateContextFromType(contextProperties, CL_DEVICE_TYPE_GPU, NULL, NULL, &errorNumber);
LOGD("createContext code %d",errorNumber);
return 1;
}
void init() {
cl_uint n;
cl_platform_id *ids,id=NULL;
int i,status;
char s[MAXCHAR];
/* choose AMD platform if possible, otherwise just pick one */
if(CL_SUCCESS!=clGetPlatformIDs(0,NULL,&n))
error("error getting platforms 1");
if(NULL==(ids=malloc(sizeof(cl_platform_id)*n))) error("out of memory");
if(CL_SUCCESS!=clGetPlatformIDs(n,ids,NULL))
error("error getting platforms 2");
for(i=0;i<n;i++) {
if(CL_SUCCESS!=clGetPlatformInfo(ids[i],CL_PLATFORM_VENDOR,MAXCHAR,s,NULL))
error("error getting platform 3");
if(!strcmp(s,"Advanced Micro Devices, Inc.")) {
id=ids[i];
break;
}
}
if(i==n) id=ids[0];
free(ids);
/* get context stuff */
cl_context_properties cps[3]={CL_CONTEXT_PLATFORM,(cl_context_properties)id,0};
context=clCreateContextFromType(cps,CL_DEVICE_TYPE_CPU,NULL,NULL,&status);
if(CL_SUCCESS!=status) error("couldn't create context");
if(CL_SUCCESS!=clGetContextInfo(context,CL_CONTEXT_DEVICES,0,NULL,(size_t *)&n))
error("error getting context info 1");
if(!n) error("no devices!");
if(NULL==(devices=malloc(n))) error("out of memory");
if(CL_SUCCESS!=clGetContextInfo(context,CL_CONTEXT_DEVICES,n,devices,NULL))
error("error getting context info 2");
/* create opencl command queue */
cmdq=clCreateCommandQueue(context,devices[0],0,&status);
if(CL_SUCCESS!=status) error("error creating command queue");
/* create memory buffers */
initmem();
/* copy contents of in to inbuffer */
inbuffer=clCreateBuffer(context,CL_MEM_READ_WRITE|CL_MEM_USE_HOST_PTR,
MAXP,in,&status);
if(CL_SUCCESS!=status) {
printf("max alloc %d\n",(int)CL_DEVICE_MAX_MEM_ALLOC_SIZE);
printf("status %d\n",status);
error("error creating input buffer");
}
loadkernel("sieve.cl");
}
void createContextFromType(v8::FunctionArgs args)
{
if (args.Length() == 5)
{
auto array = GetArray(args[0]);
auto flags = GetNumber(args[1]);
const auto platformID = cl_context_properties(UnwrapPointer(array->Get(1)));
const auto platformType = array->Get(0)->NumberValue();
const auto platformIndex = array->Get(2)->NumberValue();
cl_context_properties properties[] = { (cl_prop)platformType, (cl_prop)platformID, (cl_prop)platformIndex };
cl_context context = clCreateContextFromType(properties, flags, nullptr, nullptr, nullptr);
Return(args, v8::WrapPointer(context));
}
}
/*------------------------------------------------------------------------------------------------------------
* コンストラクタ
*/
ClHelper::ClHelper()
:mContext((cl_context)0), mDevaiceId((cl_device_id)0),
mCommandQueue((cl_command_queue)0), mProgram((cl_program)0),
mKernel((cl_kernel)0)
{
cl_int status;
// create context for specified device
mContext = clCreateContextFromType(NULL,
// CL_DEVICE_TYPE_CPU, // CPUを使用
CL_DEVICE_TYPE_GPU, // GPUを使用
NULL,
NULL,
&status);
if (status != CL_SUCCESS) {
printError(status);
throw MyError("failed to create context.", __FUNCTION__);
}
// get device id from context
cl_device_id devices[10];
status = clGetContextInfo(mContext,
CL_CONTEXT_DEVICES,
sizeof(devices),
devices,
NULL);
if(status != CL_SUCCESS){
printError(status);
throw MyError("failed to get device id.", __FUNCTION__);
}
mDevaiceId = devices[0];
// Create command queue
mCommandQueue = clCreateCommandQueue(mContext,
devices[0],
0,
&status);
if(status != CL_SUCCESS){
printError(status);
throw MyError("failed to create command queue.", __FUNCTION__);
}
}
int SetCont(int plt_sel, int dev_sel, cl_context *cont)
{
// check if the environment is valid
// gain the device numbers
cl_int ret = clGetDeviceIDs(platforms[plt_sel], CL_DEVICE_TYPE_ALL,
0, NULL, &numDevices);
cl_errChk(ret,"Error >> clGetDeviceIDs");
if (dev_sel > numDevices)
{
printf("Invalid Device Number\n");
exit(1);
}
// get the select platform & device
ret = clGetDeviceIDs(platforms[plt_sel], CL_DEVICE_TYPE_ALL,
numDevices, Devices, NULL);
// check the device is a CPU or GPU
cl_device_type DeviceTyep;
//cl_device_id DeviceID;
//DeviceID = Devices[dev_sel];
ret = clGetDeviceInfo(Devices[dev_sel], CL_DEVICE_TYPE,
sizeof(DeviceTyep),(void *)&DeviceTyep,NULL);
cl_errChk(ret,"Error >> clGetDeviceInfo_DeviceTyep");
if(DeviceTyep == CL_DEVICE_TYPE_GPU)
printf("Creating GPU Context\n");
else if (DeviceTyep == CL_DEVICE_TYPE_CPU)
printf("Creating CPU Context\n");
else
printf("This Context Type not Supported.\n");
// Create a context
cl_context_properties prop[3] = {CL_CONTEXT_PLATFORM,
(cl_context_properties) platforms[plt_sel], 0 };
*cont = clCreateContextFromType(prop,
(cl_device_type)DeviceTyep, NULL, NULL, &ret);
if (*cont == 0)
{
printf("Cannot create OpenCL context\n");
return 0;
}
return 0;
}
cl_context WINAPI wine_clCreateContextFromType(const cl_context_properties * properties, cl_device_type device_type,
void WINAPI (*pfn_notify)(const char *errinfo, const void *private_info, size_t cb, void *user_data),
void * user_data, cl_int * errcode_ret)
{
cl_context ret;
CONTEXT_CALLBACK *ccb;
TRACE("(%p, 0x%lx, %p, %p, %p)\n", properties, (long unsigned int)device_type, pfn_notify, user_data, errcode_ret);
/* FIXME: The CONTEXT_CALLBACK structure is currently leaked.
* Pointers to callback redirectors should be remembered and free()d when the context is destroyed.
* The problem is determining when a context is being destroyed. clReleaseContext only decrements
* the use count for a context, its destruction can come much later and therefore there is a risk
* that the callback could be invoked after the user_data memory has been free()d.
*/
ccb = HeapAlloc(GetProcessHeap(), 0, sizeof(CONTEXT_CALLBACK));
ccb->pfn_notify = pfn_notify;
ccb->user_data = user_data;
ret = clCreateContextFromType(properties, device_type, context_fn_notify, ccb, errcode_ret);
TRACE("(%p, 0x%lx, %p, %p, %p (%d)))=%p\n", properties, (long unsigned int)device_type, pfn_notify, user_data, errcode_ret, errcode_ret ? *errcode_ret : 0, ret);
return ret;
}
static void
init_context(void)
{
cl_int err;
cl_uint n;
cl_platform_id *plats;
cl_context_properties props[3];
cl_context c;
if (ctx != NULL) return;
err = clGetPlatformIDs(0, NULL, &n);
if (err != CL_SUCCESS) return;
plats = (cl_platform_id *)calloc(n, sizeof(cl_platform_id));
if (plats == NULL) return;
err = clGetPlatformIDs(n, plats, NULL);
if (err != CL_SUCCESS) goto fail_id;
props[0] = CL_CONTEXT_PLATFORM;
props[1] = (cl_context_properties)plats[0];
props[2] = 0;
c = clCreateContextFromType(props, CL_DEVICE_TYPE_GPU, NULL, NULL, &err);
if (err != CL_SUCCESS) {
fprintf(stderr, "Could not create context, will fail later (%d)!\n", err);
/* error - error - error */
/* but we do nothing */
goto fail_id;
}
free(plats);
setup_context(c);
clReleaseContext(c);
return;
fail_id:
free(plats);
}
/* Java->C glue code:
* Java package: com.jogamp.opencl.impl.CLImpl
* Java method: long clCreateContextFromType(java.nio.IntBuffer props, long device_type, CreateContextCallback pfn_notify, Object userData, IntBuffer errcode_ret)
* C function: cl_context clCreateContextFromType( cl_context_properties * properties ,
* cl_uint num_devices ,
* const cl_device_id * devices ,
* void (*pfn_notify)(const char *, const void *, size_t, void *) pfn_notify/,
* void * user_data ,
* cl_int * errcode_ret );
*/
JNIEXPORT jlong JNICALL
Java_com_jogamp_opencl_impl_CLImpl_clCreateContextFromType0(JNIEnv *env, jobject _unused,
jobject props, jint props_byte_offset, jobject device_type, jobject cb, jobject data, jobject errcode, jint errcode_byte_offset) {
cl_context_properties* _props_ptr = NULL;
int32_t * _errcode_ptr = NULL;
cl_context _ctx;
if (props != NULL) {
_props_ptr = (cl_context_properties*) (((char*) (*env)->GetDirectBufferAddress(env, props)) + props_byte_offset);
}
if (errcode != NULL) {
_errcode_ptr = (void *) (((char*) (*env)->GetDirectBufferAddress(env, errcode)) + errcode_byte_offset);
}
//TODO callback; payload
_ctx = clCreateContextFromType(_props_ptr, (uint64_t) device_type, NULL, NULL, (int32_t *) _errcode_ptr);
return (jlong) (intptr_t)_ctx;
}
