Use TSFN threaded callbacks

Author: raub

index.d.ts

@@ -20,11 +20,11 @@ cl.Wrapper.prototype[inspect.custom] = cl.Wrapper.prototype.toString;
 let cached = null;
 
 const showDevices = (devices, mainDevice) => {
-	console.log(
+	console.info(
 		'AVAILABLE DEVICES:',
 		devices.map(({ name, version }) => `${version} ${name}`),
 	);
-	console.log('ACTIVE DEVICE:', `${mainDevice.version} ${mainDevice.name}`);
+	console.info('ACTIVE DEVICE:', `${mainDevice.version} ${mainDevice.name}`);
 };
 
 cl.quickStart = (isLoggingDevices = false) => {

index.js

@@ -1,3 +1,4 @@
+#include "./wrapper.cpp"
 #include "./queue.cpp"
 #include "./common.cpp"
 #include "./context.cpp"
@@ -8,7 +9,6 @@
 #include "./platform.cpp"
 #include "./program.cpp"
 #include "./sampler.cpp"
-#include "./types.cpp"
 
 
 #define JS_CL_CONSTANT(name)                                                  \

src/cpp/bindings.cpp

@@ -16,8 +16,6 @@ void getPtrAndLen(Napi::Object obj, void** ptr, size_t *len) {
 	}
 }
 
-#define CASE_RET(CODE, MSG) case CODE: return MSG;
-
 const char* getExceptionMessage(const cl_int code) {
 	switch (code) {
 		case CL_SUCCESS:
@@ -143,7 +141,7 @@ const char* getExceptionMessage(const cl_int code) {
 		case CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR:
 			return "Invalid GL sharegroup reference";
 		default:
-			printf("OpenCL Unknown error: %d\n", code);
+			fprintf(stderr, "OpenCL Unknown error: %d\n", code);
 			return "Unknown error";
 	}
 }

src/cpp/common.cpp

@@ -1,4 +1,4 @@
-#include "types.hpp"
+#include "wrapper.hpp"
 
 
 namespace opencl {
@@ -128,7 +128,7 @@ JS_METHOD(getContextInfo) { NAPI_ENV;
 		Napi::Array arr = Napi::Array::New(env);
 		for(size_t i = 0; i < n; i++) {
 			CHECK_ERR(clRetainDevice(devices[i]))
-			arr.Set(i, Wrapper::fromRaw(env, devices[i]));
+			arr.Set(i, Wrapper::from(env, devices[i]));
 		}
 		RET_VALUE(arr);
 	}

src/cpp/context.cpp

@@ -1,4 +1,4 @@
-#include "types.hpp"
+#include "wrapper.hpp"
 
 
 namespace opencl {
@@ -26,7 +26,7 @@ JS_METHOD(getDeviceIDs) { NAPI_ENV;
 	for (uint32_t i = 0; i < n; i++) {
 		// This is a noop for root-level devices but properly retains sub-devices.
 		CHECK_ERR(clRetainDevice(devices[i]));
-		deviceArray.Set(i, Wrapper::fromRaw(env, devices[i]));
+		deviceArray.Set(i, Wrapper::from(env, devices[i]));
 	}
 
 	RET_VALUE(deviceArray);
@@ -386,7 +386,7 @@ JS_METHOD(createSubDevices) { NAPI_ENV;
 
 	Napi::Array subDevicesArray = Napi::Array::New(env);
 	for (uint32_t i = 0; i<capacity; i++) {
-		subDevicesArray.Set(i, Wrapper::fromRaw(env, subDevices[i]));
+		subDevicesArray.Set(i, Wrapper::from(env, subDevices[i]));
 	}
 
 	RET_VALUE(subDevicesArray);

src/cpp/device.cpp

@@ -1,7 +1,8 @@
 #include <uv.h>
 
-#include "types.hpp"
+#include "wrapper.hpp"
 #include "common.hpp"
+#include "notify-helper.hpp"
 
 
 namespace opencl {
@@ -132,91 +133,17 @@ JS_METHOD(getEventProfilingInfo) { NAPI_ENV;
 	THROW_ERR(CL_INVALID_VALUE);
 }
 
-
-class EventWorker : public Napi::AsyncWorker {
-public:
-	EventWorker(Napi::Function callback, Napi::Object userData, Napi::Object wrapper):
-	Napi::AsyncWorker(callback, "CL::EventWorker") {
-		_refEvent.Reset(wrapper, 1);
-		_refData.Reset(userData, 1);
-		this->async = new uv_async_t();
-		this->async->data = reinterpret_cast<void*>(this);
-		uv_async_init(
-			uv_default_loop(),
-			this->async,
-			(uv_async_cb)
-			dispatched_async_uv_callback
-		);
-	}
-	
-	~EventWorker() {
-		uv_close(reinterpret_cast<uv_handle_t*>(this->async), &delete_async_handle);
-	}
-	
-	uv_async_t *async;
-	
-	void setStatus(int status) {
-		_status = status;
-	}
-	
-	// Executed inside the worker-thread.
-	void Execute() {
-	}
-	
-	// Executed when the async work is complete
-	// this function will be run inside the main event loop
-	void OnOK () {
-		Napi::Env env = Env();
-		NAPI_HS;
-		Callback().Call({
-			_refData.Value(), // userdata
-			JS_NUM(_status), // error status
-			_refEvent.Value() // event
-		});
-	}
-	
-protected:
-	static void delete_async_handle(uv_handle_t *handle);
-	// The callback invoked by the call to uv_async_send() in notifyCB.
-	// Invoked on the main thread, so it's safe to call AsyncQueueWorker.
-	static void dispatched_async_uv_callback(uv_async_t*);
-	
-private:
-	int _status = 0;
-	Napi::ObjectReference _refEvent;
-	Napi::ObjectReference _refData;
-};
-
-void EventWorker::delete_async_handle(uv_handle_t *handle) {
-	delete reinterpret_cast<uv_async_t*>(handle);
-}
-
-void EventWorker::dispatched_async_uv_callback(uv_async_t *req) {
-	EventWorker* asyncCB = static_cast<EventWorker*>(req->data);
-	asyncCB->Queue();
-}
-
-// callback invoked off the main thread by clSetEventCallback
-void CL_CALLBACK notifyCB (cl_event event, cl_int event_command_exec_status, void *user_data) {
-	EventWorker* asyncCB = reinterpret_cast<EventWorker*>(user_data);
-	asyncCB->setStatus(event_command_exec_status);
-	// send a message to the main thread to safely invoke the JS callback
-	uv_async_send(asyncCB->async);
-}
-
 JS_METHOD(setEventCallback) { NAPI_ENV;
 	REQ_CL_ARG(0, ev, cl_event);
 	REQ_UINT32_ARG(1, callbackStatusType);
 	REQ_FUN_ARG(2, callback);
-	LET_OBJ_ARG(3, userData);
 
-	EventWorker* asyncCB = new EventWorker(
-		callback,
-		userData,
-		info[0].As<Napi::Object>()
-	);
-	
-	CHECK_ERR(clSetEventCallback(ev, callbackStatusType, notifyCB, asyncCB));
+	CHECK_ERR(clSetEventCallback(
+		ev,
+		callbackStatusType,
+		NotifyHelper<cl_event>::callNotifyStatus,
+		new NotifyHelper<cl_event>(callback, info[3])
+	));
 
 	RET_NUM(CL_SUCCESS);
 }

src/cpp/event.cpp

@@ -3,7 +3,7 @@
 #include <utility>
 #include <tuple>
 
-#include "types.hpp"
+#include "wrapper.hpp"
 
 
 namespace opencl {
@@ -33,7 +33,7 @@ JS_METHOD(createKernelsInProgram) { NAPI_ENV;
 
 	Napi::Array karr = Napi::Array::New(env);
 	for(cl_uint i = 0; i < numkernels; i++) {
-		karr.Set(i, Wrapper::fromRaw(env, kernels[i]));
+		karr.Set(i, Wrapper::from(env, kernels[i]));
 	}
 	delete[] kernels;
 

src/cpp/kernel.cpp

@@ -1,4 +1,4 @@
-#include "types.hpp"
+#include "wrapper.hpp"
 
 
 namespace opencl {

src/cpp/memobj.cpp

@@ -0,0 +1,83 @@
+#pragma once
+
+#include "wrapper.hpp"
+
+namespace opencl {
+
+template<typename T>
+class NotifyHelper {
+public:
+	NotifyHelper(Napi::Function callback, Napi::Value userData) {
+		Napi::Env env = callback.Env();
+		_tsfn = Napi::ThreadSafeFunction::New(
+			env, callback, Napi::Object(), "NotifyHelper", 0, 1, _delete
+		);
+		
+		_ref.Reset(Napi::Object::New(env), 1);
+		_ref.Set("cb", callback);
+		_ref.Set("data", userData);
+	}
+	
+	~NotifyHelper() {
+		Napi::Env env = _ref.Env();
+		_ref.Set("cb", JS_NULL);
+		_ref.Set("data", JS_NULL);
+		_ref.Reset();
+	}
+	
+	static void CL_CALLBACK callNotify(T resource, void *ptr) {
+		NotifyHelper *notifier = reinterpret_cast<NotifyHelper*>(ptr);
+		notifier->_notify(resource);
+	}
+	static void CL_CALLBACK callNotifyStatus(T resource, cl_int status, void *ptr) {
+		NotifyHelper *notifier = reinterpret_cast<NotifyHelper*>(ptr);
+		notifier->_notifyStatus(resource, status);
+	}
+	
+private:
+	Napi::ObjectReference _ref;
+	Napi::ThreadSafeFunction _tsfn;
+	
+	static void _delete(napi_env env, void* data, void*) {
+		if (data != nullptr) {
+			NotifyHelper* that = static_cast<NotifyHelper*>(data);
+			delete that;
+		}
+	}
+	
+	void _notify(T resource) {
+		NotifyHelper *that = this;
+		napi_status result = _tsfn.NonBlockingCall(
+			[that, resource](Napi::Env env, Napi::Function callback) {
+				callback.Call(
+					that->_ref.Value(),
+					{ Wrapper::from(env, resource), that->_ref.Get("data") }
+				);
+			}
+		);
+		if (result != napi_ok) {
+			fprintf(stderr, "Error: can't call TSFN (#%d).\n", result);
+		}
+		
+		_tsfn.Release();
+	}
+	
+	void _notifyStatus(T resource, cl_int status) {
+		NotifyHelper *that = this;
+		napi_status result = _tsfn.NonBlockingCall(
+			[that, resource, status](Napi::Env env, Napi::Function callback) {
+				callback.Call(
+					that->_ref.Value(),
+					{ Wrapper::from(env, resource), JS_NUM(status), that->_ref.Get("data") }
+				);
+			}
+		);
+		if (result != napi_ok) {
+			fprintf(stderr, "Error: can't call TSFN (#%d).\n", result);
+		}
+		
+		_tsfn.Release();
+	}
+};
+
+} // namespace opencl