fiber_tests.h File Reference

#include <stdatomic.h>
#include <stdint.h>
#include <string.h>
#include "base.h"
#include "serene/rt/fiber.h"
#include "serene/rt/fiber/thread.h"
#include "serene/rt/mm/interface.h"

Include dependency graph for fiber_tests.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	spawn_copy_args_t
struct	fiber_mbox_t

Macros
#define	FIBER_TESTS(X)

Functions
static void	test_fiber_thread_stack_bounds ()
static srn_fiber_result_t	auto_name_entry (srn_context_t *ctx, void *arg)
static srn_fiber_result_t	auto_name_parent_entry (srn_context_t *ctx, void *arg)
static void	test_fiber_auto_name ()
static void	test_fiber_make_schedule ()
static srn_fiber_result_t	spawn_copy_entry (srn_context_t *ctx, void *arg)
static void	test_fiber_spawn_copy ()
static srn_fiber_result_t	auto_workers_entry (srn_context_t *ctx, void *arg)
static void	test_fiber_sched_auto_workers ()
static void	test_fiber_types ()
static void	test_fiber_stack ()
static void	fiber_pp_entry (void *arg)
static void	test_fiber_switch ()
static srn_fiber_result_t	fiber_run_entry (srn_context_t *ctx, void *arg)
static void	test_fiber_sched_run ()
static srn_fiber_result_t	fiber_yield_entry (srn_context_t *ctx, void *arg)
static void	test_fiber_sched_yield ()
static srn_fiber_result_t	fiber_rr_entry (srn_context_t *ctx, void *arg)
static void	test_fiber_sched_yield_round_robin ()
static bool	fiber_mbox_park (srn_fiber_t *self, void *arg)
static srn_fiber_result_t	fiber_consumer_entry (srn_context_t *ctx, void *arg)
static srn_fiber_result_t	fiber_producer_entry (srn_context_t *ctx, void *arg)
static void	test_fiber_sched_suspend ()
static void	test_fiber_sched_park_abort ()
static bool	fiber_stuck_park (srn_fiber_t *self, void *arg)
static srn_fiber_result_t	fiber_stuck_entry (srn_context_t *ctx, void *arg)
static void	test_fiber_sched_registry ()
static bool	fiber_dwake_park (srn_fiber_t *self, void *arg)
static srn_fiber_result_t	fiber_dwake_consumer_entry (srn_context_t *ctx, void *arg)
static srn_fiber_result_t	fiber_dwake_producer_entry (srn_context_t *ctx, void *arg)
static void	test_fiber_sched_double_wake ()
static srn_fiber_result_t	fiber_wf_target_entry (srn_context_t *ctx, void *arg)
static srn_fiber_result_t	fiber_wf_waiter_entry (srn_context_t *ctx, void *arg)
static void	test_fiber_sched_wait_for ()
static void	test_fiber_sched_wait_for_done ()
static srn_fiber_result_t	fiber_wf_counting_waiter (srn_context_t *ctx, void *arg)
static void	test_fiber_sched_wait_for_many ()
static srn_fiber_result_t	fiber_mt_entry (srn_context_t *ctx, void *arg)
static void	test_fiber_sched_mt_run ()
static srn_fiber_result_t	fiber_mt_yield_entry (srn_context_t *ctx, void *arg)
static void	test_fiber_sched_mt_yield ()
static srn_fiber_result_t	fiber_stopper_entry (srn_context_t *ctx, void *arg)
static srn_fiber_result_t	fiber_pending_entry (srn_context_t *ctx, void *arg)
static void	test_fiber_sched_stop ()

Variables
static srn_fiber_t *	auto_name_child
static int	spawn_copy_seen
static atomic_int	auto_workers_ran
static srn_fiber_t	fiber_pp_thread
static srn_fiber_t	fiber_pp_worker
static int	fiber_pp_ticks
static int	fiber_pp_rounds
static int	fiber_ok_value
static int	fiber_run_counter
static int	fiber_yield_log [4]
static int	fiber_yield_n
static int	fiber_rr_log [6]
static int	fiber_rr_n
static fiber_mbox_t	fiber_mbox
static int	fiber_mbox_got
static srn_fiber_t *	fiber_dwake_waiter
static bool	fiber_dwake_signalled
static int	fiber_dwake_runs
static int	fiber_wf_result
static srn_fiber_t *	fiber_wf_target
static srn_fiber_result_t	fiber_wf_seen
static int	fiber_wf_woke
static atomic_int	fiber_mt_counter
static atomic_int	fiber_mt_yield_counter
static atomic_int	fiber_stop_rounds

Macro Definition Documentation

FIBER_TESTS

#define FIBER_TESTS

(

X

)

Value:

