* - tour - touring some programming systems

diff options

author	elioat <elioat@tilde.institute>	2024-10-30 23:16:53 -0400
committer	elioat <elioat@tilde.institute>	2024-10-30 23:16:53 -0400
commit	9aba1d9aa7a212a14862a0aecf1e3495fd18e13d (patch)
tree	fd5f3637c4a415fbb0f8d0d415e2ce5fb570be3d /js/games/nluqo.github.io/~bh/v1ch14/phonetree2.jpg
parent	c8a8b22d8749ccafd89f058a9c675bef1b6e54bd (diff)
download	tour-9aba1d9aa7a212a14862a0aecf1e3495fd18e13d.tar.gz

Diffstat (limited to 'js/games/nluqo.github.io/~bh/v1ch14/phonetree2.jpg')

0 files changed, 0 insertions, 0 deletions

# Mu synchronizes using channels rather than locks, like Erlang and Go. # # The two ends of a channel will usually belong to different routines, but # each end should only be used by a single one. Don't try to read from or # write to it from multiple routines at once. # # The key property of channels is that writing to a full channel or reading # from an empty one will put the current routine in 'waiting' state until the # operation can be completed. scenario channel [ run [ 1:address:channel <- new-channel 3/capacity 1:address:channel <- write 1:address:channel, 34 2:number, 1:address:channel <- read 1:address:channel ] memory-should-contain [ 2 <- 34 ] ] container channel [ # To avoid locking, writer and reader will never write to the same location. # So channels will include fields in pairs, one for the writer and one for the # reader. first-full:number # for write first-free:number # for read # A circular buffer contains values from index first-full up to (but not # including) index first-empty. The reader always modifies it at first-full, # while the writer always modifies it at first-empty. data:address:array:location ] # result:address:channel <- new-channel capacity:number recipe new-channel [ local-scope # result = new channel result:address:channel <- new channel:type # result.first-full = 0 full:address:number <- get-address *result, first-full:offset *full <- copy 0 # result.first-free = 0 free:address:number <- get-address *result, first-free:offset *free <- copy 0 # result.data = new location[ingredient+1] capacity:number <- next-ingredient capacity <- add capacity, 1 # unused slot for 'full?' below dest:address:address:array:location <- get-address *result, data:offset *dest <- new location:type, capacity reply result ] # chan <- write chan:address:channel, val:location recipe write [ local-scope chan:address:channel <- next-ingredient val:location <- next-ingredient { # block if chan is full full:boolean <- channel-full? chan break-unless full full-address:address:number <- get-address *chan, first-full:offset wait-for-location *full-address } # store val circular-buffer:address:array:location <- get *chan, data:offset free:address:number <- get-address *chan, first-free:offset dest:address:location <- index-address *circular-buffer, *free *dest <- copy val # mark its slot as filled *free <- add *free, 1 { # wrap free around to 0 if necessary len:number <- length *circular-buffer at-end?:boolean <- greater-or-equal *free, len break-unless at-end? *free <- copy 0 } reply chan/same-as-ingredient:0 ] # result:location, chan <- read chan:address:channel recipe read [ local-scope chan:address:channel <- next-ingredient { # block if chan is empty empty?:boolean <- channel-empty? chan break-unless empty? free-address:address:number <- get-address *chan, first-free:offset wait-for-location *free-address } # read result full:address:number <- get-address *chan, first-full:offset circular-buffer:address:array:location <- get *chan, data:offset result:location <- index *circular-buffer, *full # mark its slot as empty *full <- add *full, 1 { # wrap full around to 0 if necessary len:number <- length *circular-buffer at-end?:boolean <- greater-or-equal *full, len break-unless at-end? *full <- copy 0 } reply result, chan/same-as-ingredient:0 ] recipe clear-channel [ local-scope chan:address:channel <- next-ingredient { empty?:boolean <- channel-empty? chan break-if empty? _, chan <- read chan } reply chan/same-as-ingredient:0 ] scenario channel-initialization [ run [ 1:address:channel <- new-channel 3/capacity 2:number <- get *1:address:channel, first-full:offset 3:number <- get *1:address:channel, first-free:offset ] memory-should-contain [ 2 <- 0 # first-full 3 <- 0 # first-free ] ] scenario channel-write-increments-free [ run [ 1:address:channel <- new-channel 3/capacity 1:address:channel <- write 1:address:channel, 34 2:number <- get *1:address:channel, first-full:offset 3:number <- get *1:address:channel, first-free:offset ] memory-should-contain [ 2 <- 0 # first-full 3 <- 1 # first-free ] ] scenario channel-read-increments-full [ run [ 1:address:channel <- new-channel 3/capacity 1:address:channel <- write 1:address:channel, 34 _, 1:address:channel <- read 1:address:channel 2:number <- get *1:address:channel, first-full:offset 3:number <- get *1:address:channel, first-free:offset ] memory-should-contain [ 2 <- 1 # first-full 3 <- 1 # first-free ] ] scenario channel-wrap [ run [ # channel with just 1 slot 1:address:channel <- new-channel 1/capacity # write and read a value 1:address:channel <- write 1:address:channel, 34 _, 1:address:channel <- read 1:address:channel # first-free will now be 1 2:number <- get *1:address:channel, first-free:offset 3:number <- get *1:address:channel, first-free:offset # write second value, verify that first-free wraps 1:address:channel <- write 1:address:channel, 34 4:number <- get *1:address:channel, first-free:offset # read second value, verify that first-full wraps _, 1:address:channel <- read 1:address:channel 5:number <- get *1:address:channel, first-full:offset ] memory-should-contain [ 2 <- 1 # first-free after first write 3 <- 1 # first-full after first read 4 <- 0 # first-free after second write, wrapped 5 <- 0 # first-full after second read, wrapped ] ] ## helpers # An empty channel has first-empty and first-full both at the same value. recipe channel-empty? [ local-scope chan:address:channel <- next-ingredient # return chan.first-full == chan.first-free full:number <- get *chan, first-full:offset free:number <- get *chan, first-free:offset result:boolean <- equal full, free reply result ] # A full channel has first-empty just before first-full, wasting one slot. # (Other alternatives: https://en.wikipedia.org/wiki/Circular_buffer#Full_.2F_Empty_Buffer_Distinction) recipe channel-full? [ local-scope chan:address:channel <- next-ingredient # tmp = chan.first-free + 1 tmp:number <- get *chan, first-free:offset tmp <- add tmp, 1 { # if tmp == chan.capacity, tmp = 0 len:number <- channel-capacity chan at-end?:boolean <- greater-or-equal tmp, len break-unless at-end? tmp <- copy 0 } # return chan.first-full == tmp full:number <- get *chan, first-full:offset result:boolean <- equal full, tmp reply result ] # result:number <- channel-capacity chan:address:channel recipe channel-capacity [ local-scope chan:address:channel <- next-ingredient q:address:array:location <- get *chan, data:offset result:number <- length *q reply result ] scenario channel-new-empty-not-full [ run [ 1:address:channel <- new-channel 3/capacity 2:boolean <- channel-empty? 1:address:channel 3:boolean <- channel-full? 1:address:channel ] memory-should-contain [ 2 <- 1 # empty? 3 <- 0 # full? ] ] scenario channel-write-not-empty [ run [ 1:address:channel <- new-channel 3/capacity 1:address:channel <- write 1:address:channel, 34 2:boolean <- channel-empty? 1:address:channel 3:boolean <- channel-full? 1:address:channel ] memory-should-contain [ 2 <- 0 # empty? 3 <- 0 # full? ] ] scenario channel-write-full [ run [ 1:address:channel <- new-channel 1/capacity 1:address:channel <- write 1:address:channel, 34 2:boolean <- channel-empty? 1:address:channel 3:boolean <- channel-full? 1:address:channel ] memory-should-contain [ 2 <- 0 # empty? 3 <- 1 # full? ] ] scenario channel-read-not-full [ run [ 1:address:channel <- new-channel 1/capacity 1:address:channel <- write 1:address:channel, 34 _, 1:address:channel <- read 1:address:channel 2:boolean <- channel-empty? 1:address:channel 3:boolean <- channel-full? 1:address:channel ] memory-should-contain [ 2 <- 1 # empty? 3 <- 0 # full? ] ] # helper for channels of characters in particular # out <- buffer-lines in:address:channel, out:address:channel recipe buffer-lines [ local-scope in:address:channel <- next-ingredient out:address:channel <- next-ingredient # repeat forever { line:address:buffer <- new-buffer, 30 # read characters from 'in' until newline, copy into line { +next-character c:character, in <- read in # drop a character on backspace { # special-case: if it's a backspace backspace?:boolean <- equal c, 8 break-unless backspace? # drop previous character { buffer-length:address:number <- get-address *line, length:offset buffer-empty?:boolean <- equal *buffer-length, 0 break-if buffer-empty? *buffer-length <- subtract *buffer-length, 1 } # and don't append this one loop +next-character:label } # append anything else line <- buffer-append line, c line-done?:boolean <- equal c, 10/newline break-if line-done? # stop buffering on eof (currently only generated by fake console) eof?:boolean <- equal c, 0/eof break-if eof? loop } # copy line into 'out' i:number <- copy 0 line-contents:address:array:character <- get *line, data:offset max:number <- get *line, length:offset { done?:boolean <- greater-or-equal i, max break-if done? c:character <- index *line-contents, i out <- write out, c i <- add i, 1 loop } loop } reply out/same-as-ingredient:1 ] scenario buffer-lines-blocks-until-newline [ run [ 1:address:channel/stdin <- new-channel 10/capacity 2:address:channel/buffered-stdin <- new-channel 10/capacity 3:boolean <- channel-empty? 2:address:channel/buffered-stdin assert 3:boolean, [ F buffer-lines-blocks-until-newline: channel should be empty after init] # buffer stdin into buffered-stdin, try to read from buffered-stdin 4:number/buffer-routine <- start-running buffer-lines:recipe, 1:address:channel/stdin, 2:address:channel/buffered-stdin wait-for-routine 4:number/buffer-routine 5:boolean <- channel-empty? 2:address:channel/buffered-stdin assert 5:boolean, [ F buffer-lines-blocks-until-newline: channel should be empty after buffer-lines bring-up] # write 'a' 1:address:channel <- write 1:address:channel, 97/a restart 4:number/buffer-routine wait-for-routine 4:number/buffer-routine 6:boolean <- channel-empty? 2:address:channel/buffered-stdin assert 6:boolean, [ F buffer-lines-blocks-until-newline: channel should be empty after writing 'a'] # write 'b' 1:address:channel <- write 1:address:channel, 98/b restart 4:number/buffer-routine wait-for-routine 4:number/buffer-routine 7:boolean <- channel-empty? 2:address:channel/buffered-stdin assert 7:boolean, [ F buffer-lines-blocks-until-newline: channel should be empty after writing 'b'] # write newline 1:address:channel <- write 1:address:channel, 10/newline restart 4:number/buffer-routine wait-for-routine 4:number/buffer-routine 8:boolean <- channel-empty? 2:address:channel/buffered-stdin 9:boolean/completed? <- not 8:boolean assert 9:boolean/completed?, [ F buffer-lines-blocks-until-newline: channel should contain data after writing newline] trace 1, [test], [reached end] ] trace-should-contain [ test: reached end ] ]


context:
space:
mode: