[Bf-blender-cvs] SVN commit: /data/svn/bf-blender [31912] branches/particles-2010/source/ blender/nodes/intern/simulation: Made single implementations of opencl and fallback in the same function, with opencl ifdef'ed out.

Lukas Toenne lukas.toenne at googlemail.com
Mon Sep 13 15:17:43 CEST 2010


Revision: 31912
          http://projects.blender.org/plugins/scmsvn/viewcvs.php?view=rev&root=bf-blender&revision=31912
Author:   lukastoenne
Date:     2010-09-13 15:17:43 +0200 (Mon, 13 Sep 2010)

Log Message:
-----------
Made single implementations of opencl and fallback in the same function, with opencl ifdef'ed out. This will allow OpenCL builds to also use the fallback implementation, based on wether it is activated or not. Could become a user preference setting.

Modified Paths:
--------------
    branches/particles-2010/source/blender/nodes/intern/simulation/SIM_util.c
    branches/particles-2010/source/blender/nodes/intern/simulation/SIM_util.h

Modified: branches/particles-2010/source/blender/nodes/intern/simulation/SIM_util.c
===================================================================
--- branches/particles-2010/source/blender/nodes/intern/simulation/SIM_util.c	2010-09-13 12:56:39 UTC (rev 31911)
+++ branches/particles-2010/source/blender/nodes/intern/simulation/SIM_util.c	2010-09-13 13:17:43 UTC (rev 31912)
@@ -210,153 +210,346 @@
 		return 1;
 }
 
