|
| 1 | +//go:build none |
| 2 | + |
| 3 | +#define _GNU_SOURCE |
| 4 | +#include <pthread.h> |
| 5 | +#include <semaphore.h> |
| 6 | +#include <signal.h> |
| 7 | +#include <stdint.h> |
| 8 | +#include <stdio.h> |
| 9 | + |
| 10 | +// BDWGC also uses SIGRTMIN+6 on Linux, which seems like a reasonable choice. |
| 11 | +#ifdef __linux__ |
| 12 | +#define taskPauseSignal (SIGRTMIN + 6) |
| 13 | +#endif |
| 14 | + |
| 15 | +// Pointer to the current task.Task structure. |
| 16 | +// Ideally the entire task.Task structure would be a thread-local variable but |
| 17 | +// this also works. |
| 18 | +static __thread void *current_task; |
| 19 | + |
| 20 | +struct state_pass { |
| 21 | + void *(*start)(void*); |
| 22 | + void *args; |
| 23 | + void *task; |
| 24 | + sem_t startlock; |
| 25 | +}; |
| 26 | + |
| 27 | +// Handle the GC pause in Go. |
| 28 | +void tinygo_task_gc_pause(int sig); |
| 29 | + |
| 30 | +// Initialize the main thread. |
| 31 | +void tinygo_task_init(void *mainTask, pthread_t *thread, void *context) { |
| 32 | + // Make sure the current task pointer is set correctly for the main |
| 33 | + // goroutine as well. |
| 34 | + current_task = mainTask; |
| 35 | + |
| 36 | + // Store the thread ID of the main thread. |
| 37 | + *thread = pthread_self(); |
| 38 | + |
| 39 | + // Register the "GC pause" signal for the entire process. |
| 40 | + // Using pthread_kill, we can still send the signal to a specific thread. |
| 41 | + struct sigaction act = { 0 }; |
| 42 | + act.sa_flags = SA_SIGINFO; |
| 43 | + act.sa_handler = &tinygo_task_gc_pause; |
| 44 | + sigaction(taskPauseSignal, &act, NULL); |
| 45 | +} |
| 46 | + |
| 47 | +void tinygo_task_exited(void*); |
| 48 | + |
| 49 | +// Helper to start a goroutine while also storing the 'task' structure. |
| 50 | +static void* start_wrapper(void *arg) { |
| 51 | + struct state_pass *state = arg; |
| 52 | + void *(*start)(void*) = state->start; |
| 53 | + void *args = state->args; |
| 54 | + current_task = state->task; |
| 55 | + |
| 56 | + // Notify the caller that the thread has successfully started and |
| 57 | + // initialized. |
| 58 | + sem_post(&state->startlock); |
| 59 | + |
| 60 | + // Run the goroutine function. |
| 61 | + start(args); |
| 62 | + |
| 63 | + // Notify the Go side this thread will exit. |
| 64 | + tinygo_task_exited(current_task); |
| 65 | + |
| 66 | + return NULL; |
| 67 | +}; |
| 68 | + |
| 69 | +// Start a new goroutine in an OS thread. |
| 70 | +int tinygo_task_start(uintptr_t fn, void *args, void *task, pthread_t *thread, void *context) { |
| 71 | + // Sanity check. Should get optimized away. |
| 72 | + if (sizeof(pthread_t) != sizeof(void*)) { |
| 73 | + __builtin_trap(); |
| 74 | + } |
| 75 | + |
| 76 | + struct state_pass state = { |
| 77 | + .start = (void*)fn, |
| 78 | + .args = args, |
| 79 | + .task = task, |
| 80 | + }; |
| 81 | + sem_init(&state.startlock, 0, 0); |
| 82 | + int result = pthread_create(thread, NULL, &start_wrapper, &state); |
| 83 | + |
| 84 | + // Wait until the thread has been crated and read all state_pass variables. |
| 85 | + sem_wait(&state.startlock); |
| 86 | + |
| 87 | + return result; |
| 88 | +} |
| 89 | + |
| 90 | +// Return the current task (for task.Current()). |
| 91 | +void* tinygo_task_current(void) { |
| 92 | + return current_task; |
| 93 | +} |
| 94 | + |
| 95 | +// Obtain the highest address of the stack. |
| 96 | +uintptr_t tinygo_task_stacktop(void) { |
| 97 | + pthread_attr_t attr; |
| 98 | + pthread_getattr_np(pthread_self(), &attr); |
| 99 | + void *stackbase; |
| 100 | + size_t stacksize; |
| 101 | + pthread_attr_getstack(&attr, &stackbase, &stacksize); |
| 102 | + pthread_attr_destroy(&attr); |
| 103 | + return (uintptr_t)stackbase + (uintptr_t)stacksize; |
| 104 | +} |
| 105 | + |
| 106 | +// Send a signal to cause the task to pause for the GC mark phase. |
| 107 | +void tinygo_task_send_gc_signal(pthread_t thread) { |
| 108 | + pthread_kill(thread, taskPauseSignal); |
| 109 | +} |
0 commit comments