Context::Context(LuxRaysDebugHandler handler, const int openclPlatformIndex, const bool verb) { debugHandler = handler; currentDataSet = NULL; started = false; verbose = verb; // Get the list of devices available on the platform NativeThreadDeviceDescription::AddDeviceDescs(deviceDescriptions); #if !defined(LUXRAYS_DISABLE_OPENCL) // Platform info VECTOR_CLASS<cl::Platform> platforms; cl::Platform::get(&platforms); for (size_t i = 0; i < platforms.size(); ++i) LR_LOG(this, "OpenCL Platform " << i << ": " << platforms[i].getInfo<CL_PLATFORM_VENDOR>().c_str()); if (openclPlatformIndex < 0) { if (platforms.size() > 0) { // Just use all the platforms available for (size_t i = 0; i < platforms.size(); ++i) OpenCLDeviceDescription::AddDeviceDescs( platforms[i], DEVICE_TYPE_OPENCL_ALL, deviceDescriptions); } else LR_LOG(this, "No OpenCL platform available"); } else { if ((platforms.size() == 0) || (openclPlatformIndex >= (int)platforms.size())) throw std::runtime_error("Unable to find an appropriate OpenCL platform"); else { OpenCLDeviceDescription::AddDeviceDescs( platforms[openclPlatformIndex], DEVICE_TYPE_OPENCL_ALL, deviceDescriptions); } } #endif // Print device info for (size_t i = 0; i < deviceDescriptions.size(); ++i) { DeviceDescription *desc = deviceDescriptions[i]; LR_LOG(this, "Device " << i << " name: " << desc->GetName()); LR_LOG(this, "Device " << i << " type: " << DeviceDescription::GetDeviceType(desc->GetType())); LR_LOG(this, "Device " << i << " compute units: " << desc->GetComputeUnits()); LR_LOG(this, "Device " << i << " preferred float vector width: " << desc->GetNativeVectorWidthFloat()); LR_LOG(this, "Device " << i << " max allocable memory: " << desc->GetMaxMemory() / (1024 * 1024) << "MBytes"); LR_LOG(this, "Device " << i << " max allocable memory block size: " << desc->GetMaxMemoryAllocSize() / (1024 * 1024) << "MBytes"); } }
void OpenCLPrinter::printContextInfo(cl::Context context) { print("--- ContextInfo ---", ""); VECTOR_CLASS<cl::Device> devices = context.getInfo<CL_CONTEXT_DEVICES>(); print("Number of devices", devices.size()); for(int i=0; i<devices.size(); ++i) printDeviceInfo(devices[i]); }
cl::Program *oclKernelVolatileCache::Compile(cl::Context &context, cl::Device& device, const std::string &kernelsParameters, const std::string &kernelSource, bool *cached, cl::STRING_CLASS *error) { // Check if the kernel is available in the cache std::map<std::string, cl::Program::Binaries>::iterator it = kernelCache.find(kernelsParameters); if (it == kernelCache.end()) { // It isn't available, compile the source cl::Program *program = ForcedCompile( context, device, kernelsParameters, kernelSource, error); if (!program) return NULL; // Obtain the binaries of the sources VECTOR_CLASS<char *> bins = program->getInfo<CL_PROGRAM_BINARIES>(); assert (bins.size() == 1); VECTOR_CLASS<size_t> sizes = program->getInfo<CL_PROGRAM_BINARY_SIZES>(); assert (sizes.size() == 1); if (sizes[0] > 0) { // Add the kernel to the cache char *bin = new char[sizes[0]]; memcpy(bin, bins[0], sizes[0]); kernels.push_back(bin); kernelCache[kernelsParameters] = cl::Program::Binaries(1, std::make_pair(bin, sizes[0])); } if (cached) *cached = false; return program; } else { // Compile from the binaries VECTOR_CLASS<cl::Device> buildDevice; buildDevice.push_back(device); cl::Program *program = new cl::Program(context, buildDevice, it->second); program->build(buildDevice); if (cached) *cached = true; return program; } }
CLDeviceSelection::CLDeviceSelection(const QString selectString, bool allowGPU, bool allowCPU) { VECTOR_CLASS<cl::Platform> platforms; CL_DETECT_ERROR(cl::Platform::get(&platforms)); int selectIndex = 0; qDebug().nospace().noquote()<<"Making OpenCL device selection with selectstring='"<< selectString<< "', allowGPU="<<allowGPU<<", allowCPU="<<allowCPU<<""; for (size_t i = 0; i < platforms.size(); ++i) { qDebug().nospace().noquote()<<"Platform-" << i << ": " << QString::fromLocal8Bit(platforms[i].getInfo<CL_PLATFORM_VENDOR>().c_str()); // Get the list of devices available on the platform VECTOR_CLASS<cl::Device> devices; platforms[i].getDevices(CL_DEVICE_TYPE_ALL, &devices); for (size_t j = 0; j < devices.size(); ++j) { bool selected = false; auto type=devices[j].getInfo<CL_DEVICE_TYPE>(); if ((allowGPU && (type == CL_DEVICE_TYPE_GPU)) || (allowCPU && (type == CL_DEVICE_TYPE_CPU))) { if (selectString.length() == 0) { selected = true; } else { if (selectString.length() <= selectIndex) { qWarning()<< "OpenCL select devices string (opencl.devices.select) has the wrong length"; exit(1); } if (selectString.at(selectIndex) == '1') { selected = true; } } } if (selected) { push_back(devices[j]); } qDebug().nospace()<< " |-- Device-"<<i <<"."<<j <<": "<< devices[j]<<(selected?" [SEL]":" [---]"); ++selectIndex; } } if (size() == 0) { qWarning()<<"This program requires OpenCL enabled hardware. Unable to find any OpenCL GPU devices, so quitting"; exit(1); } }
void OpenCLPrinter::printPlatformAndDeviceInfo() { VECTOR_CLASS<cl::Platform> platforms; cl::Platform::get(&platforms); VECTOR_CLASS<cl::Device> devices; for(unsigned int i = 0; i < platforms.size(); i++) { printPlatformInfo(platforms[i]); platforms[i].getDevices(CL_DEVICE_TYPE_ALL, &devices); for(unsigned int j = 0; j < devices.size(); j++) { printDeviceInfo(devices[j]); } } print("Number of platforms", platforms.size()); print("Number of devices", devices.size()); }
cl::Program *oclKernelPersistentCache::Compile(cl::Context &context, cl::Device& device, const std::string &kernelsParameters, const std::string &kernelSource, bool *cached, cl::STRING_CLASS *error) { // Check if the kernel is available in the cache cl::Platform platform = device.getInfo<CL_DEVICE_PLATFORM>(); std::string platformName = platform.getInfo<CL_PLATFORM_VENDOR>(); std::string deviceName = device.getInfo<CL_DEVICE_NAME>(); std::string deviceUnits = ToString(device.getInfo<CL_DEVICE_MAX_COMPUTE_UNITS>()); std::string kernelName = HashString(kernelsParameters) + "-" + HashString(kernelSource) + ".ocl"; std::string dirName = "kernel_cache/" + appName + "/" + platformName + "/" + deviceName + "/" + deviceUnits; std::string fileName = dirName +"/" +kernelName; if (!boost::filesystem::exists(fileName)) { // It isn't available, compile the source cl::Program *program = ForcedCompile( context, device, kernelsParameters, kernelSource, error); if (!program) return NULL; // Obtain the binaries of the sources VECTOR_CLASS<char *> bins = program->getInfo<CL_PROGRAM_BINARIES>(); assert (bins.size() == 1); VECTOR_CLASS<size_t> sizes = program->getInfo<CL_PROGRAM_BINARY_SIZES >(); assert (sizes.size() == 1); // Create the file only if the binaries include something if (sizes[0] > 0) { // Add the kernel to the cache boost::filesystem::create_directories(dirName); BOOST_OFSTREAM file(fileName.c_str(), std::ios_base::out | std::ios_base::binary); file.write(bins[0], sizes[0]); // Check for errors char buf[512]; if (file.fail()) { sprintf(buf, "Unable to write kernel file cache %s", fileName.c_str()); throw std::runtime_error(buf); } file.close(); } if (cached) *cached = false; return program; } else { const size_t kernelSize = boost::filesystem::file_size(fileName); if (kernelSize > 0) { char *kernelBin = new char[kernelSize]; BOOST_IFSTREAM file(fileName.c_str(), std::ios_base::in | std::ios_base::binary); file.read(kernelBin, kernelSize); // Check for errors char buf[512]; if (file.fail()) { sprintf(buf, "Unable to read kernel file cache %s", fileName.c_str()); throw std::runtime_error(buf); } file.close(); // Compile from the binaries VECTOR_CLASS<cl::Device> buildDevice; buildDevice.push_back(device); cl::Program *program = new cl::Program(context, buildDevice, cl::Program::Binaries(1, std::make_pair(kernelBin, kernelSize))); program->build(buildDevice); if (cached) *cached = true; delete[] kernelBin; return program; } else { // Something wrong in the file, remove the file and retry boost::filesystem::remove(fileName); return Compile(context, device, kernelsParameters, kernelSource, cached, error); } } }
void printDeviceInfo(const cl::Device &device, cl_device_info info) { if (!initialized) { printf("not initialized. call initCLUtility()."); } printf("%s: ", clDeviceInfoMetaInfos[info].name); switch (clDeviceInfoMetaInfos[info].infoType) { case CLDeviceInfoType_bool: { cl_bool val; device.getInfo(info, &val); printf(val != 0 ? "YES" : "NO"); break; } case CLDeviceInfoType_uint: { cl_uint val; device.getInfo(info, &val); printf("%u", val); break; } case CLDeviceInfoType_ulong: { cl_ulong val; device.getInfo(info, &val); printf("%llu", val); break; } case CLDeviceInfoType_size_t: { size_t val; device.getInfo(info, &val); printf("%lu", val); break; } case CLDeviceInfoType_string: { std::string val; device.getInfo(info, &val); printf("%s", val.c_str()); break; } case CLDeviceInfoType_size_t_vec: { VECTOR_CLASS<size_t> val; device.getInfo(info, &val); for (uint32_t i = 0; i < val.size() - 1; ++i) { printf("%lu, ", val[i]); } printf("%lu", val.back()); break; } case CLDeviceInfoType_device_id: { cl_device_id val; device.getInfo(info, &val); printf("%#018llx", (uint64_t)val); break; } case CLDeviceInfoType_platform_id: { cl_platform_id val; device.getInfo(info, &val); printf("%#018llx", (uint64_t)val); break; } case CLDeviceInfoType_device_type: { cl_device_type val; device.getInfo(info, &val); switch (val) { case CL_DEVICE_TYPE_CPU: printf("CPU"); break; case CL_DEVICE_TYPE_GPU: printf("GPU"); break; case CL_DEVICE_TYPE_ACCELERATOR: printf("Accelerator"); break; case CL_DEVICE_TYPE_CUSTOM: printf("Custom"); break; default: break; } break; } case CLDeviceInfoType_device_fp_config: { cl_device_fp_config val; device.getInfo(info, &val); if ((val & CL_FP_DENORM) != 0) printf("CL_FP_DENORM "); if ((val & CL_FP_INF_NAN) != 0) printf("CL_FP_INF_NAN "); if ((val & CL_FP_ROUND_TO_NEAREST) != 0) printf("CL_FP_ROUND_TO_NEAREST "); if ((val & CL_FP_ROUND_TO_ZERO) != 0) printf("CL_FP_ROUND_TO_ZERO "); if ((val & CL_FP_ROUND_TO_INF) != 0) printf("CL_FP_ROUND_TO_INF "); if ((val & CL_FP_FMA) != 0) printf("CL_FP_FMA "); if ((val & CL_FP_SOFT_FLOAT) != 0) printf("CL_FP_SOFT_FLOAT "); if ((val & CL_FP_CORRECTLY_ROUNDED_DIVIDE_SQRT) != 0) printf("CL_FP_CORRECTLY_ROUNDED_DIVIDE_SQRT "); break; } case CLDeviceInfoType_device_local_mem_type: { cl_device_local_mem_type val; device.getInfo(info, &val); switch (val) { case CL_LOCAL: printf("Local"); break; case CL_GLOBAL: printf("Global"); default: break; } break; } case CLDeviceInfoType_device_mem_cache_type: { cl_device_mem_cache_type val; device.getInfo(info, &val); switch (val) { case CL_NONE: printf("None"); break; case CL_READ_ONLY_CACHE: printf("Read Only Cache"); break; case CL_READ_WRITE_CACHE: printf("Read Write Cache"); break; default: break; } break; } case CLDeviceInfoType_device_exec_capabilities: { cl_device_exec_capabilities val; device.getInfo(info, &val); if ((val & CL_EXEC_KERNEL) != 0) printf("CL_EXEC_KERNEL "); if ((val & CL_EXEC_NATIVE_KERNEL) != 0) printf("CL_EXEC_NATIVE_KERNEL "); break; } case CLDeviceInfoType_command_queue_properties: { cl_command_queue_properties val; device.getInfo(info, &val); if ((val & CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE) != 0) printf("CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE "); if ((val & CL_QUEUE_PROFILING_ENABLE) != 0) printf("CL_QUEUE_PROFILING_ENABLE "); break; } case CLDeviceInfoType_device_affinity_domain: { cl_device_affinity_domain val; device.getInfo(info, &val); if ((val & CL_DEVICE_AFFINITY_DOMAIN_NUMA) != 0) printf("CL_DEVICE_AFFINITY_DOMAIN_NUMA "); if ((val & CL_DEVICE_AFFINITY_DOMAIN_L4_CACHE) != 0) printf("CL_DEVICE_AFFINITY_DOMAIN_L4_CACHE "); if ((val & CL_DEVICE_AFFINITY_DOMAIN_L3_CACHE) != 0) printf("CL_DEVICE_AFFINITY_DOMAIN_L3_CACHE "); if ((val & CL_DEVICE_AFFINITY_DOMAIN_L2_CACHE) != 0) printf("CL_DEVICE_AFFINITY_DOMAIN_L2_CACHE "); if ((val & CL_DEVICE_AFFINITY_DOMAIN_L1_CACHE) != 0) printf("CL_DEVICE_AFFINITY_DOMAIN_L1_CACHE "); if ((val & CL_DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE) != 0) printf("CL_DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE "); break; } case CLDeviceInfoType_device_partition_property_vec: { VECTOR_CLASS<cl_device_partition_property> val; device.getInfo(info, &val); for (uint32_t i = 0; i < val.size(); ++i) { switch (val[i]) { case CL_DEVICE_PARTITION_EQUALLY: printf("CL_DEVICE_PARTITION_EQUALLY"); break; case CL_DEVICE_PARTITION_BY_COUNTS: printf("CL_DEVICE_PARTITION_BY_COUNTS"); break; case CL_DEVICE_PARTITION_BY_COUNTS_LIST_END: printf("CL_DEVICE_PARTITION_BY_COUNTS_LIST_END"); break; case CL_DEVICE_PARTITION_BY_AFFINITY_DOMAIN: printf("CL_DEVICE_PARTITION_BY_AFFINITY_DOMAIN"); break; default: break; } if (i < val.size() - 1) printf(", "); } break; } default: break; } printf("\n"); }
int main(int argc, char* argv[]) { cl_int retCode; // get platforms const cl_platform_info PLATFORM_INFOS[] = { CL_PLATFORM_NAME, CL_PLATFORM_VENDOR, CL_PLATFORM_PROFILE, CL_PLATFORM_VERSION }; VECTOR_CLASS<Platform> platforms; retCode = Platform::get(&platforms); if (retCode != CL_SUCCESS) die("failed to get platforms"); std::cout << "platforms found: " << platforms.size() << std::endl; for (uint i = 0; i < platforms.size(); i++) { std::cout << "platform " << i+1 << ": "; for (uint j = 0; j < (sizeof(PLATFORM_INFOS) / sizeof(cl_platform_info)); j++) { STRING_CLASS info; retCode = platforms[i].getInfo(PLATFORM_INFOS[j], &info); if (retCode != CL_SUCCESS) die("failed to get platform info"); std::cout << info << " "; } std::cout << std::endl; // get devices const cl_device_info DEVICE_INFOS[] = { CL_DEVICE_NAME, CL_DEVICE_VENDOR, CL_DEVICE_PROFILE, CL_DEVICE_VERSION, CL_DRIVER_VERSION, CL_DEVICE_OPENCL_C_VERSION }; VECTOR_CLASS<Device> devices; retCode = platforms[i].getDevices(CL_DEVICE_TYPE_ALL, &devices); if (retCode != CL_SUCCESS) die(" failed to get devices"); std::cout << " devices found: " << devices.size() << std::endl; for (uint j = 0; j < devices.size(); j++) { std::cout << " device " << j+1 << ": "; for (uint k = 0; k < (sizeof(DEVICE_INFOS) / sizeof(cl_device_info)); k++) { STRING_CLASS info; retCode = devices[j].getInfo(DEVICE_INFOS[k], &info); if (retCode != CL_SUCCESS) die(" failed to get device info"); std::cout << info << " "; } cl_ulong memSize; retCode = devices[j].getInfo(CL_DEVICE_GLOBAL_MEM_SIZE, &memSize); if (retCode != CL_SUCCESS) die(" failed to get device info"); std::cout << "GlobalMemSize:" << memSize / 1024 / 1024 << "MB "; retCode = devices[j].getInfo(CL_DEVICE_LOCAL_MEM_SIZE, &memSize); if (retCode != CL_SUCCESS) die(" failed to get device info"); std::cout << "LocalMemSize:" << memSize / 1024 << "KB "; std::cout << std::endl; } } }
OCLRenderer::OCLRenderer(GameLevel *level) : LevelRenderer(level) { compiledScene = new CompiledScene(level); timeSinceLastCameraEdit = WallClockTime(); timeSinceLastNoCameraEdit = timeSinceLastCameraEdit; //-------------------------------------------------------------------------- // OpenCL setup //-------------------------------------------------------------------------- vector<cl::Device> selectedDevices; // Scan all platforms and devices available VECTOR_CLASS<cl::Platform> platforms; cl::Platform::get(&platforms); const string &selectString = gameLevel->gameConfig->GetOpenCLDeviceSelect(); size_t selectIndex = 0; for (size_t i = 0; i < platforms.size(); ++i) { SFERA_LOG("[OCLRenderer] OpenCL Platform " << i << ": " << platforms[i].getInfo<CL_PLATFORM_VENDOR>()); // Get the list of devices available on the platform VECTOR_CLASS<cl::Device> devices; platforms[i].getDevices(CL_DEVICE_TYPE_ALL, &devices); for (size_t j = 0; j < devices.size(); ++j) { SFERA_LOG("[OCLRenderer] OpenCL device " << j << ": " << devices[j].getInfo<CL_DEVICE_NAME>()); SFERA_LOG("[OCLRenderer] Type: " << OCLDeviceTypeString(devices[j].getInfo<CL_DEVICE_TYPE>())); SFERA_LOG("[OCLRenderer] Units: " << devices[j].getInfo<CL_DEVICE_MAX_COMPUTE_UNITS>()); SFERA_LOG("[OCLRenderer] Global memory: " << devices[j].getInfo<CL_DEVICE_GLOBAL_MEM_SIZE>() / 1024 << "Kbytes"); SFERA_LOG("[OCLRenderer] Local memory: " << devices[j].getInfo<CL_DEVICE_LOCAL_MEM_SIZE>() / 1024 << "Kbytes"); SFERA_LOG("[OCLRenderer] Local memory type: " << OCLLocalMemoryTypeString(devices[j].getInfo<CL_DEVICE_LOCAL_MEM_TYPE>())); SFERA_LOG("[OCLRenderer] Constant memory: " << devices[j].getInfo<CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE>() / 1024 << "Kbytes"); bool selected = false; if (!gameLevel->gameConfig->GetOpenCLUseOnlyGPUs() || (devices[j].getInfo<CL_DEVICE_TYPE>() == CL_DEVICE_TYPE_GPU)) { if (selectString.length() == 0) selected = true; else { if (selectString.length() <= selectIndex) throw runtime_error("OpenCL select devices string (opencl.devices.select) has the wrong length"); if (selectString.at(selectIndex) == '1') selected = true; } } if (selected) { selectedDevices.push_back(devices[j]); SFERA_LOG("[OCLRenderer] SELECTED"); } else SFERA_LOG("[OCLRenderer] NOT SELECTED"); ++selectIndex; } } if (selectedDevices.size() == 0) throw runtime_error("Unable to find a OpenCL GPU device"); // Create synchronization barrier barrier = new boost::barrier(selectedDevices.size() + 1); totSamplePerPass = 0; for (size_t i = 0; i < selectedDevices.size(); ++i) totSamplePerPass += gameLevel->gameConfig->GetOpenCLDeviceSamplePerPass(i); renderThread.resize(selectedDevices.size(), NULL); for (size_t i = 0; i < selectedDevices.size(); ++i) { OCLRendererThread *rt = new OCLRendererThread(i, this, selectedDevices[i]); renderThread[i] = rt; } for (size_t i = 0; i < renderThread.size(); ++i) renderThread[i]->Start(); }
OCLutil::OCLutil(cl_device_type type,std::string arq,std::string buildOptions,std::string nomeRot,int n) { VECTOR_CLASS<cl::Platform> platforms; cl::Platform::get(&platforms); if(platforms.size() == 0){ std::cout<<"No OpenCL platforms were found"<<std::endl; } int platformID = -1; for(unsigned int i = 0; i < platforms.size(); i++) { try { VECTOR_CLASS<cl::Device> devices; platforms[i].getDevices(type, &devices); platformID = i; break; } catch(std::exception e) { std::cout<<"Error ao ler plataforma: "<<std::endl; continue; } } if(platformID == -1){ std::cout<<"No compatible OpenCL platform found"<<std::endl; } cl::Platform platform = platforms[platformID]; std::cout << "Using platform vendor: " << platform.getInfo<CL_PLATFORM_VENDOR>() << std::endl; // Use the preferred platform and create a context cl_context_properties cps[] = { CL_CONTEXT_PLATFORM, (cl_context_properties)(platform)(), 0 }; try { context = cl::Context(type, cps); } catch(std::exception e) { std::cout<<"Failed to create an OpenCL context!"<<std::endl; } std::string filename = arq; std::ifstream sourceFile(filename.c_str()); if(sourceFile.fail()) std::cout<<"Failed to open OpenCL source file"<<std::endl; std::string sourceCode( std::istreambuf_iterator<char>(sourceFile), (std::istreambuf_iterator<char>())); cl::Program::Sources source(1, std::make_pair(sourceCode.c_str(), sourceCode.length()+1)); // Make program of the source code in the context cl::Program program = cl::Program(context, source); VECTOR_CLASS<cl::Device> devices = context.getInfo<CL_CONTEXT_DEVICES>(); std::string deviceInfo; cl_ulong memInfo; size_t tam; cl_uint clUnit; int indexDev = 0; int maxU = 0; for (int i = 0; i < devices.size(); ++i) { devices[i].getInfo((cl_device_info) CL_DEVICE_NAME, &deviceInfo); std::cout << "Device info: " << deviceInfo << std::endl; devices[i].getInfo((cl_device_info) CL_DEVICE_VERSION, &deviceInfo); std::cout << "Versão CL: " << deviceInfo << std::endl; devices[i].getInfo((cl_device_info) CL_DRIVER_VERSION, &deviceInfo); std::cout << "Versão Driver: " << deviceInfo << std::endl; devices[i].getInfo((cl_device_info) CL_DEVICE_GLOBAL_MEM_SIZE, &memInfo); std::cout << "Memoria Global: " << memInfo << std::endl; devices[i].getInfo((cl_device_info) CL_DEVICE_LOCAL_MEM_SIZE, &memInfo); std::cout << "Memoria Local: " << memInfo << std::endl; devices[i].getInfo((cl_device_info) CL_DEVICE_LOCAL_MEM_SIZE, &tam); std::cout << "Max tamanho Work-group: " << tam << std::endl; devices[i].getInfo((cl_device_info) CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, &clUnit); std::cout << "Max dimensao: " << clUnit << std::endl; devices[i].getInfo((cl_device_info) CL_DEVICE_MAX_COMPUTE_UNITS, &clUnit); std::cout << "Unidades CL: " << clUnit << std::endl; std::cout << "*********************************" << std::endl; if((int)clUnit>maxU){ indexDev = i; maxU = (int)clUnit; } } // Build program for these specific devices cl_int error = program.build(devices, buildOptions.c_str()); if(error != 0) { std::cout << "Build log:" << std::endl << program.getBuildInfo<CL_PROGRAM_BUILD_LOG>(devices[0]) << std::endl; } std::cout << "Index Dispositino selecionado: " << indexDev << std::endl; queue = cl::CommandQueue(context, devices[indexDev]); int posi = 0; int posf = 0; for(int i = 0; i < n; i++){ posf = nomeRot.find(",",posi); std::string nomeRoti; if(posf != -1){ nomeRoti = nomeRot.substr(posi,posf-posi); }else{ nomeRoti = nomeRot.substr(posi); } std::cout<<"Nome rotina["<<i<<"]: "<<nomeRoti.data()<<std::endl; rotina.push_back(cl::Kernel(program, nomeRoti.data())); posi = posf + 1; } }