spsc_ring_tests.h File Reference

#include <sched.h>
#include <stdint.h>
#include <serene/rt/fiber/thread.h>
#include <serene/rt/impl/spsc_ring.h>
#include "acutest.h"
#include "base.h"

Include dependency graph for spsc_ring_tests.h:

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

Go to the source code of this file.

Data Structures
struct	spsc_pair
struct	spsc_producer_arg

Macros
#define	SPSC_RING_TESTS(X)

Typedefs
typedef struct spsc_pair	spsc_pair
typedef struct spsc_producer_arg	spsc_producer_arg

Functions
static void	test_spsc_ring_make_valid ()
static void	test_spsc_ring_make_oor ()
static void	test_spsc_ring_fill_drain ()
static void	test_spsc_ring_elem_bytes ()
static void	spsc_producer (void *p)
static void	test_spsc_ring_spsc_stress ()

Macro Definition Documentation

SPSC_RING_TESTS

#define SPSC_RING_TESTS

(

X

)

Value:

X("spsc_ring::make_valid", test_spsc_ring_make_valid),        \
  X("spsc_ring::make_out_of_range", test_spsc_ring_make_oor), \
  X("spsc_ring::fill_drain_wrap", test_spsc_ring_fill_drain), \
  X("spsc_ring::elem_bytes", test_spsc_ring_elem_bytes),      \
  X("spsc_ring::spsc_stress", test_spsc_ring_spsc_stress)

Definition at line 30 of file spsc_ring_tests.h.

#define SPSC_RING_TESTS(X)                                      \
  X("spsc_ring::make_valid", test_spsc_ring_make_valid),        \
    X("spsc_ring::make_out_of_range", test_spsc_ring_make_oor), \
    X("spsc_ring::fill_drain_wrap", test_spsc_ring_fill_drain), \
    X("spsc_ring::elem_bytes", test_spsc_ring_elem_bytes),      \
    X("spsc_ring::spsc_stress", test_spsc_ring_spsc_stress)

Typedef Documentation

spsc_pair

typedef struct spsc_pair spsc_pair

spsc_producer_arg

typedef struct spsc_producer_arg spsc_producer_arg

Function Documentation

spsc_producer()

void spsc_producer ( void * p )

static

