lib+driver+common: Support platforms with no threading

I was experimenting with getting c-ray to run on Tilck[1], and ran into
issues when c-ray ignored errors coming from pthread_create(3). Now both
the thread pool and other users fall back to performing work on the main
thread synchronously, should starting a thread fail.

A new macro exists in thread.h to simulate this case on a system with
threading support: CR_SIMULATE_NOTHREADS

[1] https://github.com/vvaltchev/tilck

Author: vkoskiv

src/common/platform/thread.c

@@ -43,6 +43,9 @@ void thread_wait(struct cr_thread *t) {
 // allocation here to extend the lifetime.
 
 int thread_create_detach(struct cr_thread *t) {
+#ifdef CR_SIMULATE_NOTHREADS
+	return -1;
+#endif
 	if (!t) return -1;
 	struct cr_thread *temp = calloc(1, sizeof(*temp));
 	*temp = *t;
@@ -51,13 +54,18 @@ int thread_create_detach(struct cr_thread *t) {
 	CloseHandle(t->thread_handle);
 	return 0;
 #else
-	pthread_create(&t->thread_id, NULL, thread_stub, temp);
+	int rc = pthread_create(&t->thread_id, NULL, thread_stub, temp);
+	if (rc)
+		return rc;
 	pthread_detach(t->thread_id);
 	return 0;
 #endif
 }
 
 int thread_start(struct cr_thread *t) {
+#ifdef CR_SIMULATE_NOTHREADS
+	return -1;
+#endif
 	if (!t) return -1;
 	struct cr_thread *temp = calloc(1, sizeof(*temp));
 	*temp = *t;
@@ -69,9 +77,9 @@ int thread_start(struct cr_thread *t) {
 	pthread_attr_t attribs;
 	pthread_attr_init(&attribs);
 	pthread_attr_setdetachstate(&attribs, PTHREAD_CREATE_JOINABLE);
-	int ret = pthread_create(&t->thread_id, &attribs, thread_stub, temp);
+	int rc = pthread_create(&t->thread_id, &attribs, thread_stub, temp);
 	pthread_attr_destroy(&attribs);
-	return ret;
+	return rc;
 #endif
 }
 

src/common/platform/thread.h

@@ -20,6 +20,8 @@
 
 // small thread/sync abstraction for POSIX and Windows
 
+// #define CR_SIMULATE_NOTHREADS
+
 /**
  Thread information struct to communicate with main thread
  */

src/common/platform/thread_pool.c

@@ -9,6 +9,7 @@
 #include "thread_pool.h"
 #include "mutex.h"
 #include "thread.h"
+#include "signal.h"
 #include "../logging.h"
 
 // Mostly based on John Schember's excellent blog post:
@@ -63,6 +64,7 @@ static struct cr_task *thread_pool_get_task(struct cr_thread_pool *pool) {
 }
 
 static void *cr_worker(void *arg) {
+	block_signals();
 	struct cr_thread_pool *pool = arg;
 	while (true) {
 		mutex_lock(pool->mutex);
@@ -91,7 +93,8 @@ static void *cr_worker(void *arg) {
 }
 
 struct cr_thread_pool *thread_pool_create(size_t threads) {
-	if (!threads) threads = 2;
+	if (!threads)
+		threads = 2;
 	struct cr_thread_pool *pool = calloc(1, sizeof(*pool));
 	logr(debug, "Spawning thread pool (%zut, %p)\n", threads, (void *)pool);
 	pool->alive_threads = threads;
@@ -106,13 +109,22 @@ struct cr_thread_pool *thread_pool_create(size_t threads) {
 			.thread_fn = cr_worker,
 			.user_data = pool
 		};
-		thread_create_detach(&pool->threads[i]);
+		if (thread_create_detach(&pool->threads[i]))
+			goto fail;
 	}
 	return pool;
+fail:
+	free(pool->threads);
+	mutex_destroy(pool->mutex);
+	thread_cond_destroy(&pool->work_available);
+	thread_cond_destroy(&pool->work_ongoing);
+	free(pool);
+	return NULL;
 }
 
 void thread_pool_destroy(struct cr_thread_pool *pool) {
-	if (!pool) return;
+	if (!pool)
+		return;
 	logr(debug, "Closing thread pool (%zut, %p)\n", pool->alive_threads, (void *)pool);
 	mutex_lock(pool->mutex);
 	// Clear work queue
@@ -139,7 +151,11 @@ void thread_pool_destroy(struct cr_thread_pool *pool) {
 }
 
 bool thread_pool_enqueue(struct cr_thread_pool *pool, void (*fn)(void *arg), void *arg) {
-	if (!pool) return false;
+	if (!pool) { // Fall back to running synchronously
+		if (fn)
+			fn(arg);
+		return false;
+	}
 	struct cr_task *task = task_create(fn, arg);
 	if (!task) return false;
 	mutex_lock(pool->mutex);
@@ -156,7 +172,8 @@ bool thread_pool_enqueue(struct cr_thread_pool *pool, void (*fn)(void *arg), voi
 }
 
 void thread_pool_wait(struct cr_thread_pool *pool) {
-	if (!pool) return;
+	if (!pool)
+		return;
 	mutex_lock(pool->mutex);
 	while (true) {
 		if (pool->first || (!pool->stop_flag && pool->active_threads != 0) || (pool->stop_flag && pool->alive_threads != 0)) {

src/driver/main.c

@@ -74,10 +74,13 @@ static void on_start(struct cr_renderer_cb_info *cb_info, void *user_data) {
 		.cb_info = cb_info,
 		.driver = d,
 	};
-	thread_start(&(struct cr_thread){
+	int rc = thread_start(&(struct cr_thread){
 	    .thread_fn = win_init_task,
 	    .user_data = ctx,
 	});
+	if (rc) { // Try synchronously, then.
+		win_init_task(ctx);
+	}
 #endif
 }
 

src/lib/api/c-ray.c

@@ -247,7 +247,6 @@ struct bvh_build_task_arg {
 };
 
 void bvh_build_task(void *arg) {
-	block_signals();
 	// Mesh array may get realloc'd at any time, so we use a copy of mesh while working
 	struct bvh_build_task_arg *bt = (struct bvh_build_task_arg *)arg;
 	struct timeval timer = { 0 };

src/lib/nodes/colornode.c

@@ -16,7 +16,6 @@
 #include <datatypes/scene.h>
 #include "bsdfnode.h"
 #include "../../common/platform/thread_pool.h"
-#include "../../common/platform/signal.h"
 #include "../../common/timer.h"
 
 #include "colornode.h"
@@ -32,7 +31,6 @@ struct decode_task_arg {
 };
 
 void tex_decode_task(void *arg) {
-	block_signals();
 	struct decode_task_arg *dt = (struct decode_task_arg *)arg;
 	struct timeval timer = { 0 };
 	timer_start(&timer);

src/lib/renderer/renderer.c

@@ -275,35 +275,56 @@ void renderer_render(struct renderer *r) {
 			}
 		});
 	}
+	bool threads_not_supported = false;
 	for (size_t w = 0; w < r->state.workers.count; ++w) {
 		r->state.workers.items[w].thread.user_data = &r->state.workers.items[w];
 		r->state.workers.items[w].tiles = &set;
-		if (thread_start(&r->state.workers.items[w].thread))
-			logr(error, "Failed to start worker %zu\n", w);
+		if (thread_start(&r->state.workers.items[w].thread)) {
+			threads_not_supported = true;
+			break;
+		}
 	}
 
-	//Start main thread loop to handle renderer feedback and state management
-	while (r->state.s == r_rendering) {
-		size_t inactive = 0;
-		for (size_t w = 0; w < r->state.workers.count; ++w) {
-			if (r->state.workers.items[w].thread_complete) inactive++;
-		}
-		if (g_aborted || inactive == r->state.workers.count) break;
-		
-		struct callback status = r->state.callbacks[cr_cb_status_update];
-		if (status.fn) {
-			update_cb_info(r, &set, &cb_info);
-			status.fn(&cb_info, status.user_data);
+	if (threads_not_supported) {
+		struct worker *w = &r->state.workers.items[0];
+		w->thread.thread_fn = render_single_iteration;
+		while (r->state.s == r_rendering) {
+			w->thread.thread_fn(w->thread.user_data);
+			if (g_aborted || w->thread_complete)
+				break;
+			struct callback status = r->state.callbacks[cr_cb_status_update];
+			if (status.fn) {
+				update_cb_info(r, &set, &cb_info);
+				status.fn(&cb_info, status.user_data);
+			}
 		}
 
-		timer_sleep_ms(r->state.workers.items[0].paused ? paused_msec : active_msec);
+	} else {
+		//Start main thread loop to handle renderer feedback and state management
+		while (r->state.s == r_rendering) {
+			size_t inactive = 0;
+			for (size_t w = 0; w < r->state.workers.count; ++w) {
+				if (r->state.workers.items[w].thread_complete) inactive++;
+			}
+			if (g_aborted || inactive == r->state.workers.count)
+				break;
+
+			struct callback status = r->state.callbacks[cr_cb_status_update];
+			if (status.fn) {
+				update_cb_info(r, &set, &cb_info);
+				status.fn(&cb_info, status.user_data);
+			}
+
+			timer_sleep_ms(r->state.workers.items[0].paused ? paused_msec : active_msec);
+		}
 	}
 
+
 	r->state.s = r_exiting;
 	r->state.current_set = NULL;
-	
+
 	//Make sure render threads are terminated before continuing (This blocks)
-	for (size_t w = 0; w < r->state.workers.count; ++w)
+	for (size_t w = 0; !threads_not_supported && w < r->state.workers.count; ++w)
 		thread_wait(&r->state.workers.items[w].thread);
 
 	struct callback stop = r->state.callbacks[cr_cb_on_stop];