fiber_tests.h File Reference

#include <stdatomic.h>
#include <stdint.h>
#include "base.h"
#include "serene/rt/fiber.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	fiber_mbox_t

Macros
#define	FIBER_TESTS(X)

Functions
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 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	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 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::sched::run", test_fiber_sched_run),                           \
      X("fiber::sched::yield", test_fiber_sched_yield),                       \
      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 27 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::sched::run", test_fiber_sched_run),                           \
      X("fiber::sched::yield", test_fiber_sched_yield),                       \
      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

fiber_consumer_entry()

static srn_fiber_result_t fiber_consumer_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 238 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()

static srn_fiber_result_t fiber_dwake_consumer_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 362 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()

static bool fiber_dwake_park ( srn_fiber_t * self, void * arg )

static

Definition at line 353 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()

static srn_fiber_result_t fiber_dwake_producer_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 371 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()

static bool fiber_mbox_park ( srn_fiber_t * self, void * arg )

static

Definition at line 229 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()

static srn_fiber_result_t fiber_mt_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 512 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()

static srn_fiber_result_t fiber_mt_yield_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 545 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()

static srn_fiber_result_t fiber_pending_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 595 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()

static void fiber_pp_entry ( void * arg )

static

Definition at line 90 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()

static srn_fiber_result_t fiber_producer_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 246 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_run_entry()

static srn_fiber_result_t fiber_run_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 134 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()

static srn_fiber_result_t fiber_stopper_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 584 of file fiber_tests.h.

                                                                             {
  UNUSED(ctx);
  srn_scheduler_t *sched = arg;
  for (int i = 0; i < 3; i++) {
    atomic_fetch_add(&fiber_stop_rounds, 1);
    srn_fiber_yield();
  }
  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()

static srn_fiber_result_t fiber_stuck_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 317 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()

static bool fiber_stuck_park ( srn_fiber_t * self, void * arg )

static

Definition at line 311 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()

static srn_fiber_result_t fiber_wf_counting_waiter ( srn_context_t * ctx, void * arg )

static

Definition at line 473 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()

static srn_fiber_result_t fiber_wf_target_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 414 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()

static srn_fiber_result_t fiber_wf_waiter_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 420 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()

static srn_fiber_result_t fiber_yield_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 176 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:

test_fiber_sched_double_wake()

static void test_fiber_sched_double_wake ( )

static

Definition at line 385 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_make(ctx, sched, fiber_dwake_consumer_entry, nullptr, 0);
  (void)srn_fiber_make(ctx, sched, fiber_dwake_producer_entry, nullptr, 0);
 
  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()

static void test_fiber_sched_mt_run ( )

static

Definition at line 519 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_make(ctx, sched, fiber_mt_entry, nullptr, 0);
  }
 
  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()

static void test_fiber_sched_mt_yield ( )

static

Definition at line 555 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_make(ctx, sched, fiber_mt_yield_entry,
                         (void *)(intptr_t)ROUNDS, 0);
  }
 
  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()

static void test_fiber_sched_park_abort ( )

static

Definition at line 284 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_make(ctx, sched, fiber_consumer_entry, nullptr, 0);
 
  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()

static void test_fiber_sched_registry ( )

static

Definition at line 324 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_make(ctx, sched, fiber_stuck_entry, nullptr, 0);
  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()

static void test_fiber_sched_run ( )

static

Definition at line 141 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_make(ctx, sched, fiber_run_entry, nullptr, 0);
    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()

static void test_fiber_sched_stop ( )

static

Definition at line 604 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_make(ctx, sched, fiber_stopper_entry, sched, 0);
  enum { PENDING = 3 };
  for (int i = 0; i < PENDING; i++) {
    (void)srn_fiber_make(ctx, sched, fiber_pending_entry, nullptr, 0);
  }
 
  // 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()

static void test_fiber_sched_suspend ( )

static

Definition at line 259 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_make(ctx, sched, fiber_consumer_entry, nullptr, 0);
  (void)srn_fiber_make(ctx, sched, fiber_producer_entry, nullptr, 0);
 
  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()

static void test_fiber_sched_wait_for ( )

static

Definition at line 427 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_make(ctx, sched, fiber_wf_waiter_entry, nullptr, 0);
  fiber_wf_target =
      srn_fiber_make(ctx, sched, fiber_wf_target_entry, nullptr, 0);
 
  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()

