update dependency - bug fix, expose future/promise

- transformed `uv_queue_work` to c++11 future/promise thread pool style add working example, same libuv and stage test

Author: TheTechsTech

CMakeLists.txt

@@ -25,8 +25,8 @@ set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake;${CMAKE_MODULE_PATH}")
 find_package(raii QUIET)
 if(NOT raii_FOUND)
     FetchContent_Declare(raii
-        URL https://github.com/zelang-dev/c-raii/archive/refs/tags/2.0.0.zip
-        URL_MD5 2bb38a0fae3c276139b4ec78c8b670ef
+        URL https://github.com/zelang-dev/c-raii/archive/refs/tags/2.1.0.zip
+        URL_MD5 e97338afb9360b320aecf74716be5fdc
     )
     FetchContent_MakeAvailable(raii)
 endif()

README.md

@@ -244,7 +244,7 @@ The *[tests](https://github.com/dermesser/uvco/tree/master/test)* presented ther
 
 ## Design
 
-The *intergration* pattern for all **libuv** functions taking *callback* is as [queue-work.c](https://github.com/zelang-dev/c-asio/tree/main/examples/queue-work.c) **example**:
+The *intergration* pattern for all **libuv** functions taking *callback* is as [waitgroup_work.c](https://github.com/zelang-dev/c-asio/tree/main/examples/waitgroup_work.c) **example**:
 
 ```c
 #define USE_CORO
@@ -489,6 +489,51 @@ C_API bool is_tty_err(void_t);
 C_API bool is_addrinfo(void_t);
 C_API bool is_nameinfo(void_t);
 
+C_API bool is_promise(void_t);
+C_API bool is_future(void_t);
+
+/*
+This runs the function `fn` asynchronously (potentially in a separate thread which
+might be a part of a thread pool) and returns a `future` that will eventually hold
+the result of that function call.
+
+Similar to: https://en.cppreference.com/w/cpp/thread/async.html
+https://en.cppreference.com/w/cpp/thread/packaged_task.html
+
+MUST call either `queue_then()` or `queue_get()` to actually start execution in thread.
+*/
+C_API future queue_work(thrd_func_t fn, size_t num_args, ...);
+
+/*
+This will complete an normal `uv_queue_work()` setup execution and allow thread to run
+`queue_work()` provided `fn`.
+
+Will return `promise` only useful with `queue_get()`.
+
+Similar to: https://en.cppreference.com/w/cpp/thread/promise.html */
+C_API promise *queue_then(future, queue_cb callback);
+
+/*
+This waits aka `yield` until the `future` or `promise` is ready, then retrieves
+the value stored. Right after calling this function `queue_is_valid()` is `false`.
+
+Similar to: https://en.cppreference.com/w/cpp/thread/future/get.html */
+C_API template_t queue_get(void_t);
+
+/*
+Checks if the ~future/uv_work_t~ refers to a shared state aka `promise`, and `running`.
+
+Similar to: https://en.cppreference.com/w/cpp/thread/future/valid.html
+*/
+C_API bool queue_is_valid(future);
+
+/*
+Will `pause` and `yield` to another `coroutine` until `ALL` ~future/uv_work_t~
+results/requests in `array` become available/done. Calls `queue_is_valid()` on each.
+
+Similar to: https://en.cppreference.com/w/cpp/thread/future/wait.html */
+C_API void queue_wait(arrays_t);
+
 /**
  * Initializes the process handle and starts the process.
  * If the process is successfully spawned, this function will return `spawn_t`

docs/index.md

@@ -244,7 +244,7 @@ The *[tests](https://github.com/dermesser/uvco/tree/master/test)* presented ther
 
 ## Design
 
-The *intergration* pattern for all **libuv** functions taking *callback* is as [queue-work.c](https://github.com/zelang-dev/c-asio/tree/main/examples/queue-work.c) **example**:
+The *intergration* pattern for all **libuv** functions taking *callback* is as [waitgroup_work.c](https://github.com/zelang-dev/c-asio/tree/main/examples/waitgroup_work.c) **example**:
 
 ```c
 #define USE_CORO
@@ -489,6 +489,51 @@ C_API bool is_tty_err(void_t);
 C_API bool is_addrinfo(void_t);
 C_API bool is_nameinfo(void_t);
 
+C_API bool is_promise(void_t);
+C_API bool is_future(void_t);
+
+/*
+This runs the function `fn` asynchronously (potentially in a separate thread which
+might be a part of a thread pool) and returns a `future` that will eventually hold
+the result of that function call.
+
+Similar to: https://en.cppreference.com/w/cpp/thread/async.html
+https://en.cppreference.com/w/cpp/thread/packaged_task.html
+
+MUST call either `queue_then()` or `queue_get()` to actually start execution in thread.
+*/
+C_API future queue_work(thrd_func_t fn, size_t num_args, ...);
+
+/*
+This will complete an normal `uv_queue_work()` setup execution and allow thread to run
+`queue_work()` provided `fn`.
+
+Will return `promise` only useful with `queue_get()`.
+
+Similar to: https://en.cppreference.com/w/cpp/thread/promise.html */
+C_API promise *queue_then(future, queue_cb callback);
+
+/*
+This waits aka `yield` until the `future` or `promise` is ready, then retrieves
+the value stored. Right after calling this function `queue_is_valid()` is `false`.
+
+Similar to: https://en.cppreference.com/w/cpp/thread/future/get.html */
+C_API template_t queue_get(void_t);
+
+/*
+Checks if the ~future/uv_work_t~ refers to a shared state aka `promise`, and `running`.
+
+Similar to: https://en.cppreference.com/w/cpp/thread/future/valid.html
+*/
+C_API bool queue_is_valid(future);
+
+/*
+Will `pause` and `yield` to another `coroutine` until `ALL` ~future/uv_work_t~
+results/requests in `array` become available/done. Calls `queue_is_valid()` on each.
+
+Similar to: https://en.cppreference.com/w/cpp/thread/future/wait.html */
+C_API void queue_wait(arrays_t);
+
 /**
  * Initializes the process handle and starts the process.
  * If the process is successfully spawned, this function will return `spawn_t`

examples/CMakeLists.txt

@@ -14,6 +14,7 @@ set(TARGET_LIST
  create-x509
  uv_tls_server
  uv_tls_client
+ waitgroup_work
 )
 
 foreach (TARGET ${TARGET_LIST})

examples/queue-work.c

@@ -1,5 +1,4 @@
-#define USE_CORO
-#include "raii.h"
+#include "asio.h"
 
 #define FIB_UNTIL 25
 
@@ -10,37 +9,35 @@ long fib_(long t) {
         return fib_(t-1) + fib_(t-2);
 }
 
-void_t fib(params_t req) {
-    int n = req->integer;
-    if (random() % 2)
-        sleepfor(1);
+void_t fib(args_t req) {
+	int n = req->integer;
+	if (random() % 2)
+        sleep(1);
     else
-        sleepfor(3);
+        sleep(3);
+	long fib = fib_(n);
+	fprintf(stderr, "%dth fibonacci is %lu"CLR_LN, n, fib);
 
-    long fib = fib_(n);
-    fprintf(stderr, "%dth fibonacci is %lu in thrd: #%d\033[0K\n", n, fib, coro_thrd_id());
-
-    return casting(fib);
+	return $$(n, fib);
 }
 
-void after_fib(int status, rid_t id) {
-    fprintf(stderr, "Done calculating %dth fibonacci, result: %d\n", status, result_for(id).integer);
+void after_fib(vectors_t req) {
+	fprintf(stderr, "Done calculating %dth fibonacci, result: %d"CLR_LN,
+		req[0].integer, req[1].integer);
 }
 
-int main(int argc, char **argv) {
-    rid_t data[FIB_UNTIL];
-    int i;
+int uv_main(int argc, char **argv) {
+	arrays_t arr = arrays();
+	int i;
 
-    waitgroup_t wg = waitgroup_ex(FIB_UNTIL);
-    for (i = 0; i < FIB_UNTIL; i++) {
-        data[i] = go(fib, 1, casting(i));
-    }
-    waitresult_t wgr = waitfor(wg);
+	yield();
+	for (i = 0; i < FIB_UNTIL; i++) {
+		future req = queue_work(fib, 1, casting(i));
+		$append(arr, req);
+		queue_then(req, after_fib);
+	}
 
-    if ($size(wgr) == FIB_UNTIL)
-        for (i = 0; i < FIB_UNTIL; i++) {
-            after_fib(i, data[i]);
-        }
+	queue_wait(arr);
 
-    return 0;
+	return 0;
 }

examples/waitgroup_work.c

@@ -0,0 +1,45 @@
+#define USE_CORO
+#include "raii.h"
+
+#define FIB_UNTIL 25
+
+long fib_(long t) {
+    if (t == 0 || t == 1)
+        return 1;
+    else
+        return fib_(t-1) + fib_(t-2);
+}
+
+void_t fib(params_t req) {
+    int n = req->integer;
+    if (random() % 2)
+        sleepfor(1);
+    else
+        sleepfor(3);
+
+    long fib = fib_(n);
+    fprintf(stderr, "%dth fibonacci is %lu in thrd: #%d\033[0K\n", n, fib, coro_thrd_id());
+
+    return casting(fib);
+}
+
+void after_fib(int status, rid_t id) {
+    fprintf(stderr, "Done calculating %dth fibonacci, result: %d\n", status, result_for(id).integer);
+}
+
+int main(int argc, char **argv) {
+    rid_t data[FIB_UNTIL];
+    int i;
+
+    waitgroup_t wg = waitgroup_ex(FIB_UNTIL);
+    for (i = 0; i < FIB_UNTIL; i++) {
+        data[i] = go(fib, 1, casting(i));
+    }
+    waitresult_t wgr = waitfor(wg);
+
+    if ($size(wgr) == FIB_UNTIL)
+        for (i = 0; i < FIB_UNTIL; i++)
+            after_fib(i, data[i]);
+
+    return 0;
+}

include/asio.h

@@ -2,21 +2,17 @@
 #define _ASIO_H
 
 #define INTERRUPT_MODE UV_RUN_NOWAIT
-#ifndef CERTIFICATE
-    #define CERTIFICATE "localhost"
-#endif
 
 #include "evt_tls.h"
 #include "url_http.h"
 #include "reflection.h"
 
 #ifdef _WIN32
-#define INVALID_FD -EBADF
 #define use_ipc false
 #else
-#define INVALID_FD -EBADF
 #define use_ipc true
 #endif
+#define INVALID_FD -EBADF
 
 /* Cast ~libuv~ `obj` to `uv_stream_t` ptr. */
 #define streamer(obj) ((uv_stream_t *)obj)
@@ -201,6 +197,7 @@ typedef void (*stream_cb)(uv_stream_t *);
 typedef void (*packet_cb)(udp_packet_t *);
 typedef void (*spawn_cb)(int64_t status, int signal);
 typedef void (*spawn_handler_cb)(uv_stream_t *input, string output, uv_stream_t *duplex);
+typedef void (*queue_cb)(vectors_t result);
 
 typedef struct {
     asio_types type;
@@ -481,6 +478,49 @@ C_API int udp_send(uv_udp_t *handle, string_t message, string_t addr);
 C_API udp_packet_t *udp_recv(uv_udp_t *);
 C_API int udp_send_packet(udp_packet_t *, string_t);
 
+/*
+This runs the function `fn` asynchronously (potentially in a separate thread which
+might be a part of a thread pool) and returns a `future` that will eventually hold
+the result of that function call.
+
+Similar to: https://en.cppreference.com/w/cpp/thread/async.html
+https://en.cppreference.com/w/cpp/thread/packaged_task.html
+
+MUST call either `queue_then()` or `queue_get()` to actually start execution in thread.
+*/
+C_API future queue_work(thrd_func_t fn, size_t num_args, ...);
+
+/*
+This will complete an normal `uv_queue_work()` setup execution and allow thread to run
+`queue_work()` provided `fn`.
+
+Will return `promise` only useful with `queue_get()`.
+
+Similar to: https://en.cppreference.com/w/cpp/thread/promise.html */
+C_API promise *queue_then(future, queue_cb callback);
+
+/*
+This waits aka `yield` until the `future` or `promise` is ready, then retrieves
+the value stored. Right after calling this function `queue_is_valid()` is `false`.
+
+Similar to: https://en.cppreference.com/w/cpp/thread/future/get.html */
+C_API template_t queue_get(void_t);
+
+/*
+Checks if the ~future/uv_work_t~ refers to a shared state aka `promise`, and `running`.
+
+Similar to: https://en.cppreference.com/w/cpp/thread/future/valid.html
+*/
+C_API bool queue_is_valid(future);
+
+/*
+Will `pause` and `yield` to another `coroutine` until `ALL` ~future/uv_work_t~
+results/requests in `array` become available/done. Calls `queue_is_valid()` on each.
+
+Similar to: https://en.cppreference.com/w/cpp/thread/future/wait.html */
+C_API void queue_wait(arrays_t);
+C_API void queue_delete(future);
+
 #define UV_TLS                  RAII_SCHEME_TLS
 #define UV_CTX                  ASIO_ARGS + RAII_NAN
 
@@ -517,7 +557,9 @@ C_API bool is_tty_out(void_t);
 C_API bool is_tty_err(void_t);
 C_API bool is_addrinfo(void_t);
 C_API bool is_nameinfo(void_t);
-C_API bool is_addressable(void_t);
+
+C_API bool is_promise(void_t);
+C_API bool is_future(void_t);
 
 /* This library provides its own ~main~,
 which call this function as an coroutine! */