-#ifdef WITH_OPENCL
 
 int sim_buffer_valid(struct SimBuffer *buffer)
 {
-	cl_mem_object_type buftype;
-	cl_int res= clGetMemObjectInfo(buffer->data, CL_MEM_TYPE, sizeof(cl_mem_object_type), &buftype, NULL);
-	if (res == CL_SUCCESS)
-		return 1;
-	else if (res == CL_INVALID_MEM_OBJECT)
-		return 0;
+#ifdef WITH_OPENCL
+	if (BKE_opencl_is_active()) {
+		cl_mem_object_type buftype;
+		cl_int res= clGetMemObjectInfo(buffer->data_cl, CL_MEM_TYPE, sizeof(cl_mem_object_type), &buftype, NULL);
+		if (res == CL_SUCCESS)
+			return 1;
+		else if (res == CL_INVALID_MEM_OBJECT)
+			return 0;
+		else {
+			printf("Error querying OpenCL buffer info: %s", BKE_opencl_message(res));
+			return 0;
+		}
+	}
 	else {
-		printf("Error querying OpenCL buffer info: %s", BKE_opencl_message(res));
-		return 0;
+#endif
+		return (buffer->data != NULL && buffer->stride > 0);
+#ifdef WITH_OPENCL
 	}
+#endif
 }
 
 SimBuffer sim_create_buffer(SimExecData *execdata, SimBufferMode mode, int datatype, int total)
 {
-	cl_int res;
-	size_t datasize = sim_get_data_size(datatype);
-	SimBuffer buf;
-	buf.datatype = datatype;
-	buf.stride = datasize;
-	
-	if (datasize > 0 && total > 0) {
-		buf.data = clCreateBuffer(execdata->context, mode, total * datasize, NULL, &res);
-		if (res != CL_SUCCESS) {
+#ifdef WITH_OPENCL
+	if (BKE_opencl_is_active()) {
+		cl_int res;
+		size_t datasize = sim_get_data_size(datatype);
+		SimBuffer buf;
+		buf.datatype = datatype;
+		buf.stride = datasize;
+		
+		if (datasize > 0 && total > 0) {
+			buf.data_cl = clCreateBuffer(execdata->context, mode, total * datasize, NULL, &res);
+			if (res != CL_SUCCESS) {
+				execdata->error = 1;
+				sprintf(execdata->error_string, "Error creating OpenCL buffer: %s", BKE_opencl_message(res));
+			}
+		}
+		
+		return buf;
+	}
+	else {
+#endif
+		int datasize = sim_get_data_size(datatype);
+		SimBuffer buf;
+		buf.datatype = datatype;
+		buf.stride = datasize;
+		
+		if (datasize > 0 && total > 0) {
+			buf.data = MEM_callocN(datasize * total, "SimBuffer data");
+		}
+		else {
+			buf.data = NULL;
+			
 			execdata->error = 1;
-			sprintf(execdata->error_string, "Error creating OpenCL buffer: %s", BKE_opencl_message(res));
+			sprintf(execdata->error_string, "Error creating buffer: zero datasize or number of elements.");
 		}
+		
+		return buf;
+#ifdef WITH_OPENCL
 	}
-	
-	return buf;
+#endif
 }
 
 SimBuffer sim_create_buffer_copy(SimExecData *execdata, SimBufferMode mode, int datatype, int total, void *src)
 {
-	cl_int res;
-	size_t datasize = sim_get_data_size(datatype);
-	SimBuffer buf;
-	buf.datatype = datatype;
-	buf.stride = datasize;
-	
-	if (datasize > 0 && total > 0) {
-		buf.data = clCreateBuffer(execdata->context, mode | CL_MEM_COPY_HOST_PTR, total * datasize, src, &res);
-		if (res != CL_SUCCESS) {
+#ifdef WITH_OPENCL
+	if (BKE_opencl_is_active()) {
+		cl_int res;
+		size_t datasize = sim_get_data_size(datatype);
+		SimBuffer buf;
+		buf.datatype = datatype;
+		buf.stride = datasize;
+		
+		if (datasize > 0 && total > 0) {
+			buf.data_cl = clCreateBuffer(execdata->context, mode | CL_MEM_COPY_HOST_PTR, total * datasize, src, &res);
+			if (res != CL_SUCCESS) {
+				execdata->error = 1;
+				sprintf(execdata->error_string, "Error creating OpenCL buffer copy: %s", BKE_opencl_message(res));
+			}
+		}
+		
+		return buf;
+	}
+	else {
+#endif
+		int datasize = sim_get_data_size(datatype);
+		SimBuffer buf;
+		buf.datatype = datatype;
+		buf.stride = datasize;
+		
+		if (datasize > 0 && total > 0) {
+			buf.data = MEM_callocN(datasize * total, "SimBuffer data");
+			
+			memcpy(buf.data, src, datasize * total);
+		}
+		else {
+			buf.data = NULL;
+			
 			execdata->error = 1;
-			sprintf(execdata->error_string, "Error creating OpenCL buffer copy: %s", BKE_opencl_message(res));
+			sprintf(execdata->error_string, "Error creating buffer copy: zero datasize or number of elements.");
 		}
+		
+		return buf;
+#ifdef WITH_OPENCL
 	}
-	
-	return buf;
+#endif
 }
 
 SimBuffer sim_create_host_buffer(SimExecData *execdata, SimBufferMode mode, int datatype, int total)
 {
-	cl_int res;
-	size_t datasize = sim_get_data_size(datatype);
-	SimBuffer buf;
-	buf.datatype = datatype;
-	buf.stride = datasize;
-	
-	if (datasize > 0 && total > 0) {
-		buf.data = clCreateBuffer(execdata->context, mode | CL_MEM_ALLOC_HOST_PTR, total * datasize, NULL, &res);
-		if (res != CL_SUCCESS) {
+#ifdef WITH_OPENCL
+	if (BKE_opencl_is_active()) {
+		cl_int res;
+		size_t datasize = sim_get_data_size(datatype);
+		SimBuffer buf;
+		buf.datatype = datatype;
+		buf.stride = datasize;
+		
+		if (datasize > 0 && total > 0) {
+			buf.data_cl = clCreateBuffer(execdata->context, mode | CL_MEM_ALLOC_HOST_PTR, total * datasize, NULL, &res);
+			if (res != CL_SUCCESS) {
+				execdata->error = 1;
+				sprintf(execdata->error_string, "Error creating OpenCL host buffer: %s", BKE_opencl_message(res));
+			}
+		}
+		
+		return buf;
+	}
+	else {
+#endif
+		int datasize = sim_get_data_size(datatype);
+		SimBuffer buf;
+		buf.datatype = datatype;
+		buf.stride = datasize;
+		
+		if (datasize > 0 && total > 0) {
+			buf.data = MEM_callocN(datasize * total, "SimBuffer data");
+		}
+		else {
+			buf.data = NULL;
+			
 			execdata->error = 1;
-			sprintf(execdata->error_string, "Error creating OpenCL host buffer: %s", BKE_opencl_message(res));
+			sprintf(execdata->error_string, "Error creating host buffer: zero datasize or number of elements.");
 		}
+		
+		return buf;
+#ifdef WITH_OPENCL
 	}
-	
-	return buf;
+#endif
 }
 
 void sim_release_buffer(SimExecData *execdata, SimBuffer *buffer)
 {
-	cl_int res;
-	res = clReleaseMemObject(buffer->data);
-	if (res != CL_SUCCESS) {
-		execdata->error = 1;
-		sprintf(execdata->error_string, "Error releasing OpenCL buffer: %s", BKE_opencl_message(res));
+#ifdef WITH_OPENCL
+	if (BKE_opencl_is_active()) {
+		cl_int res;
+		res = clReleaseMemObject(buffer->data_cl);
+		if (res != CL_SUCCESS) {
+			execdata->error = 1;
+			sprintf(execdata->error_string, "Error releasing OpenCL buffer: %s", BKE_opencl_message(res));
+		}
 	}
+	else {
+#endif
+		if (buffer->data) {
+			MEM_freeN(buffer->data);
+			buffer->data = NULL;
+		}
+#ifdef WITH_OPENCL
+	}
+#endif
 }
 
 void *sim_enqueue_map_buffer(SimExecData *execdata, SimBuffer *buffer, int blocking, SimMapMode mode, int start, int num, int num_wait_events, SimEvent *wait_events, SimEvent *event)
 {
-	cl_int res;
-	void *mapped;
-	
-	mapped = clEnqueueMapBuffer(execdata->queue, buffer->data, (blocking ? CL_TRUE : CL_FALSE), mode,
-								start * buffer->stride, num * buffer->stride, num_wait_events, (num_wait_events==0 ? NULL : wait_events), event, &res);
-	if (res != CL_SUCCESS) {
-		execdata->error = 1;
-		sprintf(execdata->error_string, "Error mapping OpenCL buffer: %s", BKE_opencl_message(res));
+#ifdef WITH_OPENCL
+	if (BKE_opencl_is_active()) {
+		cl_int res;
+		cl_event *wait_events_cl;
+		void *mapped;
+		
+		if (num_wait_events > 0) {
+			int i;
+			wait_events_cl = MEM_callocN(num_wait_events * sizeof(cl_event), "wait_events_cl");
+			for (i=0; i < num_wait_events; ++i)
+				wait_events_cl[i] = wait_events[i].impl_cl;
+		}
+		else
+			wait_events_cl = NULL;
+		mapped = clEnqueueMapBuffer(execdata->queue, buffer->data_cl, (blocking ? CL_TRUE : CL_FALSE), mode,
+									start * buffer->stride, num * buffer->stride,
+									num_wait_events, wait_events_cl, &event->impl_cl, &res);
+		MEM_freeN(wait_events_cl);
+		if (res != CL_SUCCESS) {
+			execdata->error = 1;
+			sprintf(execdata->error_string, "Error mapping OpenCL buffer: %s", BKE_opencl_message(res));
+		}
+		
+		return mapped;
 	}
-	
-	return mapped;
+	else {
+#endif
+		return (char*)buffer->data + start * buffer->stride;
+#ifdef WITH_OPENCL
+	}
+#endif
 }
 
 void sim_enqueue_unmap_buffer(SimExecData *execdata, SimBuffer *buffer, void *ptr, int num_wait_events, SimEvent *wait_events, SimEvent *event)
 {
-	cl_int res;
-	
-	res = clEnqueueUnmapMemObject(execdata->queue, buffer->data, ptr, num_wait_events, (num_wait_events==0 ? NULL : wait_events), event);
-	if (res != CL_SUCCESS) {
-		execdata->error = 1;
-		sprintf(execdata->error_string, "Error unmapping OpenCL buffer: %s", BKE_opencl_message(res));
+#ifdef WITH_OPENCL
+	if (BKE_opencl_is_active()) {
+		cl_int res;
+		cl_event *wait_events_cl;
+		
+		if (num_wait_events > 0) {
+			int i;
+			wait_events_cl = MEM_callocN(num_wait_events * sizeof(cl_event), "wait_events_cl");
+			for (i=0; i < num_wait_events; ++i)
+				wait_events_cl[i] = wait_events[i].impl_cl;
+		}
+		else
+			wait_events_cl = NULL;
+		res = clEnqueueUnmapMemObject(execdata->queue, buffer->data_cl, ptr, num_wait_events, wait_events_cl, &event->impl_cl);
+		MEM_freeN(wait_events_cl);
+		if (res != CL_SUCCESS) {
+			execdata->error = 1;
+			sprintf(execdata->error_string, "Error unmapping OpenCL buffer: %s", BKE_opencl_message(res));
+		}
 	}
+	else {
+#endif
+#ifdef WITH_OPENCL
+	}
+#endif
 }
 
 void sim_enqueue_read_buffer(SimExecData *execdata, SimBuffer *buffer, int blocking, int start, int num, void *dst, int num_wait_events, SimEvent *wait_events, SimEvent *event)
 {
-	cl_int res;
-	
-	res = clEnqueueReadBuffer(execdata->queue, buffer->data, (blocking ? CL_TRUE : CL_FALSE),
-							  start * buffer->stride, num * buffer->stride, dst,
-							  num_wait_events, (num_wait_events==0 ? NULL : wait_events), event);
-	if (res != CL_SUCCESS) {
-		execdata->error = 1;
-		sprintf(execdata->error_string, "Error reading from OpenCL buffer: %s", BKE_opencl_message(res));
+#ifdef WITH_OPENCL
+	if (BKE_opencl_is_active()) {
+		cl_int res;
+		cl_event *wait_events_cl;
+		
+		if (num_wait_events > 0) {
+			int i;
+			wait_events_cl = MEM_callocN(num_wait_events * sizeof(cl_event), "wait_events_cl");
+			for (i=0; i < num_wait_events; ++i)
+				wait_events_cl[i] = wait_events[i].impl_cl;
+		}
+		else
+			wait_events_cl = NULL;
+		res = clEnqueueReadBuffer(execdata->queue, buffer->data_cl, (blocking ? CL_TRUE : CL_FALSE),
+								  start * buffer->stride, num * buffer->stride, dst,
+								  num_wait_events, wait_events_cl, &event->impl_cl);
+		MEM_freeN(wait_events_cl);
+		if (res != CL_SUCCESS) {
+			execdata->error = 1;

@@ Diff output truncated at 10240 characters. @@




More information about the Bf-blender-cvs mailing list