code wiki / (root) / nx_clock_sched_reserved_fault_v2_ar.nx

nx_clock_sched_reserved_fault_v2_ar.nx

buildroot/runtime/nx_clock_sched_reserved_fault_v2_ar.nx

91031 B1513 linesdepth 5pulls 11 transitivereach 1 importersview sourcekind librarytopic clock
docsdependenciesstructsconstsfunctions

about

nx_clock_sched.nx -- RENAMED FROM nx_clock.nx 2026-07-31 (lib-reconcile). PERMANENT FIX for a two-libraries-one-name collision: runtime/nx_clock.nx is the TIMING library (nx_clock_monotonic_ns, 62 importers); THIS file is an unrelated tickless JOB SCHEDULER (clk_* registry + dispatcher) that only shared the filename. nx_cc binds an import to the IMPORTER'S OWN DIRECTORY FIRST, so every _hdl_build organ importing nx_clock.nx silently got the SCHEDULER -- _clk_probe.nx, whose whole purpose is to prove nx_clock_monotonic_ns works, could not resolve it. The RENAME is the fix. so we avoid issues ... dont have a million pulses and daemons"). Researched (knowledge/fetched/sched_*.raw: clock-distribution = ONE oscillator -> a tree of DIVIDERS; PLL derives every frequency from ONE reference; cron = ONE daemon reads ONE table of timed jobs; tickless = don't burn a constant tick when idle). The S-class pattern is identical: ONE tick source + ONE durable JOB REGISTRY + ONE dispatcher. Every periodic capability REGISTERS a job (name, interval-in-ticks) = a divider off the single clock -- it does NOT spin up its own daemon/pulse loop. So N capabilities cost ONE loop, not N. This library is the registry + dispatcher; the single tick source drives it (one external spark, like a crystal). license_tier: ORIGINAL

dependencies 4 imports · 1 importers

nx_syscalls.nx nx_store_seed_lib.nx nx_clock_caps.nx nx_ioadmit_lib.nx nx_clock_sched_reserved_fault_ nx_clock_reserved_fault_native_v2_

imports: nx_syscalls.nxnx_store_seed_lib.nxnx_clock_caps.nxnx_ioadmit_lib.nx

imported by: nx_clock_reserved_fault_native_v2_ar.nx

structs

none

consts

18const CLK_MAGIC_1000000: i64 = 1000000
20const CLK_MAXJOBS: i64 = 512 // WAS 128 (2026-08-19): the desired plane hit 128/128 and every
32const CLK_HOGDUTY: i64 = 9
45const CLK_SIGKILL: i64 = 9
46const CLK_DISPATCH_POLL_MS: i64 = 250
61const CLK_DISPATCH_DEADLINE_MS: i64 = 900000
62const CLK_NAMEW: i64 = CLK_CMD_CAP // bytes per name/organ slot -- DERIVED from the ONE shared
74const CLK_ROWW: i64 = 2*CLK_NAMEW + 64 // per-row serialization budget, DERIVED, not chosen:
79const CLK_REG: *u8 = "knowledge/sched/jobs.tsv" // RETIRED LEGACY PATH (2026-08-03, debt 1785792856):
100const CLK_HEAVY_CONF: *u8 = "knowledge/status/clock_heavy.conf"
101const CLK_DEFER_DIV: i64 = 4 // re-arm at interval/4: a 1800 s beat re-checks every 450 s, so a storm costs it at most 3 probes before its own next period
102const CLK_DEFER_MIN_S: i64 = 60 // floor: the shortest re-check that is not a busy loop against /proc/stat
103const CLK_DEFER_MAX_S: i64 = 900 // cap: half a window, the same bound CLK_DISPATCH_DEADLINE_MS already places on one job
106const CLKRS_CONF: *u8 = "knowledge/status/clock_reserved.conf"
107const CLKRS_NONE: i64 = 0 - 1
108const CLKRS_INVALID: i64 = 0 - 2
109const CLKRS_EINTR: i64 = 0 - 4
110const CLKRS_WNOHANG: i64 = 1
111const CLKRS_SIGNAL_EXIT_BASE: i64 = 128 // shell signal-exit convention
112const CLKRS_DISP: i64 = 0
113const CLKRS_STARVED: i64 = 1
114const CLKRS_LATE: i64 = 2
115const CLKRS_MAXMISSED: i64 = 3
116const CLKRS_STARVIDX: i64 = 4
117const CLKRS_MAXEXEC: i64 = 5
118const CLKRS_FOREGROUND_EXEC: i64 = 6
119const CLKRS_ERRORS: i64 = 7
120const CLKRS_N: i64 = 14
121const CLKRS_FATAL: i64 = 8
122const CLKRS_LOST_INDEX: i64 = 9
123const CLKRS_LOST_PID: i64 = 10
124const CLKRS_LOST_WAIT: i64 = 11
125const CLKRS_FOREGROUND_DISP: i64 = 12
126const CLKRS_KNOWN_OWNED: i64 = 13
127const CLKRS_FATAL_RC: i64 = 0 - 3
128const CLKRS_WAIT_RUNNING: i64 = 0
129const CLKRS_WAIT_REAPED: i64 = 1
130const CLKRS_WAIT_INTERRUPTED: i64 = 2
131const CLKRS_WAIT_LOST: i64 = 3
132const CLKRS_OUT_ERRORS: i64 = 12
133const CLKRS_OUT_FATAL: i64 = 13
134const CLKRS_OUT_LOST_INDEX: i64 = 14
135const CLKRS_OUT_LOST_PID: i64 = 15
136const CLKRS_OUT_LOST_WAIT: i64 = 16
137const CLKRS_OUT_KNOWN_OWNED: i64 = 17
138const CLKRS_OUT_N: i64 = 18
761const CLK_EPOCH_FLOOR: i64 = 1000000000
1320const CFI_ECHILD: i64 = 0 - 10