X("fiber::types", test_fiber_types), X("fiber::switch", test_fiber_switch),                    \
  X("fiber::stack", test_fiber_stack),                                                         \
  X("fiber::thread_stack_bounds", test_fiber_thread_stack_bounds),                             \
  X("fiber::auto_name", test_fiber_auto_name),                                                 \
  X("fiber::make_schedule", test_fiber_make_schedule),                                         \
  X("fiber::sched::auto_workers", test_fiber_sched_auto_workers),                              \
  X("fiber::spawn_copy", test_fiber_spawn_copy), X("fiber::sched::run", test_fiber_sched_run), \
  X("fiber::sched::yield", test_fiber_sched_yield),                                            \
  X("fiber::sched::yield_round_robin", test_fiber_sched_yield_round_robin),                    \
  X("fiber::sched::suspend", test_fiber_sched_suspend),                                        \
  X("fiber::sched::park_abort", test_fiber_sched_park_abort),                                  \
  X("fiber::sched::registry", test_fiber_sched_registry),                                      \
  X("fiber::sched::double_wake", test_fiber_sched_double_wake),                                \
  X("fiber::sched::wait_for", test_fiber_sched_wait_for),                                      \
  X("fiber::sched::wait_for_done", test_fiber_sched_wait_for_done),                            \
  X("fiber::sched::wait_for_many", test_fiber_sched_wait_for_many),                            \
  X("fiber::sched::mt_run", test_fiber_sched_mt_run),                                          \
  X("fiber::sched::mt_yield", test_fiber_sched_mt_yield),                                      \
  X("fiber::sched::stop", test_fiber_sched_stop)

Definition at line 30 of file fiber_tests.h.

#define FIBER_TESTS(X)                                                                           \
  X("fiber::types", test_fiber_types), X("fiber::switch", test_fiber_switch),                    \
    X("fiber::stack", test_fiber_stack),                                                         \
    X("fiber::thread_stack_bounds", test_fiber_thread_stack_bounds),                             \
    X("fiber::auto_name", test_fiber_auto_name),                                                 \
    X("fiber::make_schedule", test_fiber_make_schedule),                                         \
    X("fiber::sched::auto_workers", test_fiber_sched_auto_workers),                              \
    X("fiber::spawn_copy", test_fiber_spawn_copy), X("fiber::sched::run", test_fiber_sched_run), \
    X("fiber::sched::yield", test_fiber_sched_yield),                                            \
    X("fiber::sched::yield_round_robin", test_fiber_sched_yield_round_robin),                    \
    X("fiber::sched::suspend", test_fiber_sched_suspend),                                        \
    X("fiber::sched::park_abort", test_fiber_sched_park_abort),                                  \
    X("fiber::sched::registry", test_fiber_sched_registry),                                      \
    X("fiber::sched::double_wake", test_fiber_sched_double_wake),                                \
    X("fiber::sched::wait_for", test_fiber_sched_wait_for),                                      \
    X("fiber::sched::wait_for_done", test_fiber_sched_wait_for_done),                            \
    X("fiber::sched::wait_for_many", test_fiber_sched_wait_for_many),                            \
    X("fiber::sched::mt_run", test_fiber_sched_mt_run),                                          \
    X("fiber::sched::mt_yield", test_fiber_sched_mt_yield),                                      \
    X("fiber::sched::stop", test_fiber_sched_stop)

Function Documentation

auto_name_entry()

srn_fiber_result_t auto_name_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 72 of file fiber_tests.h.

                                                                         {
  UNUSED(ctx);
  UNUSED(arg);
  return nullptr;
}

Here is the caller graph for this function:

auto_name_parent_entry()

