Merge pull request #18 from lcskrishna/non-amd-openclport

Added support for OpenCL 1.2 build

Author: rgiduthuri

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

@@ -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;
 }
@@ -229,19 +231,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
@@ -254,6 +262,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) {
@@ -280,8 +289,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;
@@ -302,6 +316,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) {
@@ -330,7 +345,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);
 			}
@@ -357,13 +374,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) {
@@ -395,7 +415,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) {
@@ -476,7 +498,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;
 		}
 	}
@@ -579,13 +603,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;
@@ -1123,7 +1149,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) { 
@@ -1152,7 +1182,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;
 				}