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