srn_fiber_result_t auto_name_parent_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 80 of file fiber_tests.h.

                                                                                {
  UNUSED(arg);
  auto_name_child = srn_fiber_spawn(ctx, auto_name_entry, nullptr);
  return nullptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

auto_workers_entry()

srn_fiber_result_t auto_workers_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 180 of file fiber_tests.h.

                                                                            {
  UNUSED(ctx);
  UNUSED(arg);
  atomic_fetch_add(&auto_workers_ran, 1);
  return nullptr;
}

Here is the caller graph for this function:

fiber_consumer_entry()

srn_fiber_result_t fiber_consumer_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 449 of file fiber_tests.h.

                                                                              {
  UNUSED(ctx);
  UNUSED(arg);
  srn_fiber_suspend(fiber_mbox_park, &fiber_mbox);
  fiber_mbox_got = fiber_mbox.value;
  return &fiber_ok_value;
}

Here is the call graph for this function:

Here is the caller graph for this function:

fiber_dwake_consumer_entry()

srn_fiber_result_t fiber_dwake_consumer_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 572 of file fiber_tests.h.

                                                                                    {
  UNUSED(ctx);
  UNUSED(arg);
  srn_fiber_suspend(fiber_dwake_park, nullptr);
  fiber_dwake_runs++;
  return &fiber_ok_value;
}

Here is the call graph for this function:

Here is the caller graph for this function:

fiber_dwake_park()

bool fiber_dwake_park ( srn_fiber_t * self, void * arg )

static

Definition at line 563 of file fiber_tests.h.

                                                           {
  UNUSED(arg);
  if (fiber_dwake_signalled) {
    return false;
  }
  fiber_dwake_waiter = self;
  return true;
}

Here is the caller graph for this function:

fiber_dwake_producer_entry()

srn_fiber_result_t fiber_dwake_producer_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 580 of file fiber_tests.h.

                                                                                    {
  UNUSED(ctx);
  UNUSED(arg);
  fiber_dwake_signalled = true;
  if (fiber_dwake_waiter != nullptr) {
    srn_fiber_t *w     = fiber_dwake_waiter;
    fiber_dwake_waiter = nullptr;
    srn_fiber_ready(w); // first waker: SUSPENDED -> READY, enqueued
    srn_fiber_ready(w); // second waker: already READY -> no-op
  }
  return &fiber_ok_value;
}

Here is the call graph for this function:

Here is the caller graph for this function:

fiber_mbox_park()

bool fiber_mbox_park ( srn_fiber_t * self, void * arg )

static

Definition at line 440 of file fiber_tests.h.

                                                          {
  fiber_mbox_t *mb = arg;
  if (mb->has_value) {
    return false;
  }
  mb->waiter = self;
  return true;
}

Here is the caller graph for this function:

fiber_mt_entry()

srn_fiber_result_t fiber_mt_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 716 of file fiber_tests.h.

                                                                        {
  UNUSED(ctx);
  UNUSED(arg);
  atomic_fetch_add(&fiber_mt_counter, 1);
  return &fiber_ok_value;
}

Here is the caller graph for this function:

fiber_mt_yield_entry()

srn_fiber_result_t fiber_mt_yield_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 749 of file fiber_tests.h.

                                                                              {
  UNUSED(ctx);
  int rounds = (int)(intptr_t)arg;
  for (int i = 0; i < rounds; i++) {
    atomic_fetch_add(&fiber_mt_yield_counter, 1);
    srn_fiber_yield();
  }
  return &fiber_ok_value;
}

Here is the call graph for this function:

Here is the caller graph for this function:

fiber_pending_entry()

srn_fiber_result_t fiber_pending_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 799 of file fiber_tests.h.

                                                                             {
  UNUSED(ctx);
  UNUSED(arg);
  // Never reached, the stopper ends the run first. It adds a large amount, so
  // any accidental execution is visible in the count.
  atomic_fetch_add(&fiber_stop_rounds, 1000);
  return &fiber_ok_value;
}

Here is the caller graph for this function:

fiber_pp_entry()

void fiber_pp_entry ( void * arg )

static

Definition at line 257 of file fiber_tests.h.

                                      {
  UNUSED(arg);
  srn_fiber_on_entry(&fiber_pp_thread);
  for (int i = 0; i < fiber_pp_rounds; i++) {
    fiber_pp_ticks++;
    srn_fiber_switch(&fiber_pp_worker, &fiber_pp_thread);
  }
  srn_fiber_switch_final(&fiber_pp_thread);
}

Here is the call graph for this function:

Here is the caller graph for this function:

fiber_producer_entry()

srn_fiber_result_t fiber_producer_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 457 of file fiber_tests.h.

                                                                              {
  UNUSED(ctx);
  UNUSED(arg);
  fiber_mbox.value     = 42;
  fiber_mbox.has_value = true;
  if (fiber_mbox.waiter != nullptr) {
    srn_fiber_t *w    = fiber_mbox.waiter;
    fiber_mbox.waiter = nullptr;
    srn_fiber_ready(w);
  }
  return &fiber_ok_value;
}

Here is the call graph for this function:

Here is the caller graph for this function:

fiber_rr_entry()

srn_fiber_result_t fiber_rr_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 387 of file fiber_tests.h.

                                                                        {
  UNUSED(ctx);
  int id = (int)(intptr_t)arg;
  for (int i = 0; i < 3; i++) {
    if (fiber_rr_n < 6) {
      fiber_rr_log[fiber_rr_n++] = id;
    }
    srn_fiber_yield();
  }
  return &fiber_ok_value;
}

Here is the call graph for this function:

Here is the caller graph for this function:

fiber_run_entry()

srn_fiber_result_t fiber_run_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 300 of file fiber_tests.h.

                                                                         {
  UNUSED(ctx);
  UNUSED(arg);
  fiber_run_counter++;
  return &fiber_ok_value;
}

Here is the caller graph for this function:

fiber_stopper_entry()

srn_fiber_result_t fiber_stopper_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 787 of file fiber_tests.h.

                                                                             {
  UNUSED(ctx);
  srn_scheduler_t *sched = arg;
  // No yield in this loop, a yielded fiber goes to the back of the queue, so
  // yielding would hand the pending fibers a turn before the stop lands.
  for (int i = 0; i < 3; i++) {
    atomic_fetch_add(&fiber_stop_rounds, 1);
  }
  srn_sched_stop(sched);
  return &fiber_ok_value;
}

Here is the call graph for this function:

Here is the caller graph for this function:

fiber_stuck_entry()

srn_fiber_result_t fiber_stuck_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 528 of file fiber_tests.h.

                                                                           {
  UNUSED(ctx);
  UNUSED(arg);
  srn_fiber_suspend(fiber_stuck_park, nullptr); // never readied
  return &fiber_ok_value;
}

Here is the call graph for this function:

Here is the caller graph for this function:

fiber_stuck_park()

bool fiber_stuck_park ( srn_fiber_t * self, void * arg )

static

Definition at line 522 of file fiber_tests.h.

                                                           {
  UNUSED(self);
  UNUSED(arg);
  return true; // stay parked, with no waker
}

Here is the caller graph for this function:

fiber_wf_counting_waiter()

srn_fiber_result_t fiber_wf_counting_waiter ( srn_context_t * ctx, void * arg )

static

Definition at line 679 of file fiber_tests.h.

                                                                                  {
  UNUSED(ctx);
  UNUSED(arg);
  if (srn_fiber_wait_for(fiber_wf_target) == &fiber_wf_result) {
    fiber_wf_woke++;
  }
  return &fiber_ok_value;
}

Here is the call graph for this function:

Here is the caller graph for this function:

fiber_wf_target_entry()

srn_fiber_result_t fiber_wf_target_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 622 of file fiber_tests.h.

                                                                               {
  UNUSED(ctx);
  UNUSED(arg);
  return &fiber_wf_result;
}

Here is the caller graph for this function:

fiber_wf_waiter_entry()

srn_fiber_result_t fiber_wf_waiter_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 628 of file fiber_tests.h.

                                                                               {
  UNUSED(ctx);
  UNUSED(arg);
  fiber_wf_seen = srn_fiber_wait_for(fiber_wf_target);
  return &fiber_ok_value;
}

Here is the call graph for this function:

Here is the caller graph for this function:

fiber_yield_entry()

srn_fiber_result_t fiber_yield_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 342 of file fiber_tests.h.

                                                                           {
  UNUSED(ctx);
  int id = (int)(intptr_t)arg;
  for (int i = 0; i < 2; i++) {
    fiber_yield_log[fiber_yield_n++] = id;
    srn_fiber_yield();
  }
  return &fiber_ok_value;
}

Here is the call graph for this function:

Here is the caller graph for this function:

spawn_copy_entry()

srn_fiber_result_t spawn_copy_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 151 of file fiber_tests.h.

                                                                          {
  UNUSED(ctx);
  spawn_copy_seen = ((spawn_copy_args_t *)arg)->value;
  return nullptr;
}

Here is the caller graph for this function:

test_fiber_auto_name()

void test_fiber_auto_name ( )

static

Definition at line 90 of file fiber_tests.h.

                                   {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
  srn_scheduler_t *sched = engine->scheduler;
 
  srn_fiber_t *a  = srn_fiber_spawn(ctx, auto_name_entry, nullptr);
  srn_fiber_t *b  = srn_fiber_spawn(ctx, auto_name_entry, nullptr);
  auto_name_child = nullptr;
  (void)srn_fiber_spawn(ctx, auto_name_parent_entry, nullptr);
 
  // Made off the pool, the creator tag is `m`.
  TEST_CHECK(strncmp(a->name, "f#m:", 4) == 0);
  TEST_CHECK(strncmp(b->name, "f#m:", 4) == 0);
  TEST_CHECK(strcmp(a->name, b->name) != 0);
 
  // Run the fibers so the registry is empty before the context goes away.
  srn_sched_run(sched, 1);
 
  // The child was made by the parent running on the single worker, id 0,
  // and it is that worker's first spawn.
  TEST_ASSERT(auto_name_child != nullptr);
  TEST_CHECK(strcmp(auto_name_child->name, "f#0:1") == 0);
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}

Here is the call graph for this function:

test_fiber_make_schedule()

void test_fiber_make_schedule ( )

static

Definition at line 120 of file fiber_tests.h.

                                       {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
  srn_scheduler_t *sched = engine->scheduler;
 
  srn_fiber_t *stay = srn_fiber_make(ctx, sched, "left-new", auto_name_entry, nullptr, 0);
  srn_fiber_t *go   = srn_fiber_make(ctx, sched, "scheduled", auto_name_entry, nullptr, 0);
 
  TEST_CHECK(stay->state == SRN_FIBER_NEW);
  TEST_CHECK(strcmp(go->name, "scheduled") == 0);
  TEST_CHECK(strcmp(stay->name, "left-new") == 0);
 
  srn_fiber_schedule(go);
  srn_sched_run(sched, 1);
 
  TEST_CHECK(go->state == SRN_FIBER_DONE);
  TEST_CHECK(stay->state == SRN_FIBER_NEW);
 
  // Reap the never scheduled fiber while its struct (in the context block)
  // is still alive, before releasing the context.
  srn_sched_shutdown(sched);
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}

Here is the call graph for this function:

test_fiber_sched_auto_workers()

void test_fiber_sched_auto_workers ( )

static

Definition at line 190 of file fiber_tests.h.

                                            {
  TEST_CHECK(srn_thread_cpu_count() >= 1);
 
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
  srn_scheduler_t *sched = engine->scheduler;
 
  atomic_store(&auto_workers_ran, 0);
  for (int i = 0; i < 32; i++) {
    (void)srn_fiber_spawn(ctx, auto_workers_entry, nullptr);
  }
 
  srn_sched_run(sched, 0);
  TEST_CHECK(atomic_load(&auto_workers_ran) == 32);
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}

Here is the call graph for this function:

test_fiber_sched_double_wake()

void test_fiber_sched_double_wake ( )

static

Definition at line 593 of file fiber_tests.h.

                                           {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
  srn_scheduler_t *sched = engine->scheduler;
  ASSERT_NOT_NULL(sched);
 
  fiber_dwake_waiter    = nullptr;
  fiber_dwake_signalled = false;
  fiber_dwake_runs      = 0;
 
  // Consumer first, so it runs and suspends before the producer wakes it.
  (void)srn_fiber_spawn(ctx, fiber_dwake_consumer_entry, nullptr);
  (void)srn_fiber_spawn(ctx, fiber_dwake_producer_entry, nullptr);
 
  srn_sched_run(sched, 1);
 
  TEST_CHECK(fiber_dwake_runs == 1);
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}

Here is the call graph for this function:

test_fiber_sched_mt_run()

void test_fiber_sched_mt_run ( )

static

Definition at line 723 of file fiber_tests.h.

                                      {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
  srn_scheduler_t *sched = engine->scheduler;
  ASSERT_NOT_NULL(sched);
 
  atomic_store(&fiber_mt_counter, 0);
  enum { N = 256 };
  for (int i = 0; i < N; i++) {
    (void)srn_fiber_spawn(ctx, fiber_mt_entry, nullptr);
  }
 
  srn_sched_run(sched, 4);
 
  TEST_CHECK(atomic_load(&fiber_mt_counter) == N);
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}

Here is the call graph for this function:

test_fiber_sched_mt_yield()

void test_fiber_sched_mt_yield ( )

static

Definition at line 759 of file fiber_tests.h.

                                        {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
  srn_scheduler_t *sched = engine->scheduler;
  ASSERT_NOT_NULL(sched);
 
  atomic_store(&fiber_mt_yield_counter, 0);
  enum { N = 64, ROUNDS = 8 };
  for (int i = 0; i < N; i++) {
    (void)srn_fiber_spawn(ctx, fiber_mt_yield_entry, (void *)(intptr_t)ROUNDS);
  }
 
  srn_sched_run(sched, 4);
 
  TEST_CHECK(atomic_load(&fiber_mt_yield_counter) == N * ROUNDS);
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}

Here is the call graph for this function:

test_fiber_sched_park_abort()

void test_fiber_sched_park_abort ( )

static

Definition at line 495 of file fiber_tests.h.

                                          {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
  srn_scheduler_t *sched = engine->scheduler;
  ASSERT_NOT_NULL(sched);
 
  fiber_mbox           = (fiber_mbox_t){0};
  fiber_mbox.value     = 7;
  fiber_mbox.has_value = true; // value present before the consumer runs
  fiber_mbox_got       = 0;
 
  (void)srn_fiber_spawn(ctx, fiber_consumer_entry, nullptr);
 
  srn_sched_run(sched, 1);
 
  TEST_CHECK(fiber_mbox_got == 7);
  TEST_CHECK(fiber_mbox.waiter == nullptr); // never registered as a waiter
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}

Here is the call graph for this function:

test_fiber_sched_registry()

void test_fiber_sched_registry ( )

static

Definition at line 535 of file fiber_tests.h.

                                        {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
  srn_scheduler_t *sched = engine->scheduler;
  ASSERT_NOT_NULL(sched);
 
  srn_fiber_t *stuck = srn_fiber_spawn(ctx, fiber_stuck_entry, nullptr);
  ASSERT_NOT_NULL(stuck);
 
  // Drains the ready queue. The stuck fiber suspends and is abandoned.
  srn_sched_run(sched, 1);
  TEST_CHECK(stuck->state == SRN_FIBER_SUSPENDED);
 
  // The registry lets shutdown find and free the abandoned fiber's stack.
  srn_sched_shutdown(sched);
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}

Here is the call graph for this function:

test_fiber_sched_run()

void test_fiber_sched_run ( )

static

Definition at line 307 of file fiber_tests.h.

                                   {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
  srn_scheduler_t *sched = engine->scheduler;
  ASSERT_NOT_NULL(sched);
 
  fiber_run_counter = 0;
  enum { N = 4 };
  srn_fiber_t *fibers[N];
  for (int i = 0; i < N; i++) {
    fibers[i] = srn_fiber_spawn(ctx, fiber_run_entry, nullptr);
    ASSERT_NOT_NULL(fibers[i]);
  }
 
  srn_sched_run(sched, 1);
 
  TEST_CHECK(fiber_run_counter == N);
  for (int i = 0; i < N; i++) {
    // The struct lives in the context block after reaping. Only the stack is
    // released, so state and result are still readable here.
    TEST_CHECK(fibers[i]->state == SRN_FIBER_DONE);
    TEST_CHECK(fibers[i]->result == &fiber_ok_value);
  }
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}

Here is the call graph for this function:

test_fiber_sched_stop()

void test_fiber_sched_stop ( )

static

Definition at line 808 of file fiber_tests.h.

                                    {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
  srn_scheduler_t *sched = engine->scheduler;
  ASSERT_NOT_NULL(sched);
 
  atomic_store(&fiber_stop_rounds, 0);
  // Stopper first so it reaches the single worker before the pending fibers.
  (void)srn_fiber_spawn(ctx, fiber_stopper_entry, sched);
  enum { PENDING = 3 };
  for (int i = 0; i < PENDING; i++) {
    (void)srn_fiber_spawn(ctx, fiber_pending_entry, nullptr);
  }
 
  // Returns when the stopper calls srn_sched_stop, with the pending fibers
  // still queued.
  srn_sched_run(sched, 1);
 
  // Only the stopper ran (three rounds); no pending fiber ran.
  TEST_CHECK(atomic_load(&fiber_stop_rounds) == 3);
 
  // Reap the pending fibers while their structs (in the context block) are
  // still alive, before releasing the context. SHUTDOWN_ENGINE calls shutdown
  // again, which is a no-op on an already torn-down scheduler.
  srn_sched_shutdown(sched);
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}

Here is the call graph for this function:

test_fiber_sched_suspend()

void test_fiber_sched_suspend ( )

static

Definition at line 470 of file fiber_tests.h.

                                       {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
  srn_scheduler_t *sched = engine->scheduler;
  ASSERT_NOT_NULL(sched);
 
  fiber_mbox     = (fiber_mbox_t){0};
  fiber_mbox_got = 0;
 
  // Order matters, the consumer must be enqueued first so it runs and suspends
  // before the producer fills the slot.
  (void)srn_fiber_spawn(ctx, fiber_consumer_entry, nullptr);
  (void)srn_fiber_spawn(ctx, fiber_producer_entry, nullptr);
 
  srn_sched_run(sched, 1);
 
  TEST_CHECK(fiber_mbox_got == 42);
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}

Here is the call graph for this function:

test_fiber_sched_wait_for()

void test_fiber_sched_wait_for ( )

static

Definition at line 635 of file fiber_tests.h.

                                        {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
  srn_scheduler_t *sched = engine->scheduler;
  ASSERT_NOT_NULL(sched);
 
  fiber_wf_seen = nullptr;
  // Waiter made first, so it runs and parks before the target finishes.
  (void)srn_fiber_spawn(ctx, fiber_wf_waiter_entry, nullptr);
  fiber_wf_target = srn_fiber_spawn(ctx, fiber_wf_target_entry, nullptr);
 
  srn_sched_run(sched, 1);
 
  TEST_CHECK(fiber_wf_seen == &fiber_wf_result);
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}

Here is the call graph for this function:

test_fiber_sched_wait_for_done()

void test_fiber_sched_wait_for_done ( )

static

Definition at line 656 of file fiber_tests.h.

                                             {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
  srn_scheduler_t *sched = engine->scheduler;
  ASSERT_NOT_NULL(sched);
 
  fiber_wf_seen = nullptr;
  // Target made first, so it runs and finishes before the waiter runs.
  fiber_wf_target = srn_fiber_spawn(ctx, fiber_wf_target_entry, nullptr);
  (void)srn_fiber_spawn(ctx, fiber_wf_waiter_entry, nullptr);
 
  srn_sched_run(sched, 1);
 
  TEST_CHECK(fiber_wf_seen == &fiber_wf_result);
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}

Here is the call graph for this function:

test_fiber_sched_wait_for_many()

void test_fiber_sched_wait_for_many ( )

static

Definition at line 688 of file fiber_tests.h.

                                             {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
  srn_scheduler_t *sched = engine->scheduler;
  ASSERT_NOT_NULL(sched);
 
  fiber_wf_woke = 0;
  // Three waiters made first so they all park, then the target finishes.
  (void)srn_fiber_spawn(ctx, fiber_wf_counting_waiter, nullptr);
  (void)srn_fiber_spawn(ctx, fiber_wf_counting_waiter, nullptr);
  (void)srn_fiber_spawn(ctx, fiber_wf_counting_waiter, nullptr);
  fiber_wf_target = srn_fiber_spawn(ctx, fiber_wf_target_entry, nullptr);
 
  srn_sched_run(sched, 1);
 
  TEST_CHECK(fiber_wf_woke == 3);
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}

Here is the call graph for this function:

test_fiber_sched_yield()

void test_fiber_sched_yield ( )

static

Definition at line 352 of file fiber_tests.h.

                                     {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
  srn_scheduler_t *sched = engine->scheduler;
  ASSERT_NOT_NULL(sched);
 
  fiber_yield_n = 0;
  (void)srn_fiber_spawn(ctx, fiber_yield_entry, (void *)(intptr_t)1);
  (void)srn_fiber_spawn(ctx, fiber_yield_entry, (void *)(intptr_t)2);
 
  srn_sched_run(sched, 1);
 
  TEST_CHECK(fiber_yield_n == 4);
  int ones = 0;
  int twos = 0;
  for (int i = 0; i < 4; i++) {
    if (fiber_yield_log[i] == 1) {
      ones++;
    } else if (fiber_yield_log[i] == 2) {
      twos++;
    }
  }
  TEST_CHECK(ones == 2);
  TEST_CHECK(twos == 2);
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}

Here is the call graph for this function:

test_fiber_sched_yield_round_robin()

void test_fiber_sched_yield_round_robin ( )

static

Definition at line 399 of file fiber_tests.h.

                                                 {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
  srn_scheduler_t *sched = engine->scheduler;
  ASSERT_NOT_NULL(sched);
 
  fiber_rr_n = 0;
  (void)srn_fiber_spawn(ctx, fiber_rr_entry, (void *)(intptr_t)1);
  (void)srn_fiber_spawn(ctx, fiber_rr_entry, (void *)(intptr_t)2);
 
  srn_sched_run(sched, 1);
 
  TEST_CHECK(fiber_rr_n == 6);
  // Strict alternation, a yielding fiber never runs two steps back to back
  // while a peer is ready.
  for (int i = 1; i < 6; i++) {
    TEST_CHECK(fiber_rr_log[i] != fiber_rr_log[i - 1]);
    TEST_MSG(
      "order: %d %d %d %d %d %d", fiber_rr_log[0], fiber_rr_log[1], fiber_rr_log[2],
      fiber_rr_log[3], fiber_rr_log[4], fiber_rr_log[5]
    );
  }
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}

Here is the call graph for this function:

test_fiber_spawn_copy()

void test_fiber_spawn_copy ( )

static

Definition at line 160 of file fiber_tests.h.

                                    {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
  srn_scheduler_t *sched = engine->scheduler;
 
  spawn_copy_seen = 0;
  {
    spawn_copy_args_t args = {.value = 4242};
    (void)SRN_FIBER_SPAWN_COPY(ctx, spawn_copy_entry, args);
  }
 
  srn_sched_run(sched, 1);
  TEST_CHECK(spawn_copy_seen == 4242);
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}

Here is the call graph for this function:

test_fiber_stack()

void test_fiber_stack ( )

static

Definition at line 224 of file fiber_tests.h.

                               {
  size_t page        = srn_mm_get_os_page_size();
  size_t guard_pages = 4;
 
  srn_fiber_stack_t s = srn_fiber_stack_alloc(0, guard_pages);
 
  TEST_CHECK(s.guard != nullptr);
  TEST_CHECK(s.limit != nullptr);
  TEST_CHECK(s.start != nullptr);
  // The guard band spans the requested number of pages below the usable region.
  TEST_CHECK((char *)s.limit == (char *)s.guard + guard_pages * page);
  // The usable region is non-empty, page-aligned, and at least the default.
  TEST_CHECK((char *)s.start > (char *)s.limit);
  TEST_CHECK(((uintptr_t)s.limit & (page - 1)) == 0);
  TEST_CHECK(srn_fiber_stack_size(s) >= SRN_CONFIG_DEFAULT_FIBER_STACK_SIZE);
 
  // The whole usable region is writable end to end. The guard is left alone.
  ((char *)s.limit)[0]  = (char)0x5A;
  ((char *)s.start)[-1] = (char)0x5A;
 
  srn_fiber_stack_free(s);
}

Here is the call graph for this function:

test_fiber_switch()

void test_fiber_switch ( )

static

Definition at line 267 of file fiber_tests.h.

                                {
  srn_fiber_init_thread(&fiber_pp_thread);
 
  srn_fiber_stack_t worker_stack = srn_fiber_stack_alloc(0, SRN_CONFIG_DEFAULT_FIBER_GUARD_PAGES);
 
  fiber_pp_worker       = (srn_fiber_t){};
  fiber_pp_worker.stack = worker_stack;
  fiber_pp_worker.state = SRN_FIBER_NEW;
  srn_fiber_ctx_make(&fiber_pp_worker.fiber_ctx, worker_stack, fiber_pp_entry, nullptr);
 
  fiber_pp_ticks  = 0;
  fiber_pp_rounds = 5;
 
  // `rounds` yields, plus one more switch to let the worker run to completion.
  for (int i = 0; i <= fiber_pp_rounds; i++) {
    srn_fiber_switch(&fiber_pp_thread, &fiber_pp_worker);
  }
 
  TEST_CHECK(fiber_pp_ticks == fiber_pp_rounds);
  TEST_CHECK(fiber_pp_thread.state == SRN_FIBER_RUNNING);
 
  srn_fiber_stack_free(worker_stack);
}

Here is the call graph for this function:

test_fiber_thread_stack_bounds()

void test_fiber_thread_stack_bounds ( )

static

Definition at line 56 of file fiber_tests.h.

                                             {
  srn_fiber_t loop;
  srn_fiber_init_thread(&loop);
  TEST_CHECK(loop.state == SRN_FIBER_RUNNING);
#if SRN_ASAN
  TEST_CHECK(loop.stack.limit != nullptr);
  TEST_CHECK(loop.stack.start != nullptr);
  // A local's address cannot anchor the check, ASan's fake stack moves
  // address taken locals off the real thread stack. Sanity of the reported
  // range is what is checkable, ordered bounds spanning at least one page.
  TEST_CHECK(srn_fiber_stack_size(loop.stack) >= srn_mm_get_os_page_size());
#else
  TEST_CHECK(loop.stack.limit == nullptr);
#endif
}

Here is the call graph for this function:

test_fiber_types()

void test_fiber_types ( )

static

Definition at line 209 of file fiber_tests.h.

                               {
  // Smoke test, the public types exist and the build/test wiring works.
  // The saved context is a single stack-pointer word.
  TEST_CHECK(sizeof(srn_fiber_ctx_t) == sizeof(void *));
  // The lifecycle states run from creation to completion in order.
  TEST_CHECK(SRN_FIBER_NEW == 0);
  TEST_CHECK(SRN_FIBER_NEW < SRN_FIBER_READY);
  TEST_CHECK(SRN_FIBER_READY < SRN_FIBER_RUNNING);
  TEST_CHECK(SRN_FIBER_RUNNING < SRN_FIBER_SUSPENDED);
  TEST_CHECK(SRN_FIBER_SUSPENDED < SRN_FIBER_DONE);
}

Variable Documentation

auto_name_child

srn_fiber_t* auto_name_child

static

Definition at line 78 of file fiber_tests.h.

auto_workers_ran

atomic_int auto_workers_ran

static

Definition at line 178 of file fiber_tests.h.

fiber_dwake_runs

int fiber_dwake_runs

static

Definition at line 561 of file fiber_tests.h.

fiber_dwake_signalled

bool fiber_dwake_signalled

static

Definition at line 560 of file fiber_tests.h.

fiber_dwake_waiter

srn_fiber_t* fiber_dwake_waiter

static

Definition at line 559 of file fiber_tests.h.

fiber_mbox

fiber_mbox_t fiber_mbox

static

Definition at line 435 of file fiber_tests.h.

fiber_mbox_got

int fiber_mbox_got

static

Definition at line 436 of file fiber_tests.h.

fiber_mt_counter

atomic_int fiber_mt_counter

static

Definition at line 714 of file fiber_tests.h.

fiber_mt_yield_counter

atomic_int fiber_mt_yield_counter

static

Definition at line 747 of file fiber_tests.h.

fiber_ok_value

int fiber_ok_value

static

Definition at line 293 of file fiber_tests.h.

fiber_pp_rounds

int fiber_pp_rounds

static

Definition at line 255 of file fiber_tests.h.

fiber_pp_thread

srn_fiber_t fiber_pp_thread

static

Definition at line 252 of file fiber_tests.h.

fiber_pp_ticks

int fiber_pp_ticks

static

Definition at line 254 of file fiber_tests.h.

fiber_pp_worker

srn_fiber_t fiber_pp_worker

static

Definition at line 253 of file fiber_tests.h.

fiber_rr_log

int fiber_rr_log[6]

static

Definition at line 384 of file fiber_tests.h.

fiber_rr_n

int fiber_rr_n

static

Definition at line 385 of file fiber_tests.h.

fiber_run_counter

int fiber_run_counter

static

Definition at line 298 of file fiber_tests.h.

fiber_stop_rounds

atomic_int fiber_stop_rounds

static

Definition at line 785 of file fiber_tests.h.

fiber_wf_result

int fiber_wf_result

static

Definition at line 618 of file fiber_tests.h.

fiber_wf_seen

srn_fiber_result_t fiber_wf_seen

static

Definition at line 620 of file fiber_tests.h.

fiber_wf_target

srn_fiber_t* fiber_wf_target

static

Definition at line 619 of file fiber_tests.h.

fiber_wf_woke

int fiber_wf_woke

static

Definition at line 677 of file fiber_tests.h.

fiber_yield_log

int fiber_yield_log[4]

static

Definition at line 339 of file fiber_tests.h.

fiber_yield_n

int fiber_yield_n

static

Definition at line 340 of file fiber_tests.h.

spawn_copy_seen

int spawn_copy_seen

static

Definition at line 149 of file fiber_tests.h.