functions

140func clk_heavy_listed(conf: *u8, n: i64, name: *u8) -> i64
167func clk_defer_secs(interval: i64) -> i64
called by 1: clk_run_edf_core
175func clk_storm_defer(heavy: i64, budget: i64) -> i64
called by 1: clk_run_edf_core
182func clk_storm_budget(ioa: *i64) -> i64
187func clk_slot(names: *u8, i: i64) -> *u8 { return ((names as i64) + i*CLK_NAMEW) as *u8 }
188func clk_streq(a: *u8, b: *u8) -> i64 { var i: i64=0; while a[i]!=(0 as u8){ if a[i]!=b[i]{return 0} i=i+1 } if b[i]!=(0 as u8){return 0} return 1 }
190func clk_find(names: *u8, n: i64, name: *u8) -> i64 { var i: i64=0; while i<n { if clk_streq(clk_slot(names,i), name)==1 { return i } i=i+1 } return 0-1 }
194func clk_register(names: *u8, organs: *u8, intervals: *i64, next_due: *i64, np: *i64, name: *u8, organ: *u8, interval: i64) -> i64
264func clk_tick(intervals: *i64, next_due: *i64, n: i64, now: i64, fired: *i64) -> i64
281func clk_dispatch_run(organs: *u8, intervals: *i64, next_due: *i64, n: i64, now: i64, fired: *i64) -> i64
314func clk_run_tickless(organs: *u8, intervals: *i64, next_due: *i64, n: i64, start_tick: i64, maxbeats: i64, tick_ms: i64, out: *i64) -> i64
337func clk_due_in(next_due_i: i64, now: i64) -> i64 { return next_due_i - now }
338func clk_twin_ok(organ: *u8) -> i64 { let fd: i64 = sys_openat_rd(organ); if fd < 0 { return 0 } sys_close(fd); return 1 }
340func clk_itoa(buf: *u8, o: i64, v: i64) -> i64 { var w: i64=o; var m: i64=v; if m==0{buf[w]=48 as u8;return w+1} if m<0{buf[w]=45 as u8;w=w+1;m=0-m} let t:*u8=sys_mmap(24); var k:i64=0; while m>0{t[k]=(48+(m%10)) as u8;m=m/10;k=k+1} var j:i64=0; while j<k{buf[w]=t[k-1-j];w=w+1;j=j+1} return w }
343func clk_msgcat(d: *u8, o: i64, s: *u8) -> i64 { var x: i64=o; var i: i64=0; while s[i]!=(0 as u8){d[x]=s[i];x=x+1;i=i+1} return x }
344func clk_msgnum(d: *u8, o: i64, v: i64) -> i64
368func clk_actlog(organ: *u8, code: i64) -> i64
391func clk_save(path: *u8, names: *u8, organs: *u8, intervals: *i64, next_due: *i64, n: i64) -> i64
491func clk_load_plane(prefix: *u8, names: *u8, organs: *u8, intervals: *i64, next_due: *i64, np: *i64) -> i64
534func clk_save_plane(prefix: *u8, names: *u8, organs: *u8, intervals: *i64, next_due: *i64, n: i64) -> i64
582func clk_load_state(prefix: *u8, legacy: *u8, names: *u8, organs: *u8, intervals: *i64, next_due: *i64, np: *i64) -> i64
594func clk_merge_store(prefix: *u8, names: *u8, organs: *u8, intervals: *i64, next_due: *i64, np: *i64, base_tick: i64) -> i64
776func clk_demand_per_window(intervals: *i64, n: i64, window_secs: i64) -> i64
796func clk_edf_pick_free(deadlines: *i64, n: i64, now: i64, busy: *i64) -> i64
812func clk_edf_pick(deadlines: *i64, n: i64, now: i64) -> i64
called by 1: clk_run_edf_core
827func clk_edf_next(deadlines: *i64, n: i64) -> i64
called by 1: clk_run_edf_core
837func clk_edf_missed(deadlines: *i64, intervals: *i64, i: i64, now: i64) -> i64
846func clk_edf_rearm(deadlines: *i64, intervals: *i64, i: i64, now: i64) -> i64
858func clk_edf_migrate(deadlines: *i64, intervals: *i64, n: i64, now: i64) -> i64
889func clk_ifw(s: *u8, dst: *u8, o: i64) -> i64 { var x: i64=o; var i: i64=0; while s[i]!=(0 as u8){dst[x]=s[i];x=x+1;i=i+1} return x }
called by 1: clk_inflight
890func clk_ifn(dst: *u8, o: i64, v: i64) -> i64 { var x: i64=o; var mm: i64=v; if mm<0{dst[x]=45 as u8;x=x+1;mm=0-mm} if mm==0{dst[x]=48 as u8;return x+1} let t:*u8=sys_mmap(24); var k:i64=0; while mm>0{t[k]=(48+(mm%10)) as u8;mm=mm/10;k=k+1} var j:i64=0; while j<k{dst[x]=t[k-1-j];x=x+1;j=j+1} return x }
called by 1: clk_inflight calls 1: sys_mmap
891func clk_inflight(tag: *u8, organ: *u8, a: i64, b: i64) -> i64
904func clk_run_edf_core(organs: *u8, names: *u8, intervals: *i64, deadlines: *i64, n: i64, maxdispatch: i64, budget_secs: i64, tick_ms: i64, out: *i64, reserved_mode: i64) -> i64
1079func clk_split_argv(raw0: *u8, buf: *u8, argv: *i64, label: *u8) -> i64
1120func clk_dispatch_one(organs: *u8, names: *u8, i: i64) -> i64
1188func clk_load(path: *u8, names: *u8, organs: *u8, intervals: *i64, next_due: *i64, np: *i64) -> i64
1226func clk_reserved_resolve(conf: *u8, cn: i64, names: *u8, organs: *u8, intervals: *i64, n: i64, heavy: *u8, hn: i64) -> i64
1283func clk_reserved_due(index: i64, foreground: i64, pid: i64, due: i64, now: i64, foreground_live: i64) -> i64
1293func clk_reserved_spawn(organs: *u8, names: *u8, i: i64) -> i64
1310func clk_reserved_log(organs: *u8, names: *u8, i: i64, code: i64) -> i64
1321func cfi_number(path: *u8) -> i64
1327func cfi_write(path: *u8, value: i64) -> i64
1335func cfi_mode() -> i64
1341func cfi_fault_event() -> i64
1354func clk_reserved_wait_owned(pid: i64, status: *i64, flags: i64) -> i64
1377func clk_reserved_signal_owned(pid: i64, signal: i64) -> i64
1385func clk_reserved_wait_kind(result: i64, pid: i64) -> i64
1392func clk_reserved_halt_required(out: *i64) -> i64
called by 1: crg_subject
1396func clk_reserved_lost(ro: *i64, names: *u8, i: i64, pid: i64, result: i64, other_owned: i64) -> i64
1414func clk_dispatch_reserved(organs: *u8, names: *u8, intervals: *i64, deadlines: *i64, i: i64, reserved: i64, deadline_ms: i64, poll_ms: i64, ro: *i64) -> i64
1506func clk_run_edf(organs: *u8, names: *u8, intervals: *i64, deadlines: *i64, n: i64, maxdispatch: i64, budget_secs: i64, tick_ms: i64, out: *i64) -> i64
called by 1: crg_subject calls 1: clk_run_edf_core
1511func clk_run_edf_reserved(organs: *u8, names: *u8, intervals: *i64, deadlines: *i64, n: i64, maxdispatch: i64, budget_secs: i64, tick_ms: i64, out: *i64) -> i64
called by 1: crg_subject calls 1: clk_run_edf_core