static void test_fiber_sched_wait_for_done ( )

static

Definition at line 449 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_make(ctx, sched, fiber_wf_target_entry, nullptr, 0);
  (void)srn_fiber_make(ctx, sched, fiber_wf_waiter_entry, nullptr, 0);
 
  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()

static void test_fiber_sched_wait_for_many ( )

static

Definition at line 483 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_make(ctx, sched, fiber_wf_counting_waiter, nullptr, 0);
  (void)srn_fiber_make(ctx, sched, fiber_wf_counting_waiter, nullptr, 0);
  (void)srn_fiber_make(ctx, sched, fiber_wf_counting_waiter, nullptr, 0);
  fiber_wf_target =
      srn_fiber_make(ctx, sched, fiber_wf_target_entry, nullptr, 0);
 
  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()

static void test_fiber_sched_yield ( )

static

Definition at line 186 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_make(ctx, sched, fiber_yield_entry, (void *)(intptr_t)1, 0);
  (void)srn_fiber_make(ctx, sched, fiber_yield_entry, (void *)(intptr_t)2, 0);
 
  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_stack()

static void test_fiber_stack ( )

static

Definition at line 58 of file fiber_tests.h.

                               {
  size_t page = srn_mm_get_os_page_size();
 
  srn_fiber_stack_t s = srn_fiber_stack_alloc(0);
 
  TEST_CHECK(s.guard != nullptr);
  TEST_CHECK(s.limit != nullptr);
  TEST_CHECK(s.start != nullptr);
  // The guard sits exactly one page below the usable region.
  TEST_CHECK((char *)s.limit == (char *)s.guard + 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_FIBER_DEFAULT_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()

static void test_fiber_switch ( )

static

Definition at line 100 of file fiber_tests.h.

                                {
  srn_fiber_init_thread(&fiber_pp_thread);
 
  srn_fiber_stack_t worker_stack = srn_fiber_stack_alloc(0);
 
  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_types()

static void test_fiber_types ( )

static

Definition at line 43 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

fiber_dwake_runs

int fiber_dwake_runs

static

Definition at line 351 of file fiber_tests.h.

fiber_dwake_signalled

bool fiber_dwake_signalled

static

Definition at line 350 of file fiber_tests.h.

fiber_dwake_waiter

srn_fiber_t* fiber_dwake_waiter

static

Definition at line 349 of file fiber_tests.h.

fiber_mbox

fiber_mbox_t fiber_mbox

static

Definition at line 224 of file fiber_tests.h.

fiber_mbox_got

int fiber_mbox_got

static

Definition at line 225 of file fiber_tests.h.

fiber_mt_counter

atomic_int fiber_mt_counter

static

Definition at line 510 of file fiber_tests.h.

fiber_mt_yield_counter

atomic_int fiber_mt_yield_counter

static

Definition at line 543 of file fiber_tests.h.

fiber_ok_value

int fiber_ok_value

static

Definition at line 127 of file fiber_tests.h.

fiber_pp_rounds

int fiber_pp_rounds

static

Definition at line 88 of file fiber_tests.h.

fiber_pp_thread

srn_fiber_t fiber_pp_thread

static

Definition at line 85 of file fiber_tests.h.

fiber_pp_ticks

int fiber_pp_ticks

static

Definition at line 87 of file fiber_tests.h.

fiber_pp_worker

srn_fiber_t fiber_pp_worker

static

Definition at line 86 of file fiber_tests.h.

fiber_run_counter

int fiber_run_counter

static

Definition at line 132 of file fiber_tests.h.

fiber_stop_rounds

atomic_int fiber_stop_rounds

static

Definition at line 582 of file fiber_tests.h.

fiber_wf_result

int fiber_wf_result

static

Definition at line 410 of file fiber_tests.h.

fiber_wf_seen

srn_fiber_result_t fiber_wf_seen

static

Definition at line 412 of file fiber_tests.h.

fiber_wf_target

srn_fiber_t* fiber_wf_target

static

Definition at line 411 of file fiber_tests.h.

fiber_wf_woke

int fiber_wf_woke

static

Definition at line 471 of file fiber_tests.h.

fiber_yield_log

int fiber_yield_log[4]

static

Definition at line 173 of file fiber_tests.h.

fiber_yield_n

int fiber_yield_n

static

Definition at line 174 of file fiber_tests.h.