SEXP getDeviceType(SEXP sDeviceID){ resetError("ROpenCL::getDeviceType"); Rcpp::XPtr<cl_device_id> deviceID(sDeviceID); std::string str = "UNKNOWN"; #ifdef CL_DEVICE_TYPE cl_device_type dt = 0; logError( clGetDeviceInfo(*deviceID,CL_DEVICE_TYPE, sizeof(cl_device_type), &dt, NULL) ); # ifdef CL_DEVICE_TYPE_DEFAULT if (dt & CL_DEVICE_TYPE_DEFAULT) str = "CL_DEVICE_TYPE_DEFAULT"; # endif # ifdef CL_DEVICE_TYPE_CPU if (dt & CL_DEVICE_TYPE_CPU) str = "CL_DEVICE_TYPE_CPU"; # endif # ifdef CL_DEVICE_TYPE_GPU if (dt & CL_DEVICE_TYPE_GPU) str = "CL_DEVICE_TYPE_GPU"; # endif # ifdef CL_DEVICE_TYPE_ACCELERATOR if (dt & CL_DEVICE_TYPE_ACCELERATOR) str = "CL_DEVICE_TYPE_ACCELERATOR"; # endif # ifdef CL_DEVICE_TYPE_CUSTOM if (dt & CL_DEVICE_TYPE_CUSTOM) str = "CL_DEVICE_TYPE_CUSTOM"; # endif #endif PRINTONERROR(); return Rcpp::wrap(str); }
void InstagramClient::login(QString username, QString password, QJSValue callback) { qDebug() << SETTINGS_PATH; qDebug() << phoneIDConfItem->key(); QJsonObject json; json["phone_id"] = phoneID(); //json["_csrftoken"] = createCleanedUuid().remove(QChar('-')); json["username"] = username; json["guid"] = guid(); json["device_id"] = deviceID(); json["password"] = password; json["login_attempt_count"] = 0; QByteArray body = this->getSignedBody(json); qDebug() << "Signed Body:" << body; auto key = QUuid::createUuid(); if (!callback.isUndefined()) callbacks->insert(key, callback); QNetworkRequest req(QUrl("https://i.instagram.com/api/v1/accounts/login/")); req.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded; charset=UTF-8"); req.setAttribute(QNetworkRequest::User, key); this->setRequiredHeaders(req); loginNetworkAccessManager->setCookieJar(DConfCookieJar::createTemporaryCookieJar(this)); loginNetworkAccessManager->post(req, body); }
SEXP getKernelWorkGroupInfo(SEXP sKernel, SEXP sDeviceID){ resetError("ROpenCL::getKernelWorkGroupInfo"); Rcpp::XPtr<cl_kernel> kernel(sKernel); Rcpp::XPtr<cl_device_id> deviceID(sDeviceID); size_t sval; size_t sizes[3]; cl_ulong ulval; Rcpp::List result; #ifdef CL_KERNEL_WORK_GROUP_SIZE /* size_t */ sval = 0; if (!logError( clGetKernelWorkGroupInfo(*kernel, *deviceID, CL_KERNEL_WORK_GROUP_SIZE, sizeof(sval), &sval, NULL) )) { result["CL_KERNEL_WORK_GROUP_SIZE"] = Rcpp::wrap(sval); } #endif #ifdef CL_KERNEL_COMPILE_WORK_GROUP_SIZE /* 3x size_t */ sizes[0] = sizes[1] = sizes[2] = 0; if (!logError( clGetKernelWorkGroupInfo(*kernel, *deviceID, CL_KERNEL_COMPILE_WORK_GROUP_SIZE, 3*sizeof(size_t), &sizes, NULL) )) { Rcpp::List wgs; wgs.push_back(Rcpp::wrap(sizes[0])); wgs.push_back(Rcpp::wrap(sizes[1])); wgs.push_back(Rcpp::wrap(sizes[2])); result["CL_KERNEL_COMPILE_WORK_GROUP_SIZE"] = Rcpp::wrap(wgs); } #endif #ifdef CL_KERNEL_LOCAL_MEM_SIZE /* ulong */ ulval = 0; if (!logError( clGetKernelWorkGroupInfo(*kernel, *deviceID, CL_KERNEL_LOCAL_MEM_SIZE, sizeof(ulval), &ulval, NULL) )) { result["CL_KERNEL_LOCAL_MEM_SIZE"] = Rcpp::wrap(ulval); } #endif #ifdef CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE /* size_t */ sval = 0; if (!logError( clGetKernelWorkGroupInfo(*kernel, *deviceID, CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE, sizeof(sval), &sval, NULL) )) { result["CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE"] = Rcpp::wrap(sval); } #endif #ifdef CL_KERNEL_PRIVATE_MEM_SIZE /* ulong */ ulval = 0; if (!logError( clGetKernelWorkGroupInfo(*kernel, *deviceID, CL_KERNEL_PRIVATE_MEM_SIZE, sizeof(ulval), &ulval, NULL) )) { result["CL_KERNEL_PRIVATE_MEM_SIZE"] = Rcpp::wrap(ulval); } #endif //#ifdef CL_KERNEL_GLOBAL_WORK_SIZE /* 3x size_t */ TODO FIX THIS /* sizes[0] = sizes[1] = sizes[2] = 0; if (!logError( clGetKernelWorkGroupInfo(*kernel, *deviceID, CL_KERNEL_GLOBAL_WORK_SIZE, 3*sizeof(size_t), &sizes, NULL) )) { Rcpp::List gws; gws.push_back(Rcpp::wrap(sizes[0])); gws.push_back(Rcpp::wrap(sizes[1])); gws.push_back(Rcpp::wrap(sizes[2])); result["CL_KERNEL_GLOBAL_WORK_SIZE"] = Rcpp::wrap(gws); } */ //#endif PRINTONERROR(); return result; }
SEXP createContext(SEXP sDeviceID){ Rcpp::XPtr<cl_device_id> deviceID(sDeviceID); cl_context *context = new cl_context; *context = clCreateContext(0, 1, deviceID, NULL, NULL, NULL); Rcpp::XPtr<cl_context> tempXPtr(context); return tempXPtr; }
SEXP createCommandQueue(SEXP sContext, SEXP sDeviceID){ Rcpp::XPtr<cl_context> context(sContext); Rcpp::XPtr<cl_device_id> deviceID(sDeviceID); cl_command_queue *queue = new cl_command_queue; *queue = clCreateCommandQueue(*context, *deviceID, 0, NULL); Rcpp::XPtr<cl_command_queue> tempXPtr(queue); return tempXPtr; }
//------------------------------------------------------------------------------ //! String Event::toStr() const { String tmp; tmp += "{"; tmp += typeToStr(type()); tmp += ","; tmp += String().format("t=%f", timestamp()); tmp += ","; switch( type() ) { case POINTER_PRESS : case POINTER_RELEASE: case POINTER_MOVE : case POINTER_ENTER : case POINTER_LEAVE : case POINTER_CHANGE : case POINTER_SCROLL : case POINTER_DELETE : case POINTER_CANCEL : { tmp += String().format( "ptrID=%d", pointerID() ); tmp += ","; tmp += String().format( "val=%d", value() ); tmp += ","; tmp += String().format( "pos=(%f,%f)", position().x, position().y ); tmp += ","; tmp += String().format( "cnt=%d", count() ); } break; case KEY_PRESS: case KEY_RELEASE: case CHAR: { tmp += String().format( "val=%d", value() ); tmp += ","; tmp += String().format( "cnt=%d", count() ); } break; case HID_EVENT: { tmp += String().format( "devTypeID=%d", deviceTypeID() ); tmp += ","; tmp += String().format( "devID=%d", deviceID() ); tmp += ","; tmp += String().format( "ctrlID=%d", controlID() ); tmp += ","; tmp += String().format( "val=%f", valueFloat() ); } break; case ACCELERATE: { tmp += String().format( "(%f,%f,%f", dx(), dy(), dz() ); } break; default: break; } tmp += "}"; return tmp; }
SEXP getDeviceHalfFP(SEXP sDeviceID){ /* 16-bit floating-point */ Rcpp::XPtr<cl_device_id> deviceID(sDeviceID); Rcpp::List result; #ifdef CL_DEVICE_HALF_FP_CONFIG cl_device_fp_config fpc = 0; if ( CL_SUCCESS == clGetDeviceInfo(*deviceID,CL_DEVICE_HALF_FP_CONFIG, sizeof(cl_device_fp_config), &fpc, NULL) ) { result = getDeviceFPConfigAsList(fpc); } #endif return Rcpp::wrap(result); }
SEXP getDeviceInfo(SEXP sDeviceID){ resetError("ROpenCL::getDeviceInfo"); static char cBuffer[1024]; Rcpp::XPtr<cl_device_id> deviceID(sDeviceID); std::string str; cl_uint uival; cl_ulong ulval; size_t sval; Rcpp::List result; #ifdef CL_DEVICE_TYPE cl_device_type dt = 0; logError( clGetDeviceInfo(*deviceID,CL_DEVICE_TYPE, sizeof(cl_device_type), &dt, NULL) ); str = "UNKNOWN"; # ifdef CL_DEVICE_TYPE_DEFAULT if (dt & CL_DEVICE_TYPE_DEFAULT) str = "CL_DEVICE_TYPE_DEFAULT"; # endif # ifdef CL_DEVICE_TYPE_CPU if (dt & CL_DEVICE_TYPE_CPU) str = "CL_DEVICE_TYPE_CPU"; # endif # ifdef CL_DEVICE_TYPE_GPU if (dt & CL_DEVICE_TYPE_GPU) str = "CL_DEVICE_TYPE_GPU"; # endif # ifdef CL_DEVICE_TYPE_ACCELERATOR if (dt & CL_DEVICE_TYPE_ACCELERATOR) str = "CL_DEVICE_TYPE_ACCELERATOR"; # endif # ifdef CL_DEVICE_TYPE_CUSTOM if (dt & CL_DEVICE_TYPE_CUSTOM) str = "CL_DEVICE_TYPE_CUSTOM"; # endif result["CL_DEVICE_TYPE"] = Rcpp::wrap(str); #endif #ifdef CL_DEVICE_VENDOR_ID uival = 0; logError( clGetDeviceInfo(*deviceID, CL_DEVICE_VENDOR_ID, sizeof(uival), &uival, NULL) ); result["CL_DEVICE_VENDOR_ID"] = Rcpp::wrap(uival); #endif #ifdef CL_DEVICE_MAX_COMPUTE_UNITS uival = 0; logError( clGetDeviceInfo(*deviceID, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof(uival), &uival, NULL) ); result["CL_DEVICE_MAX_COMPUTE_UNITS"] = Rcpp::wrap(uival); #endif #ifdef CL_DEVICE_MAX_WORK_GROUP_SIZE sval = 0; logError( clGetDeviceInfo(*deviceID, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof(sval), &sval, NULL) ); result["CL_DEVICE_MAX_WORK_GROUP_SIZE"] = Rcpp::wrap(sval); #endif #ifdef CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS uival = 0; logError( clGetDeviceInfo(*deviceID, CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, sizeof(uival), &uival, NULL) ); result["CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS"] = Rcpp::wrap(uival); size_t *sizes = (size_t *) malloc(sizeof(size_t) * uival); # ifdef CL_DEVICE_MAX_WORK_ITEM_SIZES logError( clGetDeviceInfo(*deviceID, CL_DEVICE_MAX_WORK_ITEM_SIZES, sizeof(size_t) * uival, sizes, NULL) ); Rcpp::List wis; for (int i = 0; i < uival; i++) { int size = sizes[i]; wis.push_back(Rcpp::wrap(size)); } result["CL_DEVICE_MAX_WORK_ITEM_SIZES"] = Rcpp::wrap(wis); # endif free(sizes); #endif #ifdef CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR uival = 0; logError( clGetDeviceInfo(*deviceID, CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR, sizeof(uival), &uival, NULL) ); result["CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR"] = Rcpp::wrap(uival); #endif #ifdef CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT uival = 0; logError( clGetDeviceInfo(*deviceID, CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT, sizeof(uival), &uival, NULL) ); result["CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT"] = Rcpp::wrap(uival); #endif #ifdef CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT uival = 0; logError( clGetDeviceInfo(*deviceID, CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, sizeof(uival), &uival, NULL) ); result["CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT"] = Rcpp::wrap(uival); #endif #ifdef CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG uival = 0; logError( clGetDeviceInfo(*deviceID, CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG, sizeof(uival), &uival, NULL) ); result["CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG"] = Rcpp::wrap(uival); #endif #ifdef CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT uival = 0; logError( clGetDeviceInfo(*deviceID, CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT, sizeof(uival), &uival, NULL) ); result["CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT"] = Rcpp::wrap(uival); #endif #ifdef CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE uival = 0; logError( clGetDeviceInfo(*deviceID, CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE, sizeof(uival), &uival, NULL) ); result["CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE"] = Rcpp::wrap(uival); #endif #ifdef CL_DEVICE_MAX_CLOCK_FREQUENCY uival = 0; logError( clGetDeviceInfo(*deviceID, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof(uival), &uival, NULL) ); result["CL_DEVICE_MAX_CLOCK_FREQUENCY"] = Rcpp::wrap(uival); #endif #ifdef CL_DEVICE_ADDRESS_BITS #endif #ifdef CL_DEVICE_MAX_READ_IMAGE_ARGS #endif #ifdef CL_DEVICE_MAX_WRITE_IMAGE_ARGS #endif #ifdef CL_DEVICE_MAX_MEM_ALLOC_SIZE ulval = 0; logError( clGetDeviceInfo(*deviceID, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof(ulval), &ulval, NULL) ); result["CL_DEVICE_MAX_MEM_ALLOC_SIZE"] = Rcpp::wrap(ulval); #endif #ifdef CL_DEVICE_IMAGE2D_MAX_WIDTH #endif #ifdef CL_DEVICE_IMAGE2D_MAX_HEIGHT #endif #ifdef CL_DEVICE_IMAGE3D_MAX_WIDTH #endif #ifdef CL_DEVICE_IMAGE3D_MAX_HEIGHT #endif #ifdef CL_DEVICE_IMAGE3D_MAX_DEPTH #endif #ifdef CL_DEVICE_IMAGE_SUPPORT #endif #ifdef CL_DEVICE_MAX_PARAMETER_SIZE #endif #ifdef CL_DEVICE_MEM_BASE_ADDR_ALIGN #endif #ifdef CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE #endif #ifdef CL_DEVICE_SINGLE_FP_CONFIG result["CL_DEVICE_SINGLE_FP_CONFIG"] = getDeviceSingleFP(sDeviceID); #endif #ifdef CL_DEVICE_GLOBAL_MEM_CACHE_TYPE #endif #ifdef CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE #endif #ifdef CL_DEVICE_GLOBAL_MEM_CACHE_SIZE ulval = 0; logError( clGetDeviceInfo(*deviceID, CL_DEVICE_GLOBAL_MEM_CACHE_SIZE, sizeof(ulval), &ulval, NULL) ); result["CL_DEVICE_GLOBAL_MEM_CACHE_SIZE"] = Rcpp::wrap(ulval); #endif #ifdef CL_DEVICE_GLOBAL_MEM_SIZE ulval = 0; logError( clGetDeviceInfo(*deviceID, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof(ulval), &ulval, NULL) ); result["CL_DEVICE_GLOBAL_MEM_SIZE"] = Rcpp::wrap(ulval); #endif #ifdef CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE ulval = 0; logError( clGetDeviceInfo(*deviceID, CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE, sizeof(ulval), &ulval, NULL) ); result["CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE"] = Rcpp::wrap(ulval); #endif #ifdef CL_DEVICE_MAX_CONSTANT_ARGS #endif #ifdef CL_DEVICE_LOCAL_MEM_TYPE #endif #ifdef CL_DEVICE_LOCAL_MEM_SIZE ulval = 0; logError( clGetDeviceInfo(*deviceID, CL_DEVICE_LOCAL_MEM_SIZE, sizeof(ulval), &ulval, NULL) ); result["CL_DEVICE_LOCAL_MEM_SIZE"] = Rcpp::wrap(ulval); #endif #ifdef CL_DEVICE_ERROR_CORRECTION_SUPPORT #endif #ifdef CL_DEVICE_PROFILING_TIMER_RESOLUTION #endif #ifdef CL_DEVICE_ENDIAN_LITTLE #endif #ifdef CL_DEVICE_AVAILABLE #endif #ifdef CL_DEVICE_COMPILER_AVAILABLE #endif #ifdef CL_DEVICE_EXECUTION_CAPABILITIES #endif #ifdef CL_DEVICE_QUEUE_PROPERTIES #endif #ifdef CL_DEVICE_ERROR_CORRECTION_SUPPORT #endif #ifdef CL_DEVICE_NAME cBuffer[0] = '\0'; logError( clGetDeviceInfo (*deviceID, CL_DEVICE_NAME, sizeof(cBuffer), cBuffer, NULL) ); str = cBuffer; result["CL_DEVICE_NAME"] = Rcpp::wrap(str); #endif #ifdef CL_DEVICE_VENDOR cBuffer[0] = '\0'; logError( clGetDeviceInfo(*deviceID, CL_DEVICE_VENDOR, sizeof(cBuffer), cBuffer, NULL) ); str = cBuffer; result["CL_DEVICE_VENDOR"] = Rcpp::wrap(str); #endif #ifdef CL_DRIVER_VERSION cBuffer[0] = '\0'; logError( clGetDeviceInfo(*deviceID, CL_DRIVER_VERSION, sizeof(cBuffer), cBuffer, NULL) ); str = cBuffer; result["CL_DRIVER_VERSION"] = Rcpp::wrap(str); #endif #ifdef CL_DEVICE_PROFILE #endif #ifdef CL_DEVICE_VERSION cBuffer[0] = '\0'; logError( clGetDeviceInfo(*deviceID, CL_DEVICE_VERSION, sizeof(cBuffer), cBuffer, NULL) ); str = cBuffer; result["CL_DEVICE_VERSION"] = Rcpp::wrap(str); #endif #ifdef CL_DEVICE_EXTENSIONS cBuffer[0] = '\0'; logError( clGetDeviceInfo(*deviceID, CL_DEVICE_EXTENSIONS, sizeof(cBuffer), cBuffer, NULL) ); str = cBuffer; std::string word; std::stringstream ss(str); // Insert the string into a stream Rcpp::List extensions; while (ss >> word) { // Fetch next word from stream extensions.push_back(Rcpp::wrap(word)); } result["CL_DEVICE_EXTENSIONS"] = Rcpp::wrap(extensions); #endif #ifdef CL_DEVICE_PLATFORM #endif #ifdef CL_DEVICE_DOUBLE_FP_CONFIG result["CL_DEVICE_DOUBLE_FP_CONFIG"] = getDeviceDoubleFP(sDeviceID); #endif #ifdef CL_DEVICE_HALF_FP_CONFIG result["CL_DEVICE_HALF_FP_CONFIG"] = getDeviceHalfFP(sDeviceID); #endif #ifdef CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF uival = 0; logError( clGetDeviceInfo(*deviceID, CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF, sizeof(uival), &uival, NULL) ); result["CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF"] = Rcpp::wrap(uival); #endif #ifdef CL_DEVICE_HOST_UNIFIED_MEMORY #endif #ifdef CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR uival = 0; logError( clGetDeviceInfo(*deviceID, CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR, sizeof(uival), &uival, NULL) ); result["CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR"] = Rcpp::wrap(uival); #endif #ifdef CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT uival = 0; logError( clGetDeviceInfo(*deviceID, CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT, sizeof(uival), &uival, NULL) ); result["CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT"] = Rcpp::wrap(uival); #endif #ifdef CL_DEVICE_NATIVE_VECTOR_WIDTH_INT uival = 0; logError( clGetDeviceInfo(*deviceID, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof(uival), &uival, NULL) ); result["CL_DEVICE_NATIVE_VECTOR_WIDTH_INT"] = Rcpp::wrap(uival); #endif #ifdef CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG uival = 0; logError( clGetDeviceInfo(*deviceID, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof(uival), &uival, NULL) ); result["CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG"] = Rcpp::wrap(uival); #endif #ifdef CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT uival = 0; logError( clGetDeviceInfo(*deviceID, CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT, sizeof(uival), &uival, NULL) ); result["CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT"] = Rcpp::wrap(uival); #endif #ifdef CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE uival = 0; logError( clGetDeviceInfo(*deviceID, CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE, sizeof(uival), &uival, NULL) ); result["CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE"] = Rcpp::wrap(uival); #endif #ifdef CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF uival = 0; logError( clGetDeviceInfo(*deviceID, CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF, sizeof(uival), &uival, NULL) ); result["CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF"] = Rcpp::wrap(uival); #endif #ifdef CL_DEVICE_OPENCL_C_VERSION #endif #ifdef CL_DEVICE_LINKER_AVAILABLE #endif #ifdef CL_DEVICE_BUILT_IN_KERNELS #endif #ifdef CL_DEVICE_IMAGE_MAX_BUFFER_SIZE #endif #ifdef CL_DEVICE_IMAGE_MAX_ARRAY_SIZE #endif #ifdef CL_DEVICE_PARENT_DEVICE #endif #ifdef CL_DEVICE_PARTITION_MAX_SUB_DEVICES #endif #ifdef CL_DEVICE_PARTITION_PROPERTIES #endif #ifdef CL_DEVICE_PARTITION_AFFINITY_DOMAIN #endif #ifdef CL_DEVICE_PARTITION_TYPE #endif #ifdef CL_DEVICE_REFERENCE_COUNT #endif #ifdef CL_DEVICE_PREFERRED_INTEROP_USER_SYNC #endif #ifdef CL_DEVICE_PRINTF_BUFFER_SIZE #endif #ifdef CL_DEVICE_IMAGE_PITCH_ALIGNMENT #endif #ifdef CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT #endif PRINTONERROR(); return result; }
void OSGLContext_x11::getGPUInfos(std::list<OpenGLRendererInfo>& renderers) { const OSGLContext_glx_data* glxInfo = appPTR->getGLXData(); assert(glxInfo); if (!glxInfo->_imp->MESA_query_renderer) { boost::scoped_ptr<OSGLContext_x11> context; try { context.reset( new OSGLContext_x11(FramebufferConfig(), GLVersion.major, GLVersion.minor, false, GLRendererID(), 0) ); } catch (const std::exception& e) { std::cerr << e.what() << std::endl; return; } if ( !makeContextCurrent( context.get() ) ) { return; } try { OSGLContext::checkOpenGLVersion(); } catch (const std::exception& e) { std::cerr << e.what() << std::endl; return; } OpenGLRendererInfo info; info.vendorName = std::string( (const char *) glGetString(GL_VENDOR) ); info.rendererName = std::string( (const char *) glGetString(GL_RENDERER) ); info.glVersionString = std::string( (const char *) glGetString(GL_VERSION) ); glGetIntegerv(GL_MAX_TEXTURE_SIZE, &info.maxTextureSize); // We don't have any way to get memory size, set it to 0 info.maxMemBytes = 0; info.rendererID.renderID = -1; renderers.push_back(info); } else { // Just use the first screen const int screen = 0; // The function QueryRendererIntegerMESA can return at most 3 values: https://www.opengl.org/registry/specs/MESA/glx_query_renderer.txt unsigned int v[3]; int renderer = 0; bool gotRenderer; do { gotRenderer = (bool)glxInfo->_imp->QueryRendererIntegerMESA(glxInfo->_imp->x11.display, screen, renderer, GLX_RENDERER_DEVICE_ID_MESA, v); if (gotRenderer) { int rendererID = v[0]; if ( (unsigned int)rendererID == 0xFFFFFFFF ) { gotRenderer = false; } else { bool ok = glxInfo->_imp->QueryRendererIntegerMESA(glxInfo->_imp->x11.display, screen, renderer, GLX_RENDERER_ACCELERATED_MESA, v); assert(ok); if (!ok || !v[0]) { ++renderer; continue; } ok = glxInfo->_imp->QueryRendererIntegerMESA(glxInfo->_imp->x11.display, screen, renderer, GLX_RENDERER_OPENGL_COMPATIBILITY_PROFILE_VERSION_MESA, v); assert(ok); if (!ok) { ++renderer; continue; } int maxCompatGLVersionMajor = (int)v[0]; int maxCompatGLVersionMinor = (int)v[1]; ok = glxInfo->_imp->QueryRendererIntegerMESA(glxInfo->_imp->x11.display, screen, renderer, GLX_RENDERER_OPENGL_CORE_PROFILE_VERSION_MESA, v); assert(ok); if (!ok) { ++renderer; continue; } int maxCoreGLVersionMajor = (int)v[0]; int maxCoreGLVersionMinor = (int)v[1]; const char* vendorIDStr = glxInfo->_imp->QueryRendererStringMesa(glxInfo->_imp->x11.display, screen, renderer, GLX_RENDERER_VENDOR_ID_MESA); if (!vendorIDStr) { ++renderer; continue; } const char* deviceIDStr = glxInfo->_imp->QueryRendererStringMesa(glxInfo->_imp->x11.display, screen, renderer, GLX_RENDERER_DEVICE_ID_MESA); if (!deviceIDStr) { ++renderer; continue; } std::string vendorID(vendorIDStr); std::string deviceID(deviceIDStr); std::stringstream ss; ss << "Creating context for Device:" << deviceID << ", Vendor:" << vendorID << std::endl; ss << "Max Compatibility OpenGL profile version: " << maxCompatGLVersionMajor << "." << maxCompatGLVersionMinor << std::endl; ss << "Max Core OpenGL profile version: " << maxCoreGLVersionMajor << "." << maxCoreGLVersionMinor; #ifdef DEBUG std::cerr << ss.str() << std::endl; #endif OpenGLRendererInfo info; ok = glxInfo->_imp->QueryRendererIntegerMESA(glxInfo->_imp->x11.display, screen, renderer, GLX_RENDERER_VIDEO_MEMORY_MESA, v); assert(ok); info.maxMemBytes = v[0] * 1e6; // Now create a context with the renderer ID boost::scoped_ptr<OSGLContext_x11> context; try { context.reset( new OSGLContext_x11(FramebufferConfig(), GLVersion.major, GLVersion.minor, false, GLRendererID( (int)renderer ), 0) ); } catch (const std::exception& e) { #ifndef DEBUG std::cerr << ss.str() << std::endl; #endif std::cerr << e.what() << std::endl; ++renderer; continue; } if ( !makeContextCurrent( context.get() ) ) { ++renderer; continue; } try { OSGLContext::checkOpenGLVersion(); } catch (const std::exception& e) { #ifndef DEBUG std::cerr << ss.str() << std::endl; #endif std::cerr << e.what() << std::endl; ++renderer; continue; } info.rendererID.renderID = renderer; info.vendorName = std::string( (const char *) glGetString(GL_VENDOR) ); info.rendererName = std::string( (const char *) glGetString(GL_RENDERER) ); info.glVersionString = std::string( (const char *) glGetString(GL_VERSION) ); glGetIntegerv(GL_MAX_TEXTURE_SIZE, &info.maxTextureSize); renderers.push_back(info); makeContextCurrent(0); } } ++renderer; } while (gotRenderer); } } // OSGLContext_x11::getGPUInfos