14_mutex.c

Go to the documentation of this file.

/* -*- C -*-
 * Serene programming language
 * Copyright (C) 2019-2026 Sameer Rahmani <lxsameer@lxsameer.com>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
// Example 14 -- a fiber mutex guarding shared state across workers.
//
// Example 05 shared a single atomic counter, the one kind of cross worker state
// that needs no lock. Most shared state is not a lone atomic. When a fiber has
// to read a value, act on it, and write the result back as one indivisible
// step, an atomic increment is not enough and the fibers need mutual exclusion.
//
// `srn_fiber_mutex_t` provides it. Unlike an OS mutex it suspends the calling
// fiber while the lock is held elsewhere and lets the worker run other fibers
// meanwhile, so it must only ever be called from inside a running fiber. Here
// many fibers spread across several workers each take the lock, run a small
// read,modify,write on a plain nonatomic counter, then release. The lock
// serialises the critical section, so no update is lost and the final total is
// exact even though the counter itself is not atomic.
 
#include <stdio.h>
 
#include <serene/rt/fiber/mutex.h>
#include <serene/runtime.h>
 
#define FIBER_COUNT  64
#define ITERATIONS   100
#define WORKER_COUNT 4
 
static srn_fiber_mutex_t lock;
 
// Plain, nonatomic shared state. It is safe only because every access happens inside the critical
// section below.
static long counter;
 
static srn_fiber_result_t bump(srn_context_t *ctx, void *arg) {
  (void)ctx;
  (void)arg;
  for (int i = 0; i < ITERATIONS; i++) {
    srn_fiber_mutex_lock(&lock);
    // The read and the write must not interleave with another fiber. Two fibers
    // reading the same value would each write it back once and lose an update.
    long seen = counter;
    counter   = seen + 1;
    srn_fiber_mutex_unlock(&lock);
  }
  return nullptr;
}
 
int main(void) {
  SERENE_RUNTIME_INIT_WITH_SCHED(engine, sched, nullptr);
  srn_context_t *ctx = srn_context_make(engine);
 
  srn_fiber_mutex_init(&lock);
  counter = 0;
 
  for (int i = 0; i < FIBER_COUNT; i++) {
    (void)srn_fiber_spawn(ctx, bump, nullptr);
  }
 
  long expected = (long)FIBER_COUNT * ITERATIONS;
  printf(
    "running %d fibers x %d iterations across %d workers\n", FIBER_COUNT, ITERATIONS, WORKER_COUNT
  );
  srn_sched_run(sched, WORKER_COUNT);
 
  printf(
    "counted %ld (expected %ld): %s\n", counter, expected,
    counter == expected ? "every increment landed" : "lost an update"
  );
 
  srn_context_release(ctx);
  SERENE_RUNTIME_SHUTDOWN(engine);
  return 0;
}