06_request_term.c

Go to the documentation of this file.

/* -*- C -*-
 * Serene programming language
 * Copyright (C) 2019-2026 Sameer Rahmani <[email protected]>
 *
 * 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 06 -- asking the scheduler to stop.
//
// A scheduler normally runs until it goes quiescent, every worker idle with no
// work left. `srn_sched_stop` stops it before that point. Each worker
// notices the request at the top of its loop and stops once the fiber it is
// running yields or finishes, so a fiber is never cut off mid step. Work still
// queued is left unrun, and its stacks are reclaimed at shutdown through the
// scheduler's registry. The call is safe from any thread, which is what makes
// it usable from a signal handler reacting to Ctrl-C or SIGTERM.
//
// A controller fiber runs first and requests termination, then returns
// normally. It is the slice in flight, and termination lets it finish cleanly.
// A batch of task fibers sit queued behind it. Because the controller stops the
// scheduler before they get a turn, they never run, and the final count of
// tasks that ran is zero. That is the point: a requested stop abandons queued
// work rather than draining it.
 
#include <stdatomic.h>
#include <stdio.h>
 
#include <serene/runtime.h>
 
static int ok;
 
#define TASK_COUNT 16
 
static atomic_int tasks_ran;
 
static srn_fiber_result_t task(srn_context_t *ctx, void *arg) {
  (void)ctx;
  (void)arg;
  atomic_fetch_add(&tasks_ran, 1);
  return &ok;
}
 
static srn_fiber_result_t controller(srn_context_t *ctx, void *arg) {
  (void)ctx;
  // The scheduler arrives through the argument, so the controller can act on
  // it.
  srn_scheduler_t *sched = arg;
  printf("controller: stopping the scheduler before the tasks run\n");
  srn_sched_stop(sched);
  // Returning normally is the clean boundary the worker stops on.
  return &ok;
}
 
int main(void) {
  srn_mm_t *mm = srn_mm_init();
  srn_engine_t *engine = srn_engine_make(mm);
  srn_context_t *ctx = srn_context_make(engine);
  srn_scheduler_t *sched = engine->scheduler;
 
  atomic_store(&tasks_ran, 0);
 
  // The controller is created first so it reaches the front of the ready queue
  // first and requests the stop before any task is dequeued.
  (void)srn_fiber_make(ctx, sched, controller, sched, 0);
  for (int i = 0; i < TASK_COUNT; i++) {
    (void)srn_fiber_make(ctx, sched, task, nullptr, 0);
  }
 
  // One worker keeps the order deterministic: the controller runs, stops the
  // scheduler, and the worker exits at the top of its next loop with the tasks
  // still queued.
  srn_sched_run(sched, 1);
 
  int ran = atomic_load(&tasks_ran);
  printf("%d of %d tasks ran before termination\n", ran, TASK_COUNT);
  printf("the rest were left queued and are reclaimed at shutdown\n");
 
  // Teardown order matters once a run stops with work still queued. The unrun
  // tasks are still on the scheduler's registry, yet their fiber structs live
  // in this context's blocks. srn_engine_shutdown reaps the scheduler, walking
  // that registry, so it has to run before the context that owns those structs
  // is released. The examples that drain every fiber leave an empty registry,
  // so the order does not matter for them.
  srn_engine_shutdown(engine);
  srn_context_release(ctx);
  srn_mm_shutdown(mm);
  return 0;
}