!cat philosophers.go

!cat philosophers.go | wc

!ps aux | grep root | wc

!cat philosophers.go | grep func

!cat philosophers.go | grep func | wc

go f()

%%writefile printer.go
package main

var printer chan int

func printToScreen() {
    for {print(<- printer)}
}
func main() {
    printer = make(chan int)
    go printToScreen()
    for i := 3; i <= 9; i++ {printer <- i}
}

!go run copy.go

%%writefile copy.go
package main

var west, east chan int

func copyWestEast() {
    for {c := <- west; east <- c}
}
func printToScreen() {
    for {print(<- east)}
}
func main() {
    west = make(chan int)
    east = make(chan int)
    go copyWestEast()
    go printToScreen()
    for i := 3; i <= 9; i++ {west <- i}
}

!go run copy.go

%%writefile puzzle.go
package main

var c1, c2 chan int

func sub() {
    c2 <- 1; println(<- c1)
}
func main() {
    c1 = make(chan int)
    c2 = make(chan int)
    go sub()
    println(<- c1); c2 <- 1
}

!go run puzzle.go

%%writefile gcd1.go
package main

type Arguments struct {x, y int}

var args chan Arguments
var result chan int

func gcd() {
    for {
        a := <- args
        x, y := a.x, a.y
        for x != y {
            if x > y {x = x - y
            } else {y = y - x}
        }
        result <- x
    }
}
func main() {
    args, result = make(chan Arguments), make(chan int)
    go gcd()
    args <- Arguments{20, 15}; println(<- result)
    args <- Arguments{9, 6}; println(<- result)
}

!go run gcd1.go

%%writefile range.go
package main

func main() {
    fib := []int{1, 1, 2, 3, 5, 8, 13}
    for i, v := range(fib) {println(i, v)}
    forecast := "☀️🌨⛄️🌬"
    for i, c := range(forecast) {println(i, c)} // caution
    days := map[string]int{"mon":0, "tue":1, "wed":2, "thu":3, "fri":4, "sat":5, "sun":6}
    for s, n := range(days) {println(s, n)}
}

!go run range.go

%%writefile gcd2.go
package main
import "time"

type Arguments struct {x, y int}

var args chan Arguments
var result chan int

func gcd() {
    for a := range args {
        x, y := a.x, a.y
        for x != y {
            if x > y {x = x - y}
            else {y = y - x}
        }
        result <- x
    }
    println("gcd done");
}
func main() {
    args, result = make(chan Arguments), make(chan int)
    go gcd()
    args <- Arguments{20, 15}; println(<- result)
    args <- Arguments{9, 6}; println(<- result)
    close(args); time.Sleep(time.Second)
    println("main done")
}

!go run gcd2.go

%%writefile gcd3.go
package main

type Arguments struct {x, y int}

var args chan Arguments
var result chan int

func gcd() {
    for a := range args {
        x, y := a.x, a.y
        for x != y {
            if x > y {x = x - y
            } else {y = y - x}
        }
        result <- x
    }
    println("gcd done")
    result <- -1
}
func main() {
    args, result = make(chan Arguments), make(chan int)
    go gcd()
    args <- Arguments{20, 15}; println(<- result)
    args <- Arguments{9, 6}; println(<- result)
    close(args); <- result
    println("main done")
}

!go run gcd3.go

x, ok = <- c

%%writefile closed.go
package main
import "time"

var c, d chan int

func printing() {
    for {
        x, ok := <- c
        if !ok {break}
        println(x)
    }
    for x := range(d) {
        println(x)
    }
    println("done printing")
}
func main() {
    c, d = make(chan int), make(chan int)
    go printing()
    c <- 3; c <- 5; close(c)
    d <- 7; d <- 9; close(d)
    time.Sleep(time.Second)
}

!go run closed.go

%%writefile eratosthenes.go

package main

const N = 100
const L = 15 // length of chain of filters
const EOS = -1 // end of stream

var c [L] chan int

func sieve(i int) {
    if i == 0 {
        println("prime", 0, 2) // 0-th prime is 2
        for j := 3; j < N; j += 2 {c[0] <- j}
        c[0] <- EOS
    } else {
        p := <- c[i - 1]; println("prime", i, p) // i-th prime is p
        n := <- c[i - 1]
        for n != EOS {
            if n % p != 0 {c[i] <- n}
            n = <- c[i - 1]
        }
        c[i] <- EOS
    }
}
func main() {
    for i := 0; i < L; i++ {c[i] = make(chan int)}
    for i := 0; i < L; i++ {go sieve(i)}
    <- c[L - 1] // receiving EOS
}

