/*
  StarForth — Steady-State Virtual Machine Runtime

  Copyright (c) 2023–2025 Robert A. James
  All rights reserved.

  This file is part of the StarForth project.

  Licensed under the StarForth License, Version 1.0 (the "License");
  you may not use this file except in compliance with the License.

  You may obtain a copy of the License at:
      https://github.com/star.4th@proton.me/StarForth/LICENSE.txt

  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
  express or implied, including but not limited to the warranties of
  merchantability, fitness for a particular purpose, and noninfringement.

 See the License for the specific language governing permissions and
 limitations under the License.
*/

/**
 * switch.h - Cooperative VM context switch (FABRIC-3.md §XXVIII, Stage 2,
 * 2026-09-13).
 *
 * sk_vm_context_switch() suspends `from`'s execution exactly where it is
 * (mid-C-call-stack, on from's own native stack -- Stage 1) and resumes
 * `to` -- either for the first time ever (a synthesized initial frame,
 * entering sk_vm_switch_entry()) or exactly where `to` was itself last
 * switched out. Returns to the caller only once something later switches
 * back to `from` -- from from's own point of view, this call simply
 * takes a while to return, like any blocking call.
 *
 * Cooperative only: nothing here is interrupt-driven yet (that's Stage
 * 3), so this is safe to call only from ordinary FORTH word dispatch,
 * never from ISR context.
 */

#ifndef STARKERNEL_VM_SWITCH_H
#define STARKERNEL_VM_SWITCH_H

#ifdef __STARKERNEL__

#include <stdint.h>

struct VM;

int sk_vm_context_switch(struct VM *from, struct VM *to);

/* FABRIC-3.10.8 MC-2: how many switches were refused because they would
 * have entered an observer on a core other than core 0 (a guard; 0). */
uint64_t sk_vm_switch_observer_refusals(void);

/* FABRIC-3.md §XXVIII Stage 3 follow-on (2026-09-14): which VM is
 * currently physically running, tracked by the switch mechanism itself --
 * see switch.c's own doc comment on g_switch_current_vm for why this
 * exists instead of reusing vm_log_attributed_vm(). sk_vm_switch_set_
 * current() seeds the initial value (whoever is running before any
 * switch has ever happened) -- call once, at Stage 3 registration time. */
struct VM *sk_vm_switch_current_vm(void);
void sk_vm_switch_set_current(struct VM *vm);

/* FABRIC-3.8.md §3.13.3 (Stage C-b): the word checkpoint's switch point.
 * Call only where `vm` owns its outermost frame (vm_core.c gates this with
 * sk_vm_owns_outermost_frame()). Re-decides only if something physical
 * changed since the last decision (a beat of the running VM, or mail);
 * switches to a strictly cooler VM with work, if there is one. */
void sk_vm_switch_checkpoint(struct VM *vm);

/* FABRIC-3.8.md §3.13.5 (Stage C-b, ruling C-5): the idle point. Called
 * from the console's input poll loops (repl.c) each pass with no input.
 * Acts only when Hera is running with no frame live (between lines); then
 * switches to the coolest VM with work, if any.
 *
 * FABRIC-3.9.8 Stage O-B (FABRIC-3.9.0.md §2.5): Hera's own mail is drained
 * here first, one message per call, instead of on the timer-paced idle beat
 * -- she is an observer that acts on events, promptly. may_drain_self is
 * the caller's gate: readline passes (n == 0), so a drained payload never
 * prints into a line being typed. */
void sk_vm_idle_point(int may_drain_self);

/* FABRIC-3.8.md §3.5 (Stage D): 1 if `vm` is parked at its own trampoline
 * with nothing in progress -- its frame stack holds exactly one frame, its
 * own VM_FRAME_IDLE. Its saved context is the bare trampoline loop; no
 * payload, no borrowed frame, nothing that would ever need resuming. This
 * is what makes a SWITCHED_OUT VM killable. (Hera parked at her idle point
 * also has one IDLE frame, but she can never be killed anyway.) */
int sk_vm_parked_idle(const struct VM *vm);

#endif /* __STARKERNEL__ */

#endif /* STARKERNEL_VM_SWITCH_H */