code wiki / _hdl_build / nx_clock_run.nx
`nx_clock_run.nx` source

1// nx_clock_run.nx -- THE SINGLE SPARK. One invocation = ONE beat of the one Nishi clock: load the ONE durable
2// registry (name·interval·next_due·organ), advance the tick by 1, and let the ONE dispatcher run every job that is
3// now due (fork+exec its organ). Persist the advanced next_due + the tick so the NEXT spark resumes exactly. This
4// is the consolidated runner: ONE loop, ONE registry, N jobs -> it replaces N per-capability daemons/pulses.
5// Like a crystal, it needs ONE external spark per beat (boot/cron/supervisor) -- but only ONE, for ALL periodic
6// work, and one-beat-per-spark can NEVER run away. license_tier: ORIGINAL  expect_exit: 0
7import "nx_clock_sched.nx"
8import "nx_syscalls.nx"
9
10func w(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
11func wn(v: i64) -> i64 { var m: i64=v; if m<0{w("-" as *u8);m=0-m} let t:*u8=sys_mmap(24); var k:i64=0; if m==0{t[0]=48 as u8;k=1} while m>0{t[k]=(48+(m%10)) as u8;m=m/10;k=k+1} var i:i64=0; let o:*u8=sys_mmap(24); while i<k{o[i]=t[k-1-i];i=i+1} sys_write(1,o,k); return 0 }
12func readnum(p: *u8) -> i64 { let lp: *i64 = sys_mmap(8) as *i64; let d: *u8 = sys_read_file(p, lp); if (d as i64)==0 { return 0 } var c: i64=0; var i: i64=0; while i<lp[0] { if d[i]>=(48 as u8) { if d[i]<=(57 as u8) { c=c*10+(d[i]-(48 as u8)) as i64 } } i=i+1 } return c }
13func savenum(p: *u8, v: i64) -> i64 {
14    let buf: *u8 = sys_mmap(24); var o: i64=0; var m: i64=v
15    if m==0 { buf[0]=48 as u8; o=1 } else { 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} while o<k { buf[o]=t[k-1-o]; o=o+1 } }
16    sys_mkdir("knowledge" as *u8, 0x1ed); sys_mkdir("knowledge/sched" as *u8, 0x1ed)
17    let fd: i64 = sys_openat_wr(p, 0x1a4); if fd>=0 { sys_write(fd, buf, o); sys_close(fd) }
18    return 0
19}
20
21func main(argc: i64, argv: *i64) -> i64 {
22    let names: *u8 = sys_mmap(CLK_MAXJOBS*CLK_NAMEW); let orgs: *u8 = sys_mmap(CLK_MAXJOBS*CLK_NAMEW)
23    let iv: *i64 = sys_mmap(CLK_MAXJOBS*8) as *i64; let nd: *i64 = sys_mmap(CLK_MAXJOBS*8) as *i64
24    let fired: *i64 = sys_mmap(CLK_MAXJOBS*8) as *i64; let np: *i64 = sys_mmap(8) as *i64; np[0]=0
25    clk_load("knowledge/sched/jobs.tsv" as *u8, names, orgs, iv, nd, np)
26    if np[0] == 0 { w("nx_clock_run: no jobs in knowledge/sched/jobs.tsv (register some first)\n" as *u8); sys_exit(0); return 0 }
27    let T: i64 = readnum("knowledge/sched/tick.txt" as *u8) + 1
28    let dispatched: i64 = clk_dispatch_run(orgs, iv, nd, np[0], T, fired)
29    clk_save("knowledge/sched/jobs.tsv" as *u8, names, orgs, iv, nd, np[0])   // persist advanced next_due (resume)
30    savenum("knowledge/sched/tick.txt" as *u8, T)
31    w("nx_clock_run: beat "); wn(T); w(" -> dispatched "); wn(dispatched); w(" of "); wn(np[0]); w(" registered jobs (one clock, no per-job daemon)\n" as *u8)
32    sys_exit(0)
33    return 0
34}
nx_clock_run.nx source

`nx_clock_run.nx` source