!go run eratosthenes.go

func scalarmult(v int, in, mid, out chan int) {
    for {out <- v * <- in + <- mid}
}

%%writefile vectormult.go
package main

const N = 4

var in [N] chan int
var out chan int

func scalarmult(v int, in, mid, out chan int) {
    for {out <- v * <- in + <- mid}
}
func vectormult(v [N] int) {
    var mid [N] chan int
    for i := 0; i < N; i++ {mid[i] = make(chan int)}
    for i := 0; i < N - 1; i++ {go scalarmult(v[i], in[i], mid[i], mid[i + 1])}
    go scalarmult(v[N - 1], in[N - 1], mid[N - 1], out)
    for {mid[0] <- 0}
}
func genstream() {
    for r := 0; r < 20; r++ {
        for i := 0; i < N; i++ {in[i] <- r}
    }
}
func main() {
    for i := 0; i < N; i++ {in[i] = make(chan int)}
    out = make(chan int)
    go genstream()
    go vectormult([4]int{3, 7, 8, 5})
    for {println(<- out)}

!go run vectormult.go

select {
    case x = <- c: // receives x from channel c
    case y := <- c: // declares y and receives y from channel c
    case z, ok = <- c: // succeeds and ok set to false if c is closed
    case c <- 7: // send 7 over channel c
}

%%writefile zerosandones.go
package main

var c chan int

func send0and1() {
    for {
        select {
            case c <- 0:
            case c <- 1:
        }
    }
}
func main() {
    c = make(chan int)
    go send0and1()
    for i := 0; i < 100; i++ {print(<- c)}
}

!go run zerosandones.go

%%writefile bufferedcopy.go
package main

var west, east chan int

func copyWestEast() {
    const C = 10
    var buffer [C] int
    var in, out, n int
    for {
        if n == C { // buffer full, send to east
            east <- buffer[out]; out, n = (out + 1) % C, n - 1
        } else if n == 0 { // buffer empty, receive from west
            buffer[in] = <- west;   in, n = (in + 1) % C, n + 1
        } else { // either send to east or receive from west
            select {
                case east <- buffer[out]: out, n = (out + 1) % C, n - 1
                case buffer[in] = <- west: in, n = (in + 1) % C, n + 1
            }
        }
    }
}
func printToScreen() {
    for v := range(east) {print(v, " ")}
}
func main() {
    west = make(chan int)
    east = make(chan int)
    go copyWestEast()
    go printToScreen()
    for i := 0; i < 30; i++ {west <- i}
}

!go run bufferedcopy.go

%%writefile philosophers.go
package main
import ("time"; "math/rand")

var left, right [5] chan bool
var ph [5] string

func philosopherState(i int, s string) {
    ph[i] = s; println(ph[0], ph[1], ph[2], ph[3], ph[4])
    time.Sleep(time.Second * time.Duration(rand.Int() % 4)) // sleep between 0 and 3 sec
}
func fork(i int) {
    for {
        select {
            case <-left[i]: <- left[i]
            case <-right[i]: <- right[i]
        }
    }
}
func philosopher(i int) {
    for {
        philosopherState(i, "thinks")
        right[i] <- true; left[(i + 1) % 5] <- true
        philosopherState(i, "eats  ")
        right[i] <- false; left[(i + 1) % 5] <- false
    }
}
func main() {
    for i := 0; i < 5; i++ {left[i], right[i], ph[i] = make(chan bool), make(chan bool), "thinks"}
    for i := 0; i < 5; i++ {go fork(i); go philosopher(i)}
    select {}
}

!go run philosophers.go

%%writefile sorter.go

package main

import ("fmt"; "time"; "math/rand")

const EOS = -1

const N = 1 << 17  // N = 2**16
const R = 2000     // number of repetitions

func printer(in chan int) {
    for {//j := 0; j < R * (N + 1); j++ {
        v := <- in
        if v == EOS {println()
        } else {print(v, " ")
        }
    }
}

func merger(in1, in2 chan int, out chan int) {
    for {
        v1, v2 := <- in1, <- in2
        for v1 != EOS || v2 != EOS {
            if v1 != EOS && v2 != EOS {
                if v1 <= v2 {out <- v1; v1 = <- in1
                } else {out <- v2; v2 = <- in2
                } 
            } else if v1 != EOS {
                out <- v1; v1 = <- in1
            } else {
                out <- v2; v2 = <- in2
            }
        }
        out <- EOS
    }
}

func main() {
    start := time.Now()
    
    var c [2 * N] chan int
    for i := range c {c[i] = make(chan int, 4)}
    
    for i := 1; i < N; i++ {go merger(c[i * 2], c[i * 2 + 1], c[i])}

    go func () {
        for j := 0; j < R; j++ {
            for i := N; i < 2 * N; i++ {c[i] <- rand.Int()%100; c[i] <- EOS} 
        }
    } ()
    
    //printer(c[1]) // comment out one of these lines 
    for k := 0; k < R; k++ {<- c[1]}
    
    fmt.Println(time.Since(start))
}

!go run sorter.go

%%writefile allocator.go
package main

import ("time"; "math/rand")

func allocator(capacity int, request chan chan int, release chan int) {
    avail := make([]bool, capacity)
    for i := 0; i < capacity; i++ {avail[i] = true}
    next := 0
    for {
        if next < capacity {
            select {
            case reply := <- request: {reply <- next; avail[next] = false}
            case unit := <- release: avail[unit] = true
            }
        } else {
            unit := <- release; avail[unit] = true
        }
        // now comes the computation that takes place between client communication
        for i := 0; i < capacity; i++ {
            if avail[i] {print(" ")} else {print("X")}
        }
        println();
        next = 0; for next < capacity && !avail[next] {next++}
    }
}

func client(i int, request chan chan int, release chan int) {
    reply := make(chan int)
    for {
        request <- reply; unit := <- reply
        time.Sleep(time.Second * time.Duration(rand.Int() % 5)) // sleep between 0 and 4 sec
        release <- unit
    }
}
func main() {
    request, release := make(chan chan int), make(chan int)
    go allocator(5, request, release) // 5 resources
    for i := 0; i < 10; i++ {go client(i, request, release)} // 10 clients
    select {}
}

!go run allocator.go

%%writefile keyboard.go
package main
import ("time"; "fmt")

func main() {
    abort, enter := make (chan bool), make(chan string)
    go func() {
        var s string
        fmt.Scanln(&s)
        enter <- s
    } ()
    go func() {
        time.Sleep(3 * time.Second)
        abort <- true
    } ()
    fmt.Println("Enter within 3 seconds:")
    select {
        case s := <- enter: fmt.Println("You entered:", s)
        case <- abort: fmt.Println("Timeout")
    }
}

%%writefile timeout.go
package main
import ("time"; "math/rand"; "fmt")

var tick chan bool
var done chan bool

func ticker() { 
    for {
        time.Sleep(time.Second)
        tick <- true
        // fmt.Println(time.Now())
    }
}
func worker() {
    for { // "work" randomly 0 to 2 sec
        time.Sleep(time.Second * time.Duration(rand.Int() % 3))
        done <- true
    }
}
func main() {
    rand.Seed(time.Now().UnixNano())
    tick = make(chan bool); go ticker()
    done = make(chan bool); go worker()
    for {
        select {
            case <- done: fmt.Println("done"); <- tick
            case <- tick: fmt.Println("timeout"); return
        }
    }
}

!go run timeout.go

%%writefile ticker.go
package main
import ("time"; "math/rand")

var done chan bool

func worker() {
    for { // "work" 0 to 2 sec
        time.Sleep(time.Second * time.Duration(rand.Int() % 3))
        done <- true
    }
}
func main() {
    rand.Seed(time.Now().UnixNano())
    ticker := time.NewTicker(time.Second)
    done = make(chan bool); go worker()
    for {
        select {
            case <- done: println("done"); <- ticker.C
            case <- ticker.C: println("timeout"); return
        }
    }
}

!go run ticker.go

Message Passing¶

Emil Sekerinski, McMaster University, Fall 2019¶

Synchronous Message Passing¶

Guarded Communication¶

Types of Processes¶

Unix Pipes and Filters¶

Prime Number Generation¶

Processes and Channels in Go¶

Vector Multiplication¶

Guarded Communication in Go¶

Bounded Buffer with Go¶

Dining Philosophers in Go¶

Asynchronous Message Passing¶

Laws of Programs¶

Synchronous vs Asynchronous Channels¶

Sorting Network¶

Active Monitors¶

Resource Allocator in Go¶

Timing¶