Definition at line 142 of file spsc_ring_tests.h.

                                   {
  spsc_producer_arg *a = (spsc_producer_arg *)p;
  for (uint64_t i = 0; i < a->count; i++) {
    while (!srn_spsc_ring_push(a->ring, &i)) {
      // Ring full, yield so the consumer gets the CPU. Without this a tight
      // spin starves the other thread under valgrind's serialized scheduler.
      sched_yield();
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

test_spsc_ring_elem_bytes()

void test_spsc_ring_elem_bytes ( )

static

Definition at line 119 of file spsc_ring_tests.h.

                                        {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
 
  srn_spsc_ring_t *r = srn_spsc_ring_make(ctx, 3, sizeof(spsc_pair));
  TEST_ASSERT(r != nullptr && !HAS_ERROR(*r));
 
  spsc_pair in = {.a = 0xDEADBEEFU, .b = 0x12345678U};
  TEST_CHECK(srn_spsc_ring_push(r, &in));
 
  spsc_pair out = {0};
  TEST_CHECK(srn_spsc_ring_pop(r, &out));
  TEST_CHECK(out.a == 0xDEADBEEFU && out.b == 0x12345678U);
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}

Here is the call graph for this function:

test_spsc_ring_fill_drain()

void test_spsc_ring_fill_drain ( )

static

Definition at line 77 of file spsc_ring_tests.h.

                                        {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
 
  srn_spsc_ring_t *r = srn_spsc_ring_make(ctx, 2, sizeof(uint64_t)); // cap 4
  TEST_ASSERT(r != nullptr && !HAS_ERROR(*r));
 
  TEST_CHECK(srn_spsc_ring_empty(r));
 
  for (uint64_t i = 0; i < 4; i++) {
    TEST_CHECK(srn_spsc_ring_push(r, &i));
  }
 
  uint64_t overflow = 99;
  TEST_CHECK(!srn_spsc_ring_push(r, &overflow)); // full
  TEST_CHECK(!srn_spsc_ring_empty(r));
 
  uint64_t v = 0;
  TEST_CHECK(srn_spsc_ring_pop(r, &v) && v == 0);
  TEST_CHECK(srn_spsc_ring_pop(r, &v) && v == 1);
 
  uint64_t a = 4, b = 5; // these wrap into the freed slots
  TEST_CHECK(srn_spsc_ring_push(r, &a));
  TEST_CHECK(srn_spsc_ring_push(r, &b));
 
  for (uint64_t expect = 2; expect <= 5; expect++) {
    TEST_CHECK(srn_spsc_ring_pop(r, &v) && v == expect);
  }
  TEST_CHECK(srn_spsc_ring_empty(r));
  TEST_CHECK(!srn_spsc_ring_pop(r, &v)); // empty
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}

Here is the call graph for this function:

test_spsc_ring_make_oor()

void test_spsc_ring_make_oor ( )

static

Definition at line 57 of file spsc_ring_tests.h.

                                      {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
 
  srn_spsc_ring_t *too_small = srn_spsc_ring_make(ctx, 1, sizeof(int));
  TEST_ASSERT(too_small != nullptr);
  TEST_CHECK(HAS_ERROR(*too_small));
  TEST_ASSERT(too_small->maybe_error->tag == WRONG_RANGE);
 
  srn_spsc_ring_t *too_big = srn_spsc_ring_make(ctx, 64, sizeof(int));
  TEST_ASSERT(too_big != nullptr);
  TEST_CHECK(HAS_ERROR(*too_big));
  TEST_ASSERT(too_big->maybe_error->tag == WRONG_RANGE);
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}

Here is the call graph for this function:

test_spsc_ring_make_valid()

void test_spsc_ring_make_valid ( )

static

Definition at line 39 of file spsc_ring_tests.h.

                                        {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
 
  srn_spsc_ring_t *r = srn_spsc_ring_make(ctx, 3, sizeof(uint64_t)); // cap 8
  TEST_ASSERT(r != nullptr);
  TEST_CHECK(!HAS_ERROR(*r));
  TEST_CHECK(r->cap == 8);
  TEST_CHECK(r->mask == 7);
  TEST_CHECK(r->elem_size == sizeof(uint64_t));
  TEST_CHECK(srn_spsc_ring_empty(r));
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}

Here is the call graph for this function:

test_spsc_ring_spsc_stress()

void test_spsc_ring_spsc_stress ( )

static

Definition at line 156 of file spsc_ring_tests.h.

                                         {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
 
  srn_spsc_ring_t *r = srn_spsc_ring_make(ctx, 6, sizeof(uint64_t)); // cap 64
  TEST_ASSERT(r != nullptr && !HAS_ERROR(*r));
 
  constexpr uint64_t n  = 100000;
  spsc_producer_arg arg = {.ring = r, .count = n};
  srn_thread_t producer;
  TEST_ASSERT(srn_thread_spawn(&producer, spsc_producer, &arg) == SRN_THREAD_OK);
 
  bool in_order = true;
  for (uint64_t i = 0; i < n; i++) {
    uint64_t v;
    while (!srn_spsc_ring_pop(r, &v)) {
      // Ring empty, yield so the producer gets the CPU. Without this a tight
      // spin starves the producer under valgrind's serialized scheduler.
      sched_yield();
    }
    if (v != i) {
      in_order = false;
      break;
    }
  }
  TEST_CHECK(in_order);
  TEST_CHECK(srn_thread_join(&producer) == SRN_THREAD_OK);
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}

Here is the call graph for this function: