test/pthread/test_pthread_c11_threads.c

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <threads.h>

tss_t key;
cnd_t cond;
mtx_t mutex;
once_flag flag = ONCE_FLAG_INIT;

_Atomic int thread_counter = 0;
_Atomic int once_counter = 0;
_Atomic int destructor_counter = 0;

void do_once(void) {
  once_counter++;
  printf("in do_once\n");
}

// Because this thread is detached it can still be running
// when the main thread exits.  And because of an emscripten
// bug (https://github.com/emscripten-core/emscripten/issues/15186).
// this means we can't write to stdout after the main thread
// exits.  This means we can't use `thread_main` below because
// the destructor to the `tss_t key` writes to stdout.
int thread_main_detached(void* arg) {
  printf("in thread_main_detached %p\n", (void*)thrd_current());
  mtx_lock(&mutex);
  thread_counter--;
  cnd_signal(&cond);
  mtx_unlock(&mutex);
  return 0;
}

int thread_main(void* arg) {
  printf("in thread_main %p\n", (void*)thrd_current());
  tss_set(key, (void*)thrd_current());
  call_once(&flag, do_once);
  mtx_lock(&mutex);
  thread_counter--;
  cnd_signal(&cond);
  mtx_unlock(&mutex);
  return 42;
}

int run_with_exit(void* arg) {
  thrd_yield();
  thrd_exit(43);
}

void destructor(void* val) {
  printf("destructor: %p\n", (void*)thrd_current());
  assert(val == (void*)thrd_current());
  destructor_counter++;
}

int main(int argc, char* argv[]) {
  int result = 0;
  printf("thrd_current: %p\n", (void*)thrd_current());

  assert(tss_create(&key, destructor) == thrd_success);

  // Test call_once
  thrd_t t1;
  thrd_t t2;
  thrd_t t3;
  thrd_t t4;

  assert(cnd_init(&cond) == thrd_success);
  assert(mtx_init(&mutex, mtx_plain) == thrd_success);
  assert(mtx_lock(&mutex) == thrd_success);

  assert(thrd_create(&t1, thread_main, NULL) == thrd_success);
  thread_counter++;
  assert(thrd_create(&t2, thread_main, NULL) == thrd_success);
  thread_counter++;
  assert(thrd_create(&t3, thread_main, NULL) == thrd_success);
  thread_counter++;
  assert(thrd_create(&t4, thread_main, NULL) == thrd_success);
  thread_counter++;

  assert(!thrd_equal(t1, t2));
  assert(thrd_equal(t1, t1));

  while (thread_counter)
    assert(cnd_wait(&cond, &mutex) == thrd_success);

  assert(thrd_join(t1, &result) == thrd_success);
  printf("t1 joined\n");
  assert(thrd_join(t2, &result) == thrd_success);
  printf("t2 joined\n");
  assert(thrd_join(t3, &result) == thrd_success);
  printf("t3 joined\n");
  assert(thrd_join(t4, &result) == thrd_success);
  printf("t4 joined\n");
  assert(result == 42);
  assert(once_counter == 1);

  assert(destructor_counter == 4);

  // Test thrd_exit return value
  thrd_t t5;
  assert(thrd_create(&t5, run_with_exit, NULL) == thrd_success);
  assert(thrd_join(t5, &result) == thrd_success);
  assert(result == 43);

  // Test thrd_detach
  thrd_t t6;
  assert(thrd_create(&t6, thread_main_detached, NULL) == thrd_success);
  assert(thrd_detach(t6) == thrd_success);

  // Wait for the thread to at least be done printing before exiting
  // the process.
  // We shouldn't need to do this but there is a bug in emscripten
  // where a deadlock can occur between main thread calling fflush()
  // during exitRuntime and the detached thread calling print (and
  // therefore holding the stdout lock).
  // See https://github.com/emscripten-core/emscripten/issues/15186.
  assert(cnd_wait(&cond, &mutex) == thrd_success);

  printf("done!\n");
  return 0;
}