mutex_tests.h File Reference

#include <stdatomic.h>
#include <stdint.h>
#include "base.h"
#include "serene/rt/fiber.h"
#include "serene/rt/fiber/mutex.h"

Include dependency graph for mutex_tests.h:

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

Go to the source code of this file.

Macros
#define	MUTEX_TESTS(X)
#define	MTX_MUTEX_N   8
#define	MTX_FIFO_N   3
#define	MTX_MT_N   64
#define	MTX_MT_ITERS   100

Functions
static srn_fiber_t *	test_mtx_state (void)
static void	test_mutex_init ()
static srn_fiber_result_t	test_mtx_uncontended_entry (srn_context_t *ctx, void *arg)
static void	test_mutex_uncontended ()
static srn_fiber_result_t	test_mtx_me_entry (srn_context_t *ctx, void *arg)
static void	test_mutex_mutual_exclusion ()
static srn_fiber_result_t	test_mtx_fifo_waiter_entry (srn_context_t *ctx, void *arg)
static srn_fiber_result_t	test_mtx_fifo_holder_entry (srn_context_t *ctx, void *arg)
static void	test_mutex_fifo_order ()
static srn_fiber_result_t	test_mtx_mt_entry (srn_context_t *ctx, void *arg)
static void	test_mutex_mt_contention ()

Variables
static srn_fiber_mutex_t	test_mtx
static bool	test_mtx_uncontended_ran
static int	test_mtx_me_counter
static int	test_mtx_fifo_order [MTX_FIFO_N]
static int	test_mtx_fifo_n
static long	test_mtx_mt_counter

Macro Definition Documentation

MTX_FIFO_N

#define MTX_FIFO_N   3

Definition at line 131 of file mutex_tests.h.

MTX_MT_ITERS

#define MTX_MT_ITERS   100

Definition at line 191 of file mutex_tests.h.

MTX_MT_N

#define MTX_MT_N   64

Definition at line 190 of file mutex_tests.h.

MTX_MUTEX_N

#define MTX_MUTEX_N   8

Definition at line 87 of file mutex_tests.h.

MUTEX_TESTS

#define MUTEX_TESTS

(

X

)

Value:

X("mutex::init", test_mutex_init), X("mutex::uncontended", test_mutex_uncontended), \
  X("mutex::mutual_exclusion", test_mutex_mutual_exclusion),                        \
  X("mutex::fifo_order", test_mutex_fifo_order),                                    \
  X("mutex::mt_contention", test_mutex_mt_contention)

Definition at line 28 of file mutex_tests.h.

#define MUTEX_TESTS(X)                                                                \
  X("mutex::init", test_mutex_init), X("mutex::uncontended", test_mutex_uncontended), \
    X("mutex::mutual_exclusion", test_mutex_mutual_exclusion),                        \
    X("mutex::fifo_order", test_mutex_fifo_order),                                    \
    X("mutex::mt_contention", test_mutex_mt_contention)

Function Documentation

test_mtx_fifo_holder_entry()

srn_fiber_result_t test_mtx_fifo_holder_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 144 of file mutex_tests.h.

                                                                                    {
  UNUSED(ctx);
  UNUSED(arg);
  srn_fiber_mutex_lock(&test_mtx);
  // One yield is enough: the single worker runs all three waiters (each parking
  // on lock) before this holder is scheduled again.
  srn_fiber_yield();
  srn_fiber_mutex_unlock(&test_mtx);
  return nullptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

test_mtx_fifo_waiter_entry()

srn_fiber_result_t test_mtx_fifo_waiter_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 135 of file mutex_tests.h.

                                                                                    {
  UNUSED(ctx);
  int id = (int)(intptr_t)arg;
  srn_fiber_mutex_lock(&test_mtx);
  test_mtx_fifo_order[test_mtx_fifo_n++] = id;
  srn_fiber_mutex_unlock(&test_mtx);
  return nullptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

test_mtx_me_entry()

srn_fiber_result_t test_mtx_me_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 90 of file mutex_tests.h.

                                                                           {
  UNUSED(ctx);
  UNUSED(arg);
 
  WITH_LOCK(&test_mtx, {
    // srn_fiber_mutex_lock(&test_mtx);
    int seen = test_mtx_me_counter;
    // Yield the execution and let other fibers run
    srn_fiber_yield();
    test_mtx_me_counter = seen + 1;
    // srn_fiber_mutex_unlock(&test_mtx);
  });
  return nullptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

test_mtx_mt_entry()

srn_fiber_result_t test_mtx_mt_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 194 of file mutex_tests.h.

                                                                           {
  UNUSED(ctx);
  UNUSED(arg);
  for (int i = 0; i < MTX_MT_ITERS; i++) {
    srn_fiber_mutex_lock(&test_mtx);
    // plain RMW, guarded solely by the lock
    test_mtx_mt_counter++;
    srn_fiber_mutex_unlock(&test_mtx);
  }
  return nullptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

test_mtx_state()

srn_fiber_t * test_mtx_state ( void )

inlinestatic

Definition at line 37 of file mutex_tests.h.

                                                {
  return atomic_load_explicit(&test_mtx.state, memory_order_relaxed);
}

Here is the caller graph for this function:

test_mtx_uncontended_entry()

srn_fiber_result_t test_mtx_uncontended_entry ( srn_context_t * ctx, void * arg )

static

Definition at line 48 of file mutex_tests.h.

                                                                                    {
  UNUSED(ctx);
  UNUSED(arg);
  test_mtx_uncontended_ran = false;
 
  srn_fiber_mutex_lock(&test_mtx);
  srn_fiber_mutex_unlock(&test_mtx);
  // Re-acquiring a just-released lock must succeed.
  srn_fiber_mutex_lock(&test_mtx);
  srn_fiber_mutex_unlock(&test_mtx);
  test_mtx_uncontended_ran = true;
  return nullptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

test_mutex_fifo_order()

void test_mutex_fifo_order ( )

static

Definition at line 155 of file mutex_tests.h.

                                    {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
  srn_scheduler_t *sched = engine->scheduler;
  ASSERT_NOT_NULL(sched);
 
  srn_fiber_mutex_init(&test_mtx);
  test_mtx_fifo_n = 0;
 
  // Holder first so it owns the lock before any waiter runs, then the waiters
  // in the order whose service order we assert.
  (void)srn_fiber_spawn(ctx, test_mtx_fifo_holder_entry, nullptr);
  for (int i = 0; i < MTX_FIFO_N; i++) {
    (void)srn_fiber_spawn(ctx, test_mtx_fifo_waiter_entry, (void *)(intptr_t)(i + 1));
  }
  srn_sched_run(sched, 1);
 
  TEST_CHECK(test_mtx_fifo_n == MTX_FIFO_N);
  for (int i = 0; i < MTX_FIFO_N; i++) {
    TEST_CHECK(test_mtx_fifo_order[i] == i + 1);
    TEST_MSG(
      "order: %d %d %d", test_mtx_fifo_order[0], test_mtx_fifo_order[1], test_mtx_fifo_order[2]
    );
  }
  TEST_CHECK(test_mtx_state() == nullptr);
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}

Here is the call graph for this function:

test_mutex_init()

void test_mutex_init ( )

static

Definition at line 42 of file mutex_tests.h.

                              {
  srn_fiber_mutex_init(&test_mtx);
  TEST_CHECK(test_mtx_state() == nullptr);
  TEST_CHECK(test_mtx.waiters_head == nullptr);
}

Here is the call graph for this function:

test_mutex_mt_contention()

void test_mutex_mt_contention ( )

static

Definition at line 206 of file mutex_tests.h.

                                       {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
  srn_scheduler_t *sched = engine->scheduler;
  ASSERT_NOT_NULL(sched);
 
  srn_fiber_mutex_init(&test_mtx);
  test_mtx_mt_counter = 0;
 
  for (int i = 0; i < MTX_MT_N; i++) {
    (void)srn_fiber_spawn(ctx, test_mtx_mt_entry, nullptr);
  }
  srn_sched_run(sched, 4);
 
  TEST_CHECK(test_mtx_mt_counter == (long)MTX_MT_N * MTX_MT_ITERS);
  TEST_CHECK(test_mtx_state() == nullptr);
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}

Here is the call graph for this function:

test_mutex_mutual_exclusion()

void test_mutex_mutual_exclusion ( )

static

Definition at line 105 of file mutex_tests.h.

                                          {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
  srn_scheduler_t *sched = engine->scheduler;
  ASSERT_NOT_NULL(sched);
 
  srn_fiber_mutex_init(&test_mtx);
  test_mtx_me_counter = 0;
 
  for (int i = 0; i < MTX_MUTEX_N; i++) {
    UNUSED(srn_fiber_spawn(ctx, test_mtx_me_entry, nullptr));
  }
  srn_sched_run(sched, 4);
 
  // No update was lost despite each holder yielding in the middle of the criticalsection.
  TEST_CHECK(test_mtx_me_counter == MTX_MUTEX_N);
  TEST_CHECK(test_mtx_state() == nullptr);
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}

Here is the call graph for this function:

test_mutex_uncontended()

void test_mutex_uncontended ( )

static

Definition at line 62 of file mutex_tests.h.

                                     {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
  srn_scheduler_t *sched = engine->scheduler;
  ASSERT_NOT_NULL(sched);
 
  srn_fiber_mutex_init(&test_mtx);
 
  (void)srn_fiber_spawn(ctx, test_mtx_uncontended_entry, nullptr);
  srn_sched_run(sched, 1);
 
  TEST_CHECK(test_mtx_uncontended_ran);
  // The lock is released once the fiber is done.
  TEST_CHECK(test_mtx_state() == nullptr);
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}

Here is the call graph for this function:

Variable Documentation

test_mtx

srn_fiber_mutex_t test_mtx

static

Definition at line 34 of file mutex_tests.h.

test_mtx_fifo_n

int test_mtx_fifo_n

static

Definition at line 133 of file mutex_tests.h.

test_mtx_fifo_order

int test_mtx_fifo_order[MTX_FIFO_N]

static

Definition at line 132 of file mutex_tests.h.

test_mtx_me_counter

int test_mtx_me_counter

static

Definition at line 88 of file mutex_tests.h.

test_mtx_mt_counter

long test_mtx_mt_counter

static

Definition at line 192 of file mutex_tests.h.

test_mtx_uncontended_ran

bool test_mtx_uncontended_ran

static

Definition at line 35 of file mutex_tests.h.