mirror of
https://github.com/bearlanguageorg/bear.git
synced 2026-08-26 14:57:18 +00:00
Tier Three: Added threads/jobs
This commit is contained in:
allexanderbergmns
+44
@@ -640,6 +640,50 @@ fn (mut v Vm) native(id int, _argc int) ! {
|
||||
}
|
||||
v.push(v.alloc_str(s.repeat(n)))!
|
||||
}
|
||||
// -------------------------------------------------------------------
|
||||
// string builder — accumulate pieces and join once (linear, not
|
||||
// quadratic like repeated `+` concatenation)
|
||||
native_sb_new {
|
||||
v.builders << StrBuilder{}
|
||||
v.push(v.mkbuilder(v.builders.len - 1))!
|
||||
}
|
||||
native_sb_add {
|
||||
x := v.pop()!
|
||||
sb := v.pop()!
|
||||
if !v.is_builder(sb) || !v.valid_builder_handle(sb) {
|
||||
return error('sb_add expects a string builder as its first argument')
|
||||
}
|
||||
if v.is_str(x) && v.valid_handle(x) {
|
||||
v.builders[v.hand(sb)].parts << v.strings[v.hand(x)]
|
||||
} else {
|
||||
v.builders[v.hand(sb)].parts << v.val_str(x, 0)
|
||||
}
|
||||
v.push(sb)!
|
||||
}
|
||||
native_sb_str {
|
||||
sb := v.pop()!
|
||||
if !v.is_builder(sb) || !v.valid_builder_handle(sb) {
|
||||
return error('sb_str expects a string builder')
|
||||
}
|
||||
v.push(v.alloc_str(v.builders[v.hand(sb)].parts.join('')))!
|
||||
}
|
||||
native_sb_len {
|
||||
sb := v.pop()!
|
||||
if !v.is_builder(sb) || !v.valid_builder_handle(sb) {
|
||||
return error('sb_len expects a string builder')
|
||||
}
|
||||
mut n := 0
|
||||
for p in v.builders[v.hand(sb)].parts {
|
||||
n += p.len
|
||||
}
|
||||
v.push(v.enc_int(i64(n)))!
|
||||
}
|
||||
native_spawn {
|
||||
v.push(v.native_spawn(_argc)!)!
|
||||
}
|
||||
native_spawn_join {
|
||||
v.push(v.native_spawn_join()!)!
|
||||
}
|
||||
native_cwd {
|
||||
v.push(v.alloc_str(os.getwd()))!
|
||||
}
|
||||
|
||||
@@ -171,3 +171,13 @@ const native_path_abs = 185
|
||||
const native_path_rel = 186
|
||||
const native_exec_full = 187
|
||||
const native_weekday = 188
|
||||
|
||||
// string builder (efficient repeated concatenation)
|
||||
const native_sb_new = 189
|
||||
const native_sb_add = 190
|
||||
const native_sb_str = 191
|
||||
const native_sb_len = 192
|
||||
|
||||
// concurrency: spawn/join threads
|
||||
const native_spawn = 193
|
||||
const native_spawn_join = 194
|
||||
|
||||
+187
@@ -0,0 +1,187 @@
|
||||
// spawn.v — real OS-thread concurrency for the VuurRaaf VM.
|
||||
//
|
||||
// let job = spawn(fn, arg1, arg2, ...) // start, returns a job id
|
||||
// let result = spawn_join(job) // wait for the result
|
||||
//
|
||||
// Each spawned closure runs on its own OS thread in a *fresh, isolated* VM.
|
||||
// The child heap is built on the parent thread (so the deep-copy of captured
|
||||
// values and arguments happens while the parent heap is quiescent), then the
|
||||
// child VM is handed to a worker thread which owns it exclusively. The only
|
||||
// state shared between threads is the immutable bytecode; the result is
|
||||
// handed back through a per-job channel.
|
||||
//
|
||||
// The child Vm is passed to the worker *by value*: V copies the struct, and
|
||||
// because the child grows its own slice pools (reallocating the backing on
|
||||
// append), the worker's mutations never touch the parent's memory.
|
||||
//
|
||||
// Supported argument/result shapes: ints, floats, strings, `none`, and flat
|
||||
// arrays/structs of those, deep-copied into the child heap. Composite
|
||||
// results are rendered to their string form so the parent never holds a
|
||||
// dangling child handle.
|
||||
|
||||
module vm
|
||||
|
||||
// Job records one in-flight spawn; the result arrives on the channel.
|
||||
struct Job {
|
||||
mut:
|
||||
entry int
|
||||
ready Vm // the isolated child VM, exclusively owned by the worker thread
|
||||
ch chan JobResult
|
||||
}
|
||||
|
||||
// JobResult is the outcome of a spawned closure, delivered via channel.
|
||||
struct JobResult {
|
||||
mut:
|
||||
ok bool
|
||||
err string
|
||||
// exactly one of str / val is set: strings come back as `str` (always
|
||||
// isomorphic across heaps); other scalar results as `val`; composite
|
||||
// results are delivered as their string rendering in `str`.
|
||||
str string
|
||||
val i64
|
||||
}
|
||||
|
||||
const max_jobs = 256
|
||||
|
||||
// spawn is wired to the `spawn` builtin: launch a closure on an OS thread.
|
||||
fn (mut v Vm) native_spawn(argc int) !i64 {
|
||||
if argc < 1 {
|
||||
return error('spawn expects a function followed by zero or more arguments')
|
||||
}
|
||||
// stack (top first): arg_{argc-1} ... arg_0, closure
|
||||
mut args := []i64{len: argc - 1}
|
||||
for i in 0..argc - 1 {
|
||||
args[argc - 2 - i] = v.pop()!
|
||||
}
|
||||
ch := v.pop()!
|
||||
if !v.is_closure(ch) || !v.valid_closure_handle(ch) {
|
||||
return error('spawn expects a function as its first argument')
|
||||
}
|
||||
cl := v.closures[v.hand(ch)]
|
||||
if v.jobs.len >= max_jobs {
|
||||
return error('too many concurrent spawn jobs (limit ${max_jobs})')
|
||||
}
|
||||
child := v.build_job_vm(cl.entry, cl.captured, args)!
|
||||
idx := v.jobs.len
|
||||
v.jobs << Job{ entry: cl.entry, ready: child, ch: chan JobResult{cap: 1} }
|
||||
// pass the child Vm by value: the worker owns this copy exclusively
|
||||
job_child := v.jobs[idx].ready
|
||||
ch_result := v.jobs[idx].ch
|
||||
go run_spawned_job(job_child, ch_result)
|
||||
return v.enc_int(i64(idx))
|
||||
}
|
||||
|
||||
// native_spawn_join is wired to the `spawn_join` builtin: block until the job
|
||||
// finished, then return its result (deep-read back into the parent heap).
|
||||
fn (mut v Vm) native_spawn_join() !i64 {
|
||||
id := int(v.dec_int(v.pop()!))
|
||||
if id < 0 || id >= v.jobs.len {
|
||||
return error('spawn_join: unknown job id ${id}')
|
||||
}
|
||||
res := <-v.jobs[id].ch
|
||||
if !res.ok {
|
||||
return error('spawned job failed: ${res.err}')
|
||||
}
|
||||
if res.str != '' {
|
||||
return v.alloc_str(res.str)
|
||||
}
|
||||
return res.val
|
||||
}
|
||||
|
||||
// build_job_vm constructs the isolated child Vm and pre-loads the closure's
|
||||
// captured values + call arguments as leading locals. Runs on the parent
|
||||
// thread while the parent heap is quiescent.
|
||||
fn (mut v Vm) build_job_vm(entry int, captured []i64, args []i64) !Vm {
|
||||
mut child := Vm{
|
||||
code: v.code
|
||||
strings: v.strings.clone()
|
||||
stack: []i64{len: stack_cap}
|
||||
lines: v.lines
|
||||
fns: v.fns
|
||||
const_strs: v.const_strs
|
||||
max_ops: v.max_ops
|
||||
}
|
||||
// Synthetic entry frame laid out exactly like Vm.call: [ip, old_bp, argc,
|
||||
// local_0..local_{argc-1}] with bp at local_0 (so stack[bp-3]=ip,
|
||||
// stack[bp-2]=old_bp, stack[bp-1]=argc). The synthetic caller is placed at
|
||||
// bp = 3 + n so that the closure's final `ret` — which reads ip(bp-3),
|
||||
// old_bp(bp-2), argc(bp-1), unwinds `sp -= argc`, then halts (ip == -1) and
|
||||
// pushes the return value — lands back at slot (3+n)-3-n = 0, mirroring
|
||||
// how a top-level `main` returns.
|
||||
n := captured.len + args.len
|
||||
child.bp = 3 + n
|
||||
child.sp = 3 + n
|
||||
base := child.bp - 3 // ip slot
|
||||
child.stack[base] = child.enc_int(-1) // return ip: signals the synthetic frame
|
||||
child.stack[base + 1] = child.enc_int(0) // old_bp
|
||||
child.stack[base + 2] = child.enc_int(i64(n)) // argc (captured + args)
|
||||
for i, c in captured {
|
||||
child.stack[child.bp + i] = v.copy_into(mut child, c)!
|
||||
}
|
||||
for i, a in args {
|
||||
child.stack[child.bp + captured.len + i] = v.copy_into(mut child, a)!
|
||||
}
|
||||
child.sp = child.bp + n
|
||||
child.ip = entry
|
||||
return child
|
||||
}
|
||||
|
||||
// run_spawned_job is the worker thread entry: it drives the exclusively-owned
|
||||
// child VM to completion and sends the result back. The child is passed by
|
||||
// value — V copies the struct (including the freshly-allocated slice backings
|
||||
// built on the parent thread), so this worker's mutations never alias the
|
||||
// parent's memory.
|
||||
fn run_spawned_job(child Vm, ch chan JobResult) {
|
||||
mut c := child
|
||||
c.exec() or {
|
||||
ch <- JobResult{ ok: false, err: err.msg() }
|
||||
return
|
||||
}
|
||||
res := c.stack[0] // left by ret from the synthetic entry frame
|
||||
if c.is_str(res) && c.valid_handle(res) {
|
||||
ch <- JobResult{ ok: true, str: c.strings[c.hand(res)] }
|
||||
return
|
||||
}
|
||||
ch <- JobResult{ ok: true, val: res }
|
||||
}
|
||||
|
||||
// copy_into deep-copies a parent value into the child heap, re-interned so
|
||||
// the child's handles are valid in its own pools. Runs on the parent thread.
|
||||
fn (mut v Vm) copy_into(mut child Vm, x i64) !i64 {
|
||||
if v.is_int(x) {
|
||||
return x
|
||||
}
|
||||
if v.is_none(x) {
|
||||
return x
|
||||
}
|
||||
if v.is_float(x) && v.valid_float_handle(x) {
|
||||
child.floats << v.fval(x)
|
||||
return child.mkfloat(child.floats.len - 1)
|
||||
}
|
||||
if v.is_str(x) && v.valid_handle(x) {
|
||||
child.strings << v.strings[v.hand(x)]
|
||||
return child.mkstr(child.strings.len - 1)
|
||||
}
|
||||
if v.is_arr(x) && v.valid_arr_handle(x) {
|
||||
src := v.arrays[v.hand(x)]
|
||||
mut na := []i64{len: src.len}
|
||||
for i, el in src {
|
||||
na[i] = v.copy_into(mut child, el)!
|
||||
}
|
||||
child.arrays << na
|
||||
return child.mkarr(child.arrays.len - 1)
|
||||
}
|
||||
if v.is_struct(x) && v.valid_struct_handle(x) {
|
||||
s := v.structs[v.hand(x)]
|
||||
mut nf := []Field{len: s.fields.len}
|
||||
for i, fld in s.fields {
|
||||
nf[i] = Field{ name: fld.name, val: v.copy_into(mut child, fld.val)! }
|
||||
}
|
||||
child.structs << StructVal{ fields: nf, by_name: child.index_fields(nf) }
|
||||
return child.mkstruct_handle(child.structs.len - 1)
|
||||
}
|
||||
if v.is_closure(x) {
|
||||
return error('spawn: closures capturing composite/closure values are not supported')
|
||||
}
|
||||
return error('spawn: unsupported value type for cross-thread copy')
|
||||
}
|
||||
+10
@@ -34,6 +34,13 @@ struct Handler {
|
||||
sp int // stack pointer right after the handler record
|
||||
}
|
||||
|
||||
// StrBuilder accumulates string parts so repeated concatenation stays linear
|
||||
// (a `+ cat a + b + c` chain reallocates on every step; a builder joins once).
|
||||
struct StrBuilder {
|
||||
mut:
|
||||
parts []string
|
||||
}
|
||||
|
||||
// DbgMode says what the debugger should do after an interactive session ends.
|
||||
enum DbgMode {
|
||||
run // keep going until the next breakpoint (or the end)
|
||||
@@ -66,6 +73,8 @@ mut:
|
||||
structs []StructVal
|
||||
floats []f64
|
||||
closures []Closure
|
||||
builders []StrBuilder
|
||||
jobs []Job
|
||||
stack []i64
|
||||
sp int
|
||||
bp int
|
||||
@@ -79,6 +88,7 @@ mut:
|
||||
lines []obj.LineInfo // debug info: code offset -> source line
|
||||
fns []obj.BinFn // function table (for stack traces)
|
||||
const_strs int // strings[0..const_strs] are bytecode constants, never collected
|
||||
bin obj.Bin // the linked program (kept so spawn() can build isolated child VMs)
|
||||
last_heap int // heap size at the last GC check (allocation trigger)
|
||||
build_root string // directory of the .vrmm build module (build_root() builtin)
|
||||
dbg DbgState // interactive debugger state (vr debug)
|
||||
|
||||
+15
@@ -15,6 +15,7 @@ const tag_struct = u64(2)
|
||||
const tag_arr = u64(3)
|
||||
const tag_float = u64(4)
|
||||
const tag_closure = u64(5)
|
||||
const tag_builder = u64(7)
|
||||
|
||||
// none_val is the sentinel for the `none` literal (and JSON null). Tag 110
|
||||
// is not a valid encoded integer (those are multiples of 8) nor any handle,
|
||||
@@ -50,6 +51,10 @@ fn (mut v Vm) is_closure(x i64) bool {
|
||||
return u64(x) & tag_mask == tag_closure
|
||||
}
|
||||
|
||||
fn (mut v Vm) is_builder(x i64) bool {
|
||||
return u64(x) & tag_mask == tag_builder
|
||||
}
|
||||
|
||||
fn (mut v Vm) is_none(x i64) bool {
|
||||
return x == none_val
|
||||
}
|
||||
@@ -91,6 +96,10 @@ fn (mut v Vm) mkclosure(idx int) i64 {
|
||||
return i64((u64(idx) << 3) | tag_closure)
|
||||
}
|
||||
|
||||
fn (mut v Vm) mkbuilder(idx int) i64 {
|
||||
return i64((u64(idx) << 3) | tag_builder)
|
||||
}
|
||||
|
||||
// push_float interns a float into the pool and returns its tagged handle.
|
||||
fn (mut v Vm) push_float(f f64) i64 {
|
||||
v.floats << f
|
||||
@@ -137,6 +146,11 @@ fn (mut v Vm) valid_closure_handle(x i64) bool {
|
||||
return h >= 0 && h < v.closures.len
|
||||
}
|
||||
|
||||
fn (mut v Vm) valid_builder_handle(x i64) bool {
|
||||
h := v.hand(x)
|
||||
return h >= 0 && h < v.builders.len
|
||||
}
|
||||
|
||||
// valid_handle_for bounds-checks a handle against the pool matching its tag.
|
||||
fn (mut v Vm) valid_handle_for(x i64) bool {
|
||||
return match v.tag(x) {
|
||||
@@ -145,6 +159,7 @@ fn (mut v Vm) valid_handle_for(x i64) bool {
|
||||
tag_arr { v.valid_arr_handle(x) }
|
||||
tag_float { v.valid_float_handle(x) }
|
||||
tag_closure { v.valid_closure_handle(x) }
|
||||
tag_builder { v.valid_builder_handle(x) }
|
||||
else { true }
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user