Workaround for Intel Port: Updated the code with opencl version.

Author: Chaitanya Sri Krishna Lolla

openvx/ago/ago_drama_alloc.cpp

@@ -84,7 +84,11 @@ static int agoOptimizeDramaAllocGpuResources(AgoGraph * graph)
 			// create command queue: for now use device#0 -- TBD: this needs to be changed in future
 			cl_int err = -1;
 			graph->opencl_device = context->opencl_device_list[0];
+#if defined(CL_VERSION_2_0)
 			graph->opencl_cmdq = clCreateCommandQueueWithProperties(context->opencl_context, graph->opencl_device, NULL, &err);
+#else
+			graph->opencl_cmdq = clCreateCommandQueue(context->opencl_context, graph->opencl_device, 0, &err);
+#endif
 			if (err) {
 				agoAddLogEntry(&graph->ref, VX_FAILURE, "ERROR: clCreateCommandQueueWithProperties(%p,%p,0,*) => %d\n", context->opencl_context, graph->opencl_device, err);
 				return -1;

openvx/ago/ago_internal.h

@@ -144,11 +144,13 @@ THE SOFTWARE.
 #define DATA_OPENCL_ARRAY_OFFSET             16  // first 16 bytes of array buffer will be used for numitems
 // opencl configuration flags
 #define CONFIG_OPENCL_USE_1_2              0x0001  // use OpenCL 1.2
+#if defined(CL_VERSION_2_0)
 #define CONFIG_OPENCL_SVM_MASK             0x00F0  // OpenCL SVM flags mask
 #define CONFIG_OPENCL_SVM_ENABLE           0x0010  // use OpenCL SVM
 #define CONFIG_OPENCL_SVM_AS_FGS           0x0020  // use OpenCL SVM as fine grain system
 #define CONFIG_OPENCL_SVM_AS_CLMEM         0x0040  // use OpenCL SVM as cl_mem
 #endif
+#endif
 // opencl image fixed byte offset
 #define OPENCL_IMAGE_FIXED_OFFSET             256
 
@@ -393,9 +395,11 @@ struct AgoData {
 #if ENABLE_OPENCL
 	cl_mem     opencl_buffer;
 	cl_mem     opencl_buffer_allocated;
-#endif
+#if defined(CL_VERSION_2_0)
 	vx_uint8 * opencl_svm_buffer;
 	vx_uint8 * opencl_svm_buffer_allocated;
+#endif
+#endif
 	vx_uint32  opencl_buffer_offset;
 	vx_bool isVirtual;
 	vx_bool isDelayed;
@@ -669,7 +673,9 @@ struct AgoContext {
 	cl_command_queue opencl_cmdq;
 	vx_uint32 opencl_config_flags;
 	char opencl_extensions[1024];
+#if defined(CL_VERSION_2_0)
 	cl_device_svm_capabilities opencl_svmcaps;
+#endif
 	cl_uint      opencl_num_devices;
 	cl_device_id opencl_device_list[16];
 	char opencl_build_options[256];

openvx/ago/ago_util.cpp

@@ -1502,7 +1502,7 @@ int agoGetDataFromDescription(AgoContext * acontext, AgoGraph * agraph, AgoData
 		}
 		else if (data->u.scalar.type == VX_TYPE_FLOAT16) {
 			data->u.scalar.itemsize = sizeof(vx_uint16);
-			if (sscanf(s, "%g", &data->u.scalar.u.u) == 1)
+			if (sscanf(s, "%d", &data->u.scalar.u.u) == 1)
 				data->isInitialized = vx_true_e;
 		}
 		else if (data->u.scalar.type == VX_TYPE_BOOL) {
@@ -2907,8 +2907,11 @@ AgoData::AgoData()
 	  buffer{ nullptr }, buffer_allocated{ nullptr }, reserved{ nullptr }, reserved_allocated{ nullptr }, buffer_sync_flags{ 0 }, 
 #if ENABLE_OPENCL
 	  opencl_buffer{ nullptr }, opencl_buffer_allocated{ nullptr },
+#if defined(CL_VERSION_2_0)
+	  opencl_svm_buffer{ nullptr }, opencl_svm_buffer_allocated{ nullptr },
 #endif
-	  opencl_svm_buffer{ nullptr }, opencl_svm_buffer_allocated{ nullptr }, opencl_buffer_offset{ 0 },
+#endif
+	  opencl_buffer_offset{ 0 },
 	  isVirtual{ vx_false_e }, isDelayed{ vx_false_e }, isNotFullyConfigured{ vx_false_e }, isInitialized{ vx_false_e }, siblingIndex{ 0 },
 	  numChildren{ 0 }, children{ nullptr }, parent{ nullptr }, inputUsageCount{ 0 }, outputUsageCount{ 0 }, inoutUsageCount{ 0 },
 	  nextMapId{ 0 }, hierarchical_level{ 0 }, hierarchical_life_start{ 0 }, hierarchical_life_end{ 0 }, ownerOfUserBufferOpenCL{ nullptr }
@@ -3069,7 +3072,10 @@ AgoContext::AgoContext()
 	  num_active_modules{ 0 }, num_active_references{ 0 }, callback_log{ nullptr }, callback_reentrant{ vx_false_e },
 	  thread_config{ CONFIG_THREAD_DEFAULT }, importing_module_index_plus1{ 0 }, graph_garbage_data{ nullptr }, graph_garbage_node{ nullptr }, graph_garbage_list{ nullptr }
 #if ENABLE_OPENCL
-	, opencl_context_imported{ false }, opencl_context{ nullptr }, opencl_cmdq{ nullptr }, opencl_config_flags{ 0 }, opencl_svmcaps{ 0 }, opencl_num_devices{ 0 }, isAmdMediaOpsSupported{ true }
+#if defined(CL_VERSION_2_0)
+	  , opencl_svmcaps{ 0 }
+#endif
+	  , opencl_context_imported{ false }, opencl_context{ nullptr }, opencl_cmdq{ nullptr }, opencl_config_flags{ 0 }, opencl_num_devices{ 0 }, isAmdMediaOpsSupported{ true }
 #endif
 {
 	memset(&kernelList, 0, sizeof(kernelList));

openvx/ago/ago_util_opencl.cpp

@@ -115,6 +115,7 @@ int agoGpuOclReleaseData(AgoData * data)
 		clReleaseMemObject(data->opencl_buffer_allocated);
 		data->opencl_buffer_allocated = NULL;
 	}
+#if defined(CL_VERSION_2_0)
 	if (data->opencl_svm_buffer_allocated) {
 		if (data->ref.context->opencl_config_flags & CONFIG_OPENCL_SVM_AS_FGS) {
 			agoReleaseMemory(data->opencl_svm_buffer_allocated);
@@ -124,8 +125,9 @@ int agoGpuOclReleaseData(AgoData * data)
 		}
 		data->opencl_svm_buffer_allocated = NULL;
 	}
-	data->opencl_buffer = NULL;
 	data->opencl_svm_buffer = NULL;
+#endif
+	data->opencl_buffer = NULL;
 	data->opencl_buffer_offset = 0;
 	return 0;
 }
@@ -151,17 +153,26 @@ int agoGpuOclCreateContext(AgoContext * context, cl_context opencl_context)
 			agoAddLogEntry(NULL, VX_FAILURE, "ERROR: clGetPlatformIDs(%d,*,0) => %d (failed)\n", num_platforms, status);
 			return -1;
 		}
-		cl_platform_id platform_id = platform_list[0];
-		for (int i = 0; i < (int)num_platforms; i++) {
-			char vendor[128] = { 0 };
-			if ((status = clGetPlatformInfo(platform_list[i], CL_PLATFORM_VENDOR, sizeof(vendor), vendor, NULL)) != CL_SUCCESS) {
-				agoAddLogEntry(NULL, VX_FAILURE, "ERROR: clGetPlatformInfo([%d],...) => %d (failed)\n", i, status);
-				return -1;
+		cl_platform_id platform_id = nullptr;
+		char opencl_platform_override[64] = "";
+		if (agoGetEnvironmentVariable("AGO_OPENCL_PLATFORM", opencl_platform_override, sizeof(opencl_platform_override))) {
+			cl_uint index = (cl_uint)atoi(opencl_platform_override);
+			if (index < num_platforms) {
+				platform_id = platform_list[index];
 			}
-			if (!strcmp(vendor, "Advanced Micro Devices, Inc.")) {
-				platform_id = platform_list[i];
-				context->isVendorAmd = true;
-				break;
+		}
+		if (!platform_id) {
+			platform_id = platform_list[0];
+			for (int i = 0; i < (int)num_platforms; i++) {
+				char vendor[128] = { 0 };
+				if ((status = clGetPlatformInfo(platform_list[i], CL_PLATFORM_VENDOR, sizeof(vendor), vendor, NULL)) != CL_SUCCESS) {
+					agoAddLogEntry(NULL, VX_FAILURE, "ERROR: clGetPlatformInfo([%d],...) => %d (failed)\n", i, status);
+					return -1;
+				}
+				if (!strcmp(vendor, "Advanced Micro Devices, Inc.")) {
+					platform_id = platform_list[i];
+					break;
+				}
 			}
 		}
 		delete [] platform_list;
@@ -221,19 +232,25 @@ int agoGpuOclCreateContext(AgoContext * context, cl_context opencl_context)
 		return -1;
 	}
 	context->isAmdMediaOpsSupported = strstr(extensions, "cl_amd_media_ops") ? true : false;
+#if defined(CL_VERSION_2_0)
 	agoAddLogEntry(&context->ref, VX_SUCCESS, "OK: OpenVX using GPU device#%d (%s) [%s] [SvmCaps " VX_FMT_SIZE " %d]\n", device_id, deviceName, deviceVersion, context->opencl_svmcaps, context->opencl_config_flags);
+#else
+	agoAddLogEntry(&context->ref, VX_SUCCESS, "OK: OpenVX using GPU device#%d (%s) [%s] [%d]\n", device_id, deviceName, deviceVersion, context->opencl_config_flags);
+#endif
 	memset(context->opencl_extensions, 0, sizeof(context->opencl_extensions));
 	status = clGetDeviceInfo(context->opencl_device_list[device_id], CL_DEVICE_EXTENSIONS, sizeof(context->opencl_extensions), context->opencl_extensions, NULL);
 	if (status) { 
 		agoAddLogEntry(&context->ref, VX_FAILURE, "ERROR: clGetDeviceInfo(%p,CL_DEVICE_EXTENSIONS) => %d\n", context->opencl_device_list[device_id], status);
 		return -1; 
 	}
+#if defined(CL_VERSION_2_0)
 	context->opencl_svmcaps = 0;
 	status = clGetDeviceInfo(context->opencl_device_list[device_id], CL_DEVICE_SVM_CAPABILITIES, sizeof(context->opencl_svmcaps), &context->opencl_svmcaps, NULL);
 	if (status) { 
 		agoAddLogEntry(&context->ref, VX_FAILURE, "ERROR: clGetDeviceInfo(%p,CL_DEVICE_SVM_CAPABILITIES) => %d\n", context->opencl_device_list[device_id], status);
 		return -1; 
 	}
+#endif
 	// get default OpenCL build options
 	strcpy(context->opencl_build_options, (context->opencl_config_flags & CONFIG_OPENCL_USE_1_2) ? "-cl-std=CL1.2" : "-cl-std=CL2.0");
 	// override build options with environment variable
@@ -246,6 +263,7 @@ int agoGpuOclCreateContext(AgoContext * context, cl_context opencl_context)
 	}
 
 	// decide SVM features
+#if defined(CL_VERSION_2_0)
 	if (context->opencl_svmcaps & (CL_DEVICE_SVM_FINE_GRAIN_BUFFER | CL_DEVICE_SVM_FINE_GRAIN_SYSTEM)) {
 		context->opencl_config_flags &= ~CONFIG_OPENCL_SVM_MASK;
 		if (context->attr_affinity.device_info & AGO_TARGET_AFFINITY_GPU_INFO_SVM_MASK) {
@@ -272,8 +290,13 @@ int agoGpuOclCreateContext(AgoContext * context, cl_context opencl_context)
 			}
 		}
 	}
+#endif
 	// create command queue for buffer sync
+#if defined(CL_VERSION_2_0)
 	context->opencl_cmdq = clCreateCommandQueueWithProperties(context->opencl_context, context->opencl_device_list[device_id], NULL, &status);
+#else
+	context->opencl_cmdq = clCreateCommandQueue(context->opencl_context, context->opencl_device_list[device_id], 0, &status);
+#endif
 	if (status) {
 		agoAddLogEntry(&context->ref, VX_FAILURE, "ERROR: clCreateCommandQueueWithProperties(%p,%p,0,*) => %d\n", context->opencl_context, context->opencl_device_list[device_id], status);
 		return -1;
@@ -294,6 +317,7 @@ int agoGpuOclAllocBuffer(AgoData * data)
 		AgoData * dataMaster = data->u.img.roiMasterImage ? data->u.img.roiMasterImage : data; // to handle image ROI
 		if (!dataMaster->opencl_buffer && !dataMaster->u.img.enableUserBufferOpenCL && !(dataMaster->import_type == VX_MEMORY_TYPE_OPENCL)) {
 			cl_int err = CL_SUCCESS;
+#if defined(CL_VERSION_2_0)
 			if (!dataMaster->buffer && !dataMaster->u.img.isUniform) {
 				if (context->opencl_config_flags & CONFIG_OPENCL_SVM_ENABLE) {
 					if (context->opencl_config_flags & CONFIG_OPENCL_SVM_AS_FGS) {
@@ -322,7 +346,9 @@ int agoGpuOclAllocBuffer(AgoData * data)
 					dataMaster->opencl_buffer = dataMaster->opencl_buffer_allocated = clCreateBuffer(context->opencl_context, CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR, dataMaster->size + dataMaster->opencl_buffer_offset, dataMaster->opencl_svm_buffer_allocated, &err);
 				}
 			}
-			else {
+			else
+#endif
+			{
 				// allocate normal opencl_buffer
 				dataMaster->opencl_buffer = dataMaster->opencl_buffer_allocated = clCreateBuffer(context->opencl_context, CL_MEM_READ_WRITE, dataMaster->size + dataMaster->opencl_buffer_offset, NULL, &err);
 			}
@@ -349,13 +375,16 @@ int agoGpuOclAllocBuffer(AgoData * data)
 		if (data != dataMaster) {
 			// special handling for image ROI
 			data->opencl_buffer = dataMaster->opencl_buffer;
+#if defined(CL_VERSION_2_0)
 			data->opencl_svm_buffer = dataMaster->opencl_svm_buffer;
+#endif
 		}
 	}
 	else if (data->ref.type == VX_TYPE_ARRAY || data->ref.type == AGO_TYPE_CANNY_STACK) {
 		if (!data->opencl_buffer) {
 			data->opencl_buffer_offset = DATA_OPENCL_ARRAY_OFFSET; // first few bytes reserved for numitems/stacktop
 			cl_int err = CL_SUCCESS;
+#if defined(CL_VERSION_2_0)
 			if (!data->buffer) {
 				if (context->opencl_config_flags & CONFIG_OPENCL_SVM_ENABLE) {
 					if (context->opencl_config_flags & CONFIG_OPENCL_SVM_AS_FGS) {
@@ -387,7 +416,9 @@ int agoGpuOclAllocBuffer(AgoData * data)
 					data->opencl_buffer = data->opencl_buffer_allocated = clCreateBuffer(context->opencl_context, CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR, data->size + data->opencl_buffer_offset, data->opencl_svm_buffer_allocated, &err);
 				}
 			}
-			else {
+			else
+#endif
+			{
 				// normal opencl_buffer allocation
 				data->opencl_buffer = data->opencl_buffer_allocated = clCreateBuffer(context->opencl_context, CL_MEM_READ_WRITE, data->size + data->opencl_buffer_offset, NULL, &err);
 				if (data->opencl_buffer) {
@@ -468,7 +499,9 @@ int agoGpuOclAllocBuffer(AgoData * data)
 		if (data != dataMaster) {
 			// special handling for tensor ROI
 			data->opencl_buffer = dataMaster->opencl_buffer;
+#if defined(CL_VERSION_2_0)
 			data->opencl_svm_buffer = dataMaster->opencl_svm_buffer;
+#endif
 			data->opencl_buffer_offset = (vx_uint32)data->u.tensor.offset;
 		}
 	}
@@ -571,13 +604,15 @@ int agoGpuOclDataSetBufferAsKernelArg(AgoData * data, cl_kernel opencl_kernel, v
 			return -1;
 		}
 	}
+#if defined(CL_VERSION_2_0)
 	else if (data->opencl_svm_buffer) {
 		cl_int err = clSetKernelArgSVMPointer(opencl_kernel, (cl_uint)kernelArgIndex, data->opencl_svm_buffer);
 		if (err) {
 			agoAddLogEntry(&data->ref, VX_FAILURE, "ERROR: clSetKernelArgSVMPointer(supernode,%d,*,buffer) failed(%d) for group#%d\n", (cl_uint)kernelArgIndex, err, group);
 			return -1;
 		}
 	}
+#endif
 	else if (data->import_type != VX_MEMORY_TYPE_OPENCL && !(data->ref.type == VX_TYPE_IMAGE && data->u.img.enableUserBufferOpenCL)) {
 		agoAddLogEntry(&data->ref, VX_FAILURE, "ERROR: agoGpuOclDataSetBufferAsKernelArg(supernode,%d) OpenCL buffer not allocated for group#%d\n", (cl_uint)kernelArgIndex, group);
 		return -1;
@@ -1115,7 +1150,11 @@ static int agoGpuOclDataOutputAtomicSync(AgoGraph * graph, AgoData * data)
 		// update number of items
 		cl_int err = CL_SUCCESS;
 		int64_t stime = agoGetClockCounter();
+#if defined(CL_VERSION_2_0)
 		vx_uint32 * pNumItems = (vx_uint32 *)data->opencl_svm_buffer;
+#else
+		vx_uint32 * pNumItems = nullptr;
+#endif
 		if (data->opencl_buffer) {
 			pNumItems = (vx_uint32 *)clEnqueueMapBuffer(opencl_cmdq, data->opencl_buffer, CL_TRUE, CL_MAP_READ | CL_MAP_WRITE, 0, sizeof(vx_uint32), 0, NULL, NULL, &err);
 			if (err) { 
@@ -1144,7 +1183,11 @@ static int agoGpuOclDataOutputAtomicSync(AgoGraph * graph, AgoData * data)
 		// update number of items and reset it for next use
 		int64_t stime = agoGetClockCounter();
 		cl_int err = CL_SUCCESS;
+#if defined(CL_VERSION_2_0)
 		vx_uint8 * stack = data->opencl_svm_buffer;
+#else
+		vx_uint8 * stack = nullptr;
+#endif
 		if (data->opencl_buffer) {
 			stack = (vx_uint8 *)clEnqueueMapBuffer(opencl_cmdq, data->opencl_buffer, CL_TRUE, CL_MAP_READ | CL_MAP_WRITE, 0, sizeof(vx_uint32), 0, NULL, NULL, &err);
 			if (err) { 

openvx/api/vx_api.cpp

@@ -1020,7 +1020,11 @@ VX_API_ENTRY vx_status VX_API_CALL vxQueryImage(vx_image image_, vx_enum attribu
 						*(cl_mem *)ptr = image->opencl_buffer;
 					}
 					else {
+#if defined(CL_VERSION_2_0)
 						*(vx_uint8 **)ptr = image->opencl_svm_buffer;
+#else
+						*(vx_uint8 **)ptr = NULL;
+#endif
 					}
 					status = VX_SUCCESS;
 				}