feat(c): Add co-op threading builtins to C generator (#1491)

* Add threading builtins to C generator

* Add generate-async-helpers flag

* Update tests

* Add ldflags option

* Change context_get and context_set

* Split out to new flag

* Use globals for test

* Format

* Compile test with optimizations

Author: TartanLlama

.github/workflows/main.yml

@@ -161,7 +161,7 @@ jobs:
         cargo run test --languages rust,c,go tests/runtime-async \
           --artifacts target/artifacts \
           --rust-wit-bindgen-path ./crates/guest-rust \
-          --runner "wasmtime -W component-model-async"
+          --runner "wasmtime -W component-model-async -W component-model-threading -W component-model-async-stackful"
 
   test_unit:
     name: Crate Unit Tests

crates/c/src/lib.rs

@@ -103,7 +103,7 @@ pub struct Opts {
     #[cfg_attr(feature = "clap", arg(long, value_name = "NAME"))]
     pub rename_world: Option<String>,
 
-    /// Add the specified suffix to the name of the custome section containing
+    /// Add the specified suffix to the name of the custom section containing
     /// the component type.
     #[cfg_attr(feature = "clap", arg(long, value_name = "STRING"))]
     pub type_section_suffix: Option<String>,
@@ -121,6 +121,14 @@ pub struct Opts {
 
     #[cfg_attr(feature = "clap", clap(flatten))]
     pub async_: AsyncFilterSet,
+
+    /// Force generation of async helpers even if no async functions/futures are present.
+    #[cfg_attr(feature = "clap", arg(long, default_value_t = false))]
+    pub generate_async_helpers: bool,
+
+    /// Generate helpers for threading builtins. Implies `--generate-async-helpers`.
+    #[cfg_attr(feature = "clap", arg(long, default_value_t = false))]
+    pub generate_threading_helpers: bool,
 }
 
 #[cfg(feature = "clap")]
@@ -432,9 +440,16 @@ impl WorldGenerator for C {
                 "\nunion double_int64 {{ double a; int64_t b; }};"
             );
         }
-        if self.needs_async || self.futures.len() > 0 {
+        if self.needs_async
+            || self.futures.len() > 0
+            || self.opts.generate_async_helpers
+            || self.opts.generate_threading_helpers
+        {
             self.generate_async_helpers();
         }
+        if self.opts.generate_threading_helpers {
+            self.generate_threading_helpers();
+        }
         let version = env!("CARGO_PKG_VERSION");
         let mut h_str = wit_bindgen_core::Source::default();
 
@@ -703,6 +718,115 @@ impl C {
         }
     }
 
+    fn generate_threading_helpers(&mut self) {
+        let snake = self.world.to_snake_case();
+        uwriteln!(
+            self.src.h_async,
+            "
+void* {snake}_context_get_1(void);
+void {snake}_context_set_1(void* value);
+uint32_t {snake}_thread_yield_cancellable(void);
+uint32_t {snake}_thread_index(void);
+uint32_t {snake}_thread_new_indirect(void (*start_function)(void*), void* arg);
+void {snake}_thread_switch_to(uint32_t thread);
+uint32_t {snake}_thread_switch_to_cancellable(uint32_t thread);
+void {snake}_thread_resume_later(uint32_t thread);
+void {snake}_thread_yield_to(uint32_t thread);
+uint32_t {snake}_thread_yield_to_cancellable(uint32_t thread);
+void {snake}_thread_suspend(void);
+uint32_t {snake}_thread_suspend_cancellable(void);
+            "
+        );
+        uwriteln!(
+            self.src.c_async,
+            r#"
+__attribute__((__import_module__("$root"), __import_name__("[context-get-1]")))
+extern void* __context_get_1(void);
+
+void* {snake}_context_get_1(void) {{
+    return __context_get_1();
+}}
+
+__attribute__((__import_module__("$root"), __import_name__("[context-set-1]")))
+extern void __context_set_1(void*);
+
+void {snake}_context_set_1(void* value) {{
+    __context_set_1(value);
+}}
+
+__attribute__((__import_module__("$root"), __import_name__("[cancellable][thread-yield]")))
+extern uint32_t __thread_yield_cancellable(void);
+
+uint32_t {snake}_thread_yield_cancellable(void) {{
+    return __thread_yield_cancellable();
+}}
+
+__attribute__((__import_module__("$root"), __import_name__("[thread-index]")))
+extern uint32_t __thread_index(void);
+
+uint32_t {snake}_thread_index(void) {{
+    return __thread_index();
+}}
+
+__attribute__((__import_module__("$root"), __import_name__("[thread-new-indirect-v0]")))
+extern uint32_t __thread_new_indirect(uint32_t, void*);
+
+uint32_t {snake}_thread_new_indirect(void (*start_function)(void*), void* arg) {{
+    return __thread_new_indirect((uint32_t)(uintptr_t)start_function, arg
+);
+}}
+
+__attribute__((__import_module__("$root"), __import_name__("[thread-switch-to]")))
+extern uint32_t __thread_switch_to(uint32_t);
+
+void {snake}_thread_switch_to(uint32_t thread) {{
+    __thread_switch_to(thread);
+}}
+
+__attribute__((__import_module__("$root"), __import_name__("[cancellable][thread-switch-to]")))
+extern uint32_t __thread_switch_to_cancellable(uint32_t);
+
+uint32_t {snake}_thread_switch_to_cancellable(uint32_t thread) {{
+    return __thread_switch_to_cancellable(thread);
+}}
+
+__attribute__((__import_module__("$root"), __import_name__("[thread-resume-later]")))
+extern void __thread_resume_later(uint32_t);
+
+void {snake}_thread_resume_later(uint32_t thread) {{
+    __thread_resume_later(thread);
+}}
+
+__attribute__((__import_module__("$root"), __import_name__("[thread-yield-to]")))
+extern uint32_t __thread_yield_to(uint32_t);
+
+void {snake}_thread_yield_to(uint32_t thread) {{
+    __thread_yield_to(thread);
+}}
+
+__attribute__((__import_module__("$root"), __import_name__("[cancellable][thread-yield-to]")))
+extern uint32_t __thread_yield_to_cancellable(uint32_t);
+
+uint32_t {snake}_thread_yield_to_cancellable(uint32_t thread) {{
+    return __thread_yield_to_cancellable(thread);
+}}
+
+__attribute__((__import_module__("$root"), __import_name__("[thread-suspend]")))
+extern uint32_t __thread_suspend(void);
+
+void {snake}_thread_suspend(void) {{
+    __thread_suspend();
+}}
+
+__attribute__((__import_module__("$root"), __import_name__("[cancellable][thread-suspend]")))
+extern uint32_t __thread_suspend_cancellable(void);
+uint32_t {snake}_thread_suspend_cancellable(void) {{
+    return __thread_suspend_cancellable();
+}}
+            "#
+        );
+    }
+
     fn generate_async_helpers(&mut self) {
         let snake = self.world.to_snake_case();
         let shouty = self.world.to_shouty_snake_case();
@@ -768,10 +892,9 @@ typedef enum {snake}_waitable_state {{
 
 void {snake}_backpressure_inc(void);
 void {snake}_backpressure_dec(void);
-void* {snake}_context_get(void);
-void {snake}_context_set(void*);
-void {snake}_yield(void);
-uint32_t {snake}_yield_cancellable(void);
+void* {snake}_context_get_0(void);
+void {snake}_context_set_0(void* value);
+void {snake}_thread_yield(void);
             "
         );
         uwriteln!(
@@ -847,32 +970,26 @@ void {snake}_backpressure_dec(void) {{
 }}
 
 __attribute__((__import_module__("$root"), __import_name__("[context-get-0]")))
-extern void* __context_get(void);
+extern void* __context_get_0(void);
 
-void* {snake}_context_get() {{
-    return __context_get();
+void* {snake}_context_get_0(void) {{
+    return __context_get_0();
 }}
 
 __attribute__((__import_module__("$root"), __import_name__("[context-set-0]")))
-extern void __context_set(void*);
+extern void __context_set_0(void*);
 
-void {snake}_context_set(void *val) {{
-    return __context_set(val);
+
+void {snake}_context_set_0(void *value) {{
+    __context_set_0(value);
 }}
 
 __attribute__((__import_module__("$root"), __import_name__("[thread-yield]")))
 extern uint32_t __thread_yield(void);
 
-void {snake}_yield(void) {{
+void {snake}_thread_yield(void) {{
     __thread_yield();
 }}
-
-__attribute__((__import_module__("$root"), __import_name__("[cancellable][thread-yield]")))
-extern uint32_t __thread_yield_cancellable(void);
-
-uint32_t {snake}_yield_cancellable(void) {{
-    return __thread_yield_cancellable();
-}}
             "#
         );
     }

crates/test/README.md

@@ -314,9 +314,10 @@ separate crate and passed as `--extern`
 
 #### Configuration: C
 
-C/C++ configuration supports configuring compilation flags at this time:
+C/C++ configuration supports configuring compilation and linker flags at this time:
 
 ```rust
 //@ [lang]
 //@ cflags = '-O'
+//@ ldflags = "-Wl,--export-table"
 ```

crates/test/src/c.rs

@@ -28,6 +28,9 @@ struct LangConfig {
     /// Space-separated list or array of compiler flags to pass.
     #[serde(default)]
     cflags: StringList,
+    /// Space-separated list or array of linker flags to pass.
+    #[serde(default)]
+    ldflags: StringList,
 }
 
 fn clang(runner: &Runner<'_>) -> PathBuf {
@@ -144,6 +147,9 @@ fn compile(runner: &Runner<'_>, compile: &Compile<'_>, compiler: PathBuf) -> Res
     for flag in Vec::from(config.cflags) {
         cmd.arg(flag);
     }
+    for flag in Vec::from(config.ldflags) {
+        cmd.arg(flag);
+    }
     cmd.arg("-mexec-model=reactor");
     if produces_component(runner) {
         cmd.arg("-Wl,--skip-wit-component");

tests/runtime-async/async/cancel-import/test.c

@@ -18,12 +18,12 @@ test_callback_code_t exports_test_pending_import(exports_test_future_void_t x) {
   task->set = test_waitable_set_new();
   test_waitable_join(task->future, task->set);
 
-  test_context_set(task);
+  test_context_set_0(task);
   return TEST_CALLBACK_CODE_WAIT(task->set);
 }
 
 test_callback_code_t exports_test_pending_import_callback(test_event_t *event) {
-  struct my_task *task = (struct my_task*) test_context_get();
+  struct my_task *task = (struct my_task*) test_context_get_0();
   if (event->event == TEST_EVENT_CANCEL) {
     assert(event->waitable == 0);
     assert(event->code == 0);

tests/runtime-async/async/future-cancel-read/test.c

@@ -58,13 +58,13 @@ test_callback_code_t exports_test_start_read_then_cancel(
 
   test_waitable_join(signal, state->set);
 
-  test_context_set(state);
+  test_context_set_0(state);
   return TEST_CALLBACK_CODE_WAIT(state->set);
 }
 
 test_callback_code_t exports_test_start_read_then_cancel_callback(test_event_t *event) {
   struct start_read_then_cancel_state *state =
-    (struct start_read_then_cancel_state*) test_context_get();
+    (struct start_read_then_cancel_state*) test_context_get_0();
   assert(event->event == TEST_EVENT_FUTURE_READ);
   assert(event->waitable == state->signal);
   assert(TEST_WAITABLE_STATE(event->code) == TEST_WAITABLE_COMPLETED);

tests/runtime-async/async/pending-import/test.c

@@ -18,12 +18,12 @@ test_callback_code_t exports_test_pending_import(exports_test_future_void_t x) {
   task->set = test_waitable_set_new();
   test_waitable_join(task->future, task->set);
 
-  test_context_set(task);
+  test_context_set_0(task);
   return TEST_CALLBACK_CODE_WAIT(task->set);
 }
 
 test_callback_code_t exports_test_pending_import_callback(test_event_t *event) {
-  struct my_task *task = (struct my_task*) test_context_get();
+  struct my_task *task = (struct my_task*) test_context_get_0();
   assert(event->event == TEST_EVENT_FUTURE_READ);
   assert(event->waitable == task->future);
   assert(TEST_WAITABLE_STATE(event->code) == TEST_WAITABLE_COMPLETED);

tests/runtime-async/async/ping-pong/test.c

@@ -33,12 +33,12 @@ test_callback_code_t exports_test_ping(exports_test_future_string_t x, test_stri
 
   // Register ourselves as waiting on the future, then block our task.
   test_waitable_join(task->future, task->set);
-  test_context_set(task);
+  test_context_set_0(task);
   return TEST_CALLBACK_CODE_WAIT(task->set);
 }
 
 test_callback_code_t exports_test_ping_callback(test_event_t *event) {
-  struct ping_task *task = (struct ping_task*) test_context_get();
+  struct ping_task *task = (struct ping_task*) test_context_get_0();
   switch (task->state) {
     case PING_S1: {
       // Assert that our future read completed and discard the read end of the
@@ -126,12 +126,12 @@ test_callback_code_t exports_test_pong(exports_test_future_string_t x) {
   assert(status == TEST_WAITABLE_STATUS_BLOCKED);
   test_waitable_join(task->future, task->set);
 
-  test_context_set(task);
+  test_context_set_0(task);
   return TEST_CALLBACK_CODE_WAIT(task->set);
 }
 
 test_callback_code_t exports_test_pong_callback(test_event_t *event) {
-  struct pong_task *task = (struct pong_task*) test_context_get();
+  struct pong_task *task = (struct pong_task*) test_context_get_0();
 
   // assert this event is a future read completion
   assert(event->event == TEST_EVENT_FUTURE_READ);

tests/runtime-async/async/simple-yield/test.c

@@ -12,7 +12,7 @@ test_subtask_status_t exports_test_f_callback(test_event_t *event) {
   assert(event->event == TEST_EVENT_NONE);
   assert(event->waitable == 0);
   assert(event->code == 0);
-  test_yield();
+  test_thread_yield();
   exports_test_f_return();
   return TEST_CALLBACK_CODE_EXIT;
 }

tests/runtime-async/async/threading-builtins/runner.c

@@ -0,0 +1,20 @@
+//@ args = '--rename a:b/i=test --async=-run'
+#include <assert.h>
+#include <runner.h>
+
+void exports_runner_run()
+{
+    runner_subtask_status_t status = test_f();
+    assert(RUNNER_SUBTASK_STATE(status) == RUNNER_SUBTASK_STARTED);
+    runner_subtask_t task = RUNNER_SUBTASK_HANDLE(status);
+
+    runner_waitable_set_t set = runner_waitable_set_new();
+    runner_waitable_join(task, set);
+    runner_event_t event;
+    runner_waitable_set_wait(set, &event);
+    assert(event.event == RUNNER_EVENT_SUBTASK);
+    assert(event.waitable == task);
+    assert(event.code == RUNNER_SUBTASK_RETURNED);
+    runner_waitable_join(task, 0);
+    runner_waitable_set_drop(set);
+}