Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2024-02-02 18:09
📄 doubleselect.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test the situation in which two cases of a select can // both end up running. See http://codereview.appspot.com/180068. package main import ( "flag" "runtime" ) var iterations int = flag.Int("n", 100000, "number of iterations") // sender sends a counter to one of four different channels. If two // cases both end up running in the same iteration, the same value will be sent // to two different channels. func sender(n int, c1, c2, c3, c4 chan<- int) { defer close(c1) defer close(c2) defer close(c3) defer close(c4) for i := 0; i < n; i++ { select { case c1 <- i: case c2 <- i: case c3 <- i: case c4 <- i: } } } // mux receives the values from sender and forwards them onto another channel. // It would be simpler to just have sender's four cases all be the same // channel, but this doesn't actually trigger the bug. func mux(out chan<- int, in <-chan int, done chan<- bool) { for v := range in { out <- v } done <- true } // recver gets a steam of values from the four mux's and checks for duplicates. func recver(in <-chan int) { seen := make(map[int]bool) for v := range in { if _, ok := seen[v]; ok { println("got duplicate value: ", v) panic("fail") } seen[v] = true } } func main() { runtime.GOMAXPROCS(2) flag.Parse() c1 := make(chan int) c2 := make(chan int) c3 := make(chan int) c4 := make(chan int) done := make(chan bool) cmux := make(chan int) go sender(iterations, c1, c2, c3, c4) go mux(cmux, c1, done) go mux(cmux, c2, done) go mux(cmux, c3, done) go mux(cmux, c4, done) go func() { <-done <-done <-done <-done close(cmux) }() // We keep the recver because it might catch more bugs in the future. // However, the result of the bug linked to at the top is that we'll // end up panicking with: "throw: bad g->status in ready". recver(cmux) }	1.96 KB	2024-02-02 18:09
📄 fifo.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test that unbuffered channels act as pure fifos. package main import "os" const N = 10 func AsynchFifo() { ch := make(chan int, N) for i := 0; i < N; i++ { ch <- i } for i := 0; i < N; i++ { if <-ch != i { print("bad receive\n") os.Exit(1) } } } func Chain(ch <-chan int, val int, in <-chan int, out chan<- int) { <-in if <-ch != val { panic(val) } out <- 1 } // thread together a daisy chain to read the elements in sequence func SynchFifo() { ch := make(chan int) in := make(chan int) start := in for i := 0; i < N; i++ { out := make(chan int) go Chain(ch, i, in, out) in = out } start <- 0 for i := 0; i < N; i++ { ch <- i } <-in } func main() { AsynchFifo() SynchFifo() }	896 B	2024-02-02 18:09
📄 goroutines.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Torture test for goroutines. // Make a lot of goroutines, threaded together, and tear them down cleanly. package main import ( "os" "strconv" ) func f(left, right chan int) { left <- <-right } func main() { var n = 10000 if len(os.Args) > 1 { var err error n, err = strconv.Atoi(os.Args[1]) if err != nil { print("bad arg\n") os.Exit(1) } } leftmost := make(chan int) right := leftmost left := leftmost for i := 0; i < n; i++ { right = make(chan int) go f(left, right) left = right } go func(c chan int) { c <- 1 }(right) <-leftmost }	743 B	2024-02-02 18:09
📄 nonblock.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test channel operations that test for blocking. // Use several sizes and types of operands. package main import "runtime" import "time" func i32receiver(c chan int32, strobe chan bool) { if <-c != 123 { panic("i32 value") } strobe <- true } func i32sender(c chan int32, strobe chan bool) { c <- 234 strobe <- true } func i64receiver(c chan int64, strobe chan bool) { if <-c != 123456 { panic("i64 value") } strobe <- true } func i64sender(c chan int64, strobe chan bool) { c <- 234567 strobe <- true } func breceiver(c chan bool, strobe chan bool) { if !<-c { panic("b value") } strobe <- true } func bsender(c chan bool, strobe chan bool) { c <- true strobe <- true } func sreceiver(c chan string, strobe chan bool) { if <-c != "hello" { panic("s value") } strobe <- true } func ssender(c chan string, strobe chan bool) { c <- "hello again" strobe <- true } var ticker = time.Tick(10 * 1000) // 10 us func sleep() { <-ticker <-ticker runtime.Gosched() runtime.Gosched() runtime.Gosched() } const maxTries = 10000 // Up to 100ms per test. func main() { var i32 int32 var i64 int64 var b bool var s string var sync = make(chan bool) for buffer := 0; buffer < 2; buffer++ { c32 := make(chan int32, buffer) c64 := make(chan int64, buffer) cb := make(chan bool, buffer) cs := make(chan string, buffer) select { case i32 = <-c32: panic("blocked i32sender") default: } select { case i64 = <-c64: panic("blocked i64sender") default: } select { case b = <-cb: panic("blocked bsender") default: } select { case s = <-cs: panic("blocked ssender") default: } go i32receiver(c32, sync) try := 0 Send32: for { select { case c32 <- 123: break Send32 default: try++ if try > maxTries { println("i32receiver buffer=", buffer) panic("fail") } sleep() } } <-sync go i32sender(c32, sync) if buffer > 0 { <-sync } try = 0 Recv32: for { select { case i32 = <-c32: break Recv32 default: try++ if try > maxTries { println("i32sender buffer=", buffer) panic("fail") } sleep() } } if i32 != 234 { panic("i32sender value") } if buffer == 0 { <-sync } go i64receiver(c64, sync) try = 0 Send64: for { select { case c64 <- 123456: break Send64 default: try++ if try > maxTries { panic("i64receiver") } sleep() } } <-sync go i64sender(c64, sync) if buffer > 0 { <-sync } try = 0 Recv64: for { select { case i64 = <-c64: break Recv64 default: try++ if try > maxTries { panic("i64sender") } sleep() } } if i64 != 234567 { panic("i64sender value") } if buffer == 0 { <-sync } go breceiver(cb, sync) try = 0 SendBool: for { select { case cb <- true: break SendBool default: try++ if try > maxTries { panic("breceiver") } sleep() } } <-sync go bsender(cb, sync) if buffer > 0 { <-sync } try = 0 RecvBool: for { select { case b = <-cb: break RecvBool default: try++ if try > maxTries { panic("bsender") } sleep() } } if !b { panic("bsender value") } if buffer == 0 { <-sync } go sreceiver(cs, sync) try = 0 SendString: for { select { case cs <- "hello": break SendString default: try++ if try > maxTries { panic("sreceiver") } sleep() } } <-sync go ssender(cs, sync) if buffer > 0 { <-sync } try = 0 RecvString: for { select { case s = <-cs: break RecvString default: try++ if try > maxTries { panic("ssender") } sleep() } } if s != "hello again" { panic("ssender value") } if buffer == 0 { <-sync } } }	3.93 KB	2024-02-02 18:09
📄 perm.go // errorcheck // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test various correct and incorrect permutations of send-only, // receive-only, and bidirectional channels. // Does not compile. package main var ( cr <-chan int cs chan<- int c chan int ) func main() { cr = c // ok cs = c // ok c = cr // ERROR "illegal types\|incompatible\|cannot" c = cs // ERROR "illegal types\|incompatible\|cannot" cr = cs // ERROR "illegal types\|incompatible\|cannot" cs = cr // ERROR "illegal types\|incompatible\|cannot" var n int <-n // ERROR "receive from non-chan\|expected channel" n <- 2 // ERROR "send to non-chan\|must be channel" c <- 0 // ok <-c // ok x, ok := <-c // ok _, _ = x, ok cr <- 0 // ERROR "send" <-cr // ok x, ok = <-cr // ok _, _ = x, ok cs <- 0 // ok <-cs // ERROR "receive" x, ok = <-cs // ERROR "receive" _, _ = x, ok select { case c <- 0: // ok case x := <-c: // ok _ = x case cr <- 0: // ERROR "send" case x := <-cr: // ok _ = x case cs <- 0: // ok case x := <-cs: // ERROR "receive" _ = x } for _ = range cs { // ERROR "receive" } for range cs { // ERROR "receive" } close(c) close(cs) close(cr) // ERROR "receive" close(n) // ERROR "invalid operation.*non-chan type\|must be channel\|non-channel" }	1.39 KB	2024-02-02 18:09
📄 powser1.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test concurrency primitives: power series. // Power series package // A power series is a channel, along which flow rational // coefficients. A denominator of zero signifies the end. // Original code in Newsqueak by Doug McIlroy. // See Squinting at Power Series by Doug McIlroy, // https://swtch.com/~rsc/thread/squint.pdf package main import "os" type rat struct { num, den int64 // numerator, denominator } func (u rat) pr() { if u.den == 1 { print(u.num) } else { print(u.num, "/", u.den) } print(" ") } func (u rat) eq(c rat) bool { return u.num == c.num && u.den == c.den } type dch struct { req chan int dat chan rat nam int } type dch2 [2]dch var chnames string var chnameserial int var seqno int func mkdch() dch { c := chnameserial % len(chnames) chnameserial++ d := new(dch) d.req = make(chan int) d.dat = make(chan rat) d.nam = c return d } func mkdch2() dch2 { d2 := new(dch2) d2[0] = mkdch() d2[1] = mkdch() return d2 } // split reads a single demand channel and replicates its // output onto two, which may be read at different rates. // A process is created at first demand for a rat and dies // after the rat has been sent to both outputs. // When multiple generations of split exist, the newest // will service requests on one channel, which is // always renamed to be out[0]; the oldest will service // requests on the other channel, out[1]. All generations but the // newest hold queued data that has already been sent to // out[0]. When data has finally been sent to out[1], // a signal on the release-wait channel tells the next newer // generation to begin servicing out[1]. func dosplit(in dch, out dch2, wait chan int) { both := false // do not service both channels select { case <-out[0].req: case <-wait: both = true select { case <-out[0].req: case <-out[1].req: out[0], out[1] = out[1], out[0] } } seqno++ in.req <- seqno release := make(chan int) go dosplit(in, out, release) dat := <-in.dat out[0].dat <- dat if !both { <-wait } <-out[1].req out[1].dat <- dat release <- 0 } func split(in dch, out dch2) { release := make(chan int) go dosplit(in, out, release) release <- 0 } func put(dat rat, out dch) { <-out.req out.dat <- dat } func get(in dch) rat { seqno++ in.req <- seqno return <-in.dat } // Get one rat from each of n demand channels func getn(in []dch) []rat { n := len(in) if n != 2 { panic("bad n in getn") } req := new([2]chan int) dat := new([2]chan rat) out := make([]rat, 2) var i int var it rat for i = 0; i < n; i++ { req[i] = in[i].req dat[i] = nil } for n = 2 * n; n > 0; n-- { seqno++ select { case req[0] <- seqno: dat[0] = in[0].dat req[0] = nil case req[1] <- seqno: dat[1] = in[1].dat req[1] = nil case it = <-dat[0]: out[0] = it dat[0] = nil case it = <-dat[1]: out[1] = it dat[1] = nil } } return out } // Get one rat from each of 2 demand channels func get2(in0 dch, in1 dch) []rat { return getn([]dch{in0, in1}) } func copy(in dch, out dch) { for { <-out.req out.dat <- get(in) } } func repeat(dat rat, out dch) { for { put(dat, out) } } type PS dch // power series type PS2 [2]PS // pair of power series var Ones PS var Twos PS func mkPS() dch { return mkdch() } func mkPS2() dch2 { return mkdch2() } // Conventions // Upper-case for power series. // Lower-case for rationals. // Input variables: U,V,... // Output variables: ...,Y,Z // Integer gcd; needed for rational arithmetic func gcd(u, v int64) int64 { if u < 0 { return gcd(-u, v) } if u == 0 { return v } return gcd(v%u, u) } // Make a rational from two ints and from one int func i2tor(u, v int64) rat { g := gcd(u, v) var r rat if v > 0 { r.num = u / g r.den = v / g } else { r.num = -u / g r.den = -v / g } return r } func itor(u int64) rat { return i2tor(u, 1) } var zero rat var one rat // End mark and end test var finis rat func end(u rat) int64 { if u.den == 0 { return 1 } return 0 } // Operations on rationals func add(u, v rat) rat { g := gcd(u.den, v.den) return i2tor(u.num(v.den/g)+v.num(u.den/g), u.den(v.den/g)) } func mul(u, v rat) rat { g1 := gcd(u.num, v.den) g2 := gcd(u.den, v.num) var r rat r.num = (u.num / g1) (v.num / g2) r.den = (u.den / g2) * (v.den / g1) return r } func neg(u rat) rat { return i2tor(-u.num, u.den) } func sub(u, v rat) rat { return add(u, neg(v)) } func inv(u rat) rat { // invert a rat if u.num == 0 { panic("zero divide in inv") } return i2tor(u.den, u.num) } // print eval in floating point of PS at x=c to n terms func evaln(c rat, U PS, n int) { xn := float64(1) x := float64(c.num) / float64(c.den) val := float64(0) for i := 0; i < n; i++ { u := get(U) if end(u) != 0 { break } val = val + xfloat64(u.num)/float64(u.den) xn = xn x } print(val, "\n") } // Print n terms of a power series func printn(U PS, n int) { done := false for ; !done && n > 0; n-- { u := get(U) if end(u) != 0 { done = true } else { u.pr() } } print(("\n")) } // Evaluate n terms of power series U at x=c func eval(c rat, U PS, n int) rat { if n == 0 { return zero } y := get(U) if end(y) != 0 { return zero } return add(y, mul(c, eval(c, U, n-1))) } // Power-series constructors return channels on which power // series flow. They start an encapsulated generator that // puts the terms of the series on the channel. // Make a pair of power series identical to a given power series func Split(U PS) dch2 { UU := mkdch2() go split(U, UU) return UU } // Add two power series func Add(U, V PS) PS { Z := mkPS() go func() { var uv []rat for { <-Z.req uv = get2(U, V) switch end(uv[0]) + 2end(uv[1]) { case 0: Z.dat <- add(uv[0], uv[1]) case 1: Z.dat <- uv[1] copy(V, Z) case 2: Z.dat <- uv[0] copy(U, Z) case 3: Z.dat <- finis } } }() return Z } // Multiply a power series by a constant func Cmul(c rat, U PS) PS { Z := mkPS() go func() { done := false for !done { <-Z.req u := get(U) if end(u) != 0 { done = true } else { Z.dat <- mul(c, u) } } Z.dat <- finis }() return Z } // Subtract func Sub(U, V PS) PS { return Add(U, Cmul(neg(one), V)) } // Multiply a power series by the monomial x^n func Monmul(U PS, n int) PS { Z := mkPS() go func() { for ; n > 0; n-- { put(zero, Z) } copy(U, Z) }() return Z } // Multiply by x func Xmul(U PS) PS { return Monmul(U, 1) } func Rep(c rat) PS { Z := mkPS() go repeat(c, Z) return Z } // Monomial cx^n func Mon(c rat, n int) PS { Z := mkPS() go func() { if c.num != 0 { for ; n > 0; n = n - 1 { put(zero, Z) } put(c, Z) } put(finis, Z) }() return Z } func Shift(c rat, U PS) PS { Z := mkPS() go func() { put(c, Z) copy(U, Z) }() return Z } // simple pole at 1: 1/(1-x) = 1 1 1 1 1 ... // Convert array of coefficients, constant term first // to a (finite) power series / func Poly(a []rat) PS { Z:=mkPS() begin func(a []rat, Z PS) { j:=0 done:=0 for j=len(a); !done&&j>0; j=j-1) if(a[j-1].num!=0) done=1 i:=0 for(; i<j; i=i+1) put(a[i],Z) put(finis,Z) }() return Z } / // Multiply. The algorithm is // let U = u + xUU // let V = v + xVV // then UV = uv + x(uVV+vUU) + xxUUVV func Mul(U, V PS) PS { Z := mkPS() go func() { <-Z.req uv := get2(U, V) if end(uv[0]) != 0 \|\| end(uv[1]) != 0 { Z.dat <- finis } else { Z.dat <- mul(uv[0], uv[1]) UU := Split(U) VV := Split(V) W := Add(Cmul(uv[0], VV[0]), Cmul(uv[1], UU[0])) <-Z.req Z.dat <- get(W) copy(Add(W, Mul(UU[1], VV[1])), Z) } }() return Z } // Differentiate func Diff(U PS) PS { Z := mkPS() go func() { <-Z.req u := get(U) if end(u) == 0 { done := false for i := 1; !done; i++ { u = get(U) if end(u) != 0 { done = true } else { Z.dat <- mul(itor(int64(i)), u) <-Z.req } } } Z.dat <- finis }() return Z } // Integrate, with const of integration func Integ(c rat, U PS) PS { Z := mkPS() go func() { put(c, Z) done := false for i := 1; !done; i++ { <-Z.req u := get(U) if end(u) != 0 { done = true } Z.dat <- mul(i2tor(1, int64(i)), u) } Z.dat <- finis }() return Z } // Binomial theorem (1+x)^c func Binom(c rat) PS { Z := mkPS() go func() { n := 1 t := itor(1) for c.num != 0 { put(t, Z) t = mul(mul(t, c), i2tor(1, int64(n))) c = sub(c, one) n++ } put(finis, Z) }() return Z } // Reciprocal of a power series // let U = u + xUU // let Z = z + xZZ // (u+xUU)(z+xZZ) = 1 // z = 1/u // uZZ + zUU +xUUZZ = 0 // ZZ = -UU(z+xZZ)/u func Recip(U PS) PS { Z := mkPS() go func() { ZZ := mkPS2() <-Z.req z := inv(get(U)) Z.dat <- z split(Mul(Cmul(neg(z), U), Shift(z, ZZ[0])), ZZ) copy(ZZ[1], Z) }() return Z } // Exponential of a power series with constant term 0 // (nonzero constant term would make nonrational coefficients) // bug: the constant term is simply ignored // Z = exp(U) // DZ = ZDU // integrate to get Z func Exp(U PS) PS { ZZ := mkPS2() split(Integ(one, Mul(ZZ[0], Diff(U))), ZZ) return ZZ[1] } // Substitute V for x in U, where the leading term of V is zero // let U = u + xUU // let V = v + xVV // then S(U,V) = u + VVS(V,UU) // bug: a nonzero constant term is ignored func Subst(U, V PS) PS { Z := mkPS() go func() { VV := Split(V) <-Z.req u := get(U) Z.dat <- u if end(u) == 0 { if end(get(VV[0])) != 0 { put(finis, Z) } else { copy(Mul(VV[0], Subst(U, VV[1])), Z) } } }() return Z } // Monomial Substitution: U(c x^n) // Each Ui is multiplied by c^i and followed by n-1 zeros func MonSubst(U PS, c0 rat, n int) PS { Z := mkPS() go func() { c := one for { <-Z.req u := get(U) Z.dat <- mul(u, c) c = mul(c, c0) if end(u) != 0 { Z.dat <- finis break } for i := 1; i < n; i++ { <-Z.req Z.dat <- zero } } }() return Z } func Init() { chnameserial = -1 seqno = 0 chnames = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" zero = itor(0) one = itor(1) finis = i2tor(1, 0) Ones = Rep(one) Twos = Rep(itor(2)) } func check(U PS, c rat, count int, str string) { for i := 0; i < count; i++ { r := get(U) if !r.eq(c) { print("got: ") r.pr() print("should get ") c.pr() print("\n") panic(str) } } } const N = 10 func checka(U PS, a []rat, str string) { for i := 0; i < N; i++ { check(U, a[i], 1, str) } } func main() { Init() if len(os.Args) > 1 { // print print("Ones: ") printn(Ones, 10) print("Twos: ") printn(Twos, 10) print("Add: ") printn(Add(Ones, Twos), 10) print("Diff: ") printn(Diff(Ones), 10) print("Integ: ") printn(Integ(zero, Ones), 10) print("CMul: ") printn(Cmul(neg(one), Ones), 10) print("Sub: ") printn(Sub(Ones, Twos), 10) print("Mul: ") printn(Mul(Ones, Ones), 10) print("Exp: ") printn(Exp(Ones), 15) print("MonSubst: ") printn(MonSubst(Ones, neg(one), 2), 10) print("ATan: ") printn(Integ(zero, MonSubst(Ones, neg(one), 2)), 10) } else { // test check(Ones, one, 5, "Ones") check(Add(Ones, Ones), itor(2), 0, "Add Ones Ones") // 1 1 1 1 1 check(Add(Ones, Twos), itor(3), 0, "Add Ones Twos") // 3 3 3 3 3 a := make([]rat, N) d := Diff(Ones) for i := 0; i < N; i++ { a[i] = itor(int64(i + 1)) } checka(d, a, "Diff") // 1 2 3 4 5 in := Integ(zero, Ones) a[0] = zero // integration constant for i := 1; i < N; i++ { a[i] = i2tor(1, int64(i)) } checka(in, a, "Integ") // 0 1 1/2 1/3 1/4 1/5 check(Cmul(neg(one), Twos), itor(-2), 10, "CMul") // -1 -1 -1 -1 -1 check(Sub(Ones, Twos), itor(-1), 0, "Sub Ones Twos") // -1 -1 -1 -1 -1 m := Mul(Ones, Ones) for i := 0; i < N; i++ { a[i] = itor(int64(i + 1)) } checka(m, a, "Mul") // 1 2 3 4 5 e := Exp(Ones) a[0] = itor(1) a[1] = itor(1) a[2] = i2tor(3, 2) a[3] = i2tor(13, 6) a[4] = i2tor(73, 24) a[5] = i2tor(167, 40) a[6] = i2tor(4051, 720) a[7] = i2tor(37633, 5040) a[8] = i2tor(43817, 4480) a[9] = i2tor(4596553, 362880) checka(e, a, "Exp") // 1 1 3/2 13/6 73/24 at := Integ(zero, MonSubst(Ones, neg(one), 2)) for c, i := 1, 0; i < N; i++ { if i%2 == 0 { a[i] = zero } else { a[i] = i2tor(int64(c), int64(i)) c = -1 } } checka(at, a, "ATan") // 0 -1 0 -1/3 0 -1/5 /* t := Revert(Integ(zero, MonSubst(Ones, neg(one), 2))) a[0] = zero a[1] = itor(1) a[2] = zero a[3] = i2tor(1,3) a[4] = zero a[5] = i2tor(2,15) a[6] = zero a[7] = i2tor(17,315) a[8] = zero a[9] = i2tor(62,2835) checka(t, a, "Tan") // 0 1 0 1/3 0 2/15 */ } }	12.66 KB	2024-02-02 18:09
📄 powser2.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test concurrency primitives: power series. // Like powser1.go but uses channels of interfaces. // Has not been cleaned up as much as powser1.go, to keep // it distinct and therefore a different test. // Power series package // A power series is a channel, along which flow rational // coefficients. A denominator of zero signifies the end. // Original code in Newsqueak by Doug McIlroy. // See Squinting at Power Series by Doug McIlroy, // https://swtch.com/~rsc/thread/squint.pdf package main import "os" type rat struct { num, den int64 // numerator, denominator } type item interface { pr() eq(c item) bool } func (u rat) pr() { if u.den == 1 { print(u.num) } else { print(u.num, "/", u.den) } print(" ") } func (u rat) eq(c item) bool { c1 := c.(rat) return u.num == c1.num && u.den == c1.den } type dch struct { req chan int dat chan item nam int } type dch2 [2]dch var chnames string var chnameserial int var seqno int func mkdch() dch { c := chnameserial % len(chnames) chnameserial++ d := new(dch) d.req = make(chan int) d.dat = make(chan item) d.nam = c return d } func mkdch2() dch2 { d2 := new(dch2) d2[0] = mkdch() d2[1] = mkdch() return d2 } // split reads a single demand channel and replicates its // output onto two, which may be read at different rates. // A process is created at first demand for an item and dies // after the item has been sent to both outputs. // When multiple generations of split exist, the newest // will service requests on one channel, which is // always renamed to be out[0]; the oldest will service // requests on the other channel, out[1]. All generations but the // newest hold queued data that has already been sent to // out[0]. When data has finally been sent to out[1], // a signal on the release-wait channel tells the next newer // generation to begin servicing out[1]. func dosplit(in dch, out dch2, wait chan int) { both := false // do not service both channels select { case <-out[0].req: case <-wait: both = true select { case <-out[0].req: case <-out[1].req: out[0], out[1] = out[1], out[0] } } seqno++ in.req <- seqno release := make(chan int) go dosplit(in, out, release) dat := <-in.dat out[0].dat <- dat if !both { <-wait } <-out[1].req out[1].dat <- dat release <- 0 } func split(in dch, out dch2) { release := make(chan int) go dosplit(in, out, release) release <- 0 } func put(dat item, out dch) { <-out.req out.dat <- dat } func get(in dch) rat { seqno++ in.req <- seqno return (<-in.dat).(rat) } // Get one item from each of n demand channels func getn(in []dch) []item { n := len(in) if n != 2 { panic("bad n in getn") } req := make([]chan int, 2) dat := make([]chan item, 2) out := make([]item, 2) var i int var it item for i = 0; i < n; i++ { req[i] = in[i].req dat[i] = nil } for n = 2 n; n > 0; n-- { seqno++ select { case req[0] <- seqno: dat[0] = in[0].dat req[0] = nil case req[1] <- seqno: dat[1] = in[1].dat req[1] = nil case it = <-dat[0]: out[0] = it dat[0] = nil case it = <-dat[1]: out[1] = it dat[1] = nil } } return out } // Get one item from each of 2 demand channels func get2(in0 dch, in1 dch) []item { return getn([]dch{in0, in1}) } func copy(in dch, out dch) { for { <-out.req out.dat <- get(in) } } func repeat(dat item, out dch) { for { put(dat, out) } } type PS dch // power series type PS2 [2]PS // pair of power series var Ones PS var Twos PS func mkPS() dch { return mkdch() } func mkPS2() dch2 { return mkdch2() } // Conventions // Upper-case for power series. // Lower-case for rationals. // Input variables: U,V,... // Output variables: ...,Y,Z // Integer gcd; needed for rational arithmetic func gcd(u, v int64) int64 { if u < 0 { return gcd(-u, v) } if u == 0 { return v } return gcd(v%u, u) } // Make a rational from two ints and from one int func i2tor(u, v int64) rat { g := gcd(u, v) r := new(rat) if v > 0 { r.num = u / g r.den = v / g } else { r.num = -u / g r.den = -v / g } return r } func itor(u int64) rat { return i2tor(u, 1) } var zero rat var one rat // End mark and end test var finis rat func end(u rat) int64 { if u.den == 0 { return 1 } return 0 } // Operations on rationals func add(u, v rat) rat { g := gcd(u.den, v.den) return i2tor(u.num(v.den/g)+v.num(u.den/g), u.den(v.den/g)) } func mul(u, v rat) rat { g1 := gcd(u.num, v.den) g2 := gcd(u.den, v.num) r := new(rat) r.num = (u.num / g1) (v.num / g2) r.den = (u.den / g2) * (v.den / g1) return r } func neg(u rat) rat { return i2tor(-u.num, u.den) } func sub(u, v rat) rat { return add(u, neg(v)) } func inv(u rat) rat { // invert a rat if u.num == 0 { panic("zero divide in inv") } return i2tor(u.den, u.num) } // print eval in floating point of PS at x=c to n terms func Evaln(c rat, U PS, n int) { xn := float64(1) x := float64(c.num) / float64(c.den) val := float64(0) for i := 0; i < n; i++ { u := get(U) if end(u) != 0 { break } val = val + xfloat64(u.num)/float64(u.den) xn = xn * x } print(val, "\n") } // Print n terms of a power series func Printn(U PS, n int) { done := false for ; !done && n > 0; n-- { u := get(U) if end(u) != 0 { done = true } else { u.pr() } } print(("\n")) } func Print(U PS) { Printn(U, 1000000000) } // Evaluate n terms of power series U at x=c func eval(c rat, U PS, n int) rat { if n == 0 { return zero } y := get(U) if end(y) != 0 { return zero } return add(y, mul(c, eval(c, U, n-1))) } // Power-series constructors return channels on which power // series flow. They start an encapsulated generator that // puts the terms of the series on the channel. // Make a pair of power series identical to a given power series func Split(U PS) dch2 { UU := mkdch2() go split(U, UU) return UU } // Add two power series func Add(U, V PS) PS { Z := mkPS() go func(U, V, Z PS) { var uv []item for { <-Z.req uv = get2(U, V) switch end(uv[0].(rat)) + 2end(uv[1].(rat)) { case 0: Z.dat <- add(uv[0].(rat), uv[1].(rat)) case 1: Z.dat <- uv[1] copy(V, Z) case 2: Z.dat <- uv[0] copy(U, Z) case 3: Z.dat <- finis } } }(U, V, Z) return Z } // Multiply a power series by a constant func Cmul(c rat, U PS) PS { Z := mkPS() go func(c rat, U, Z PS) { done := false for !done { <-Z.req u := get(U) if end(u) != 0 { done = true } else { Z.dat <- mul(c, u) } } Z.dat <- finis }(c, U, Z) return Z } // Subtract func Sub(U, V PS) PS { return Add(U, Cmul(neg(one), V)) } // Multiply a power series by the monomial x^n func Monmul(U PS, n int) PS { Z := mkPS() go func(n int, U PS, Z PS) { for ; n > 0; n-- { put(zero, Z) } copy(U, Z) }(n, U, Z) return Z } // Multiply by x func Xmul(U PS) PS { return Monmul(U, 1) } func Rep(c rat) PS { Z := mkPS() go repeat(c, Z) return Z } // Monomial cx^n func Mon(c rat, n int) PS { Z := mkPS() go func(c rat, n int, Z PS) { if c.num != 0 { for ; n > 0; n = n - 1 { put(zero, Z) } put(c, Z) } put(finis, Z) }(c, n, Z) return Z } func Shift(c rat, U PS) PS { Z := mkPS() go func(c rat, U, Z PS) { put(c, Z) copy(U, Z) }(c, U, Z) return Z } // simple pole at 1: 1/(1-x) = 1 1 1 1 1 ... // Convert array of coefficients, constant term first // to a (finite) power series /* func Poly(a [] rat) PS{ Z:=mkPS() begin func(a [] rat, Z PS){ j:=0 done:=0 for j=len(a); !done&&j>0; j=j-1) if(a[j-1].num!=0) done=1 i:=0 for(; i<j; i=i+1) put(a[i],Z) put(finis,Z) }() return Z } / // Multiply. The algorithm is // let U = u + xUU // let V = v + xVV // then UV = uv + x(uVV+vUU) + xxUUVV func Mul(U, V PS) PS { Z := mkPS() go func(U, V, Z PS) { <-Z.req uv := get2(U, V) if end(uv[0].(rat)) != 0 \|\| end(uv[1].(rat)) != 0 { Z.dat <- finis } else { Z.dat <- mul(uv[0].(rat), uv[1].(rat)) UU := Split(U) VV := Split(V) W := Add(Cmul(uv[0].(rat), VV[0]), Cmul(uv[1].(rat), UU[0])) <-Z.req Z.dat <- get(W) copy(Add(W, Mul(UU[1], VV[1])), Z) } }(U, V, Z) return Z } // Differentiate func Diff(U PS) PS { Z := mkPS() go func(U, Z PS) { <-Z.req u := get(U) if end(u) == 0 { done := false for i := 1; !done; i++ { u = get(U) if end(u) != 0 { done = true } else { Z.dat <- mul(itor(int64(i)), u) <-Z.req } } } Z.dat <- finis }(U, Z) return Z } // Integrate, with const of integration func Integ(c rat, U PS) PS { Z := mkPS() go func(c rat, U, Z PS) { put(c, Z) done := false for i := 1; !done; i++ { <-Z.req u := get(U) if end(u) != 0 { done = true } Z.dat <- mul(i2tor(1, int64(i)), u) } Z.dat <- finis }(c, U, Z) return Z } // Binomial theorem (1+x)^c func Binom(c rat) PS { Z := mkPS() go func(c rat, Z PS) { n := 1 t := itor(1) for c.num != 0 { put(t, Z) t = mul(mul(t, c), i2tor(1, int64(n))) c = sub(c, one) n++ } put(finis, Z) }(c, Z) return Z } // Reciprocal of a power series // let U = u + xUU // let Z = z + xZZ // (u+xUU)(z+xZZ) = 1 // z = 1/u // uZZ + zUU +xUUZZ = 0 // ZZ = -UU(z+xZZ)/u func Recip(U PS) PS { Z := mkPS() go func(U, Z PS) { ZZ := mkPS2() <-Z.req z := inv(get(U)) Z.dat <- z split(Mul(Cmul(neg(z), U), Shift(z, ZZ[0])), ZZ) copy(ZZ[1], Z) }(U, Z) return Z } // Exponential of a power series with constant term 0 // (nonzero constant term would make nonrational coefficients) // bug: the constant term is simply ignored // Z = exp(U) // DZ = ZDU // integrate to get Z func Exp(U PS) PS { ZZ := mkPS2() split(Integ(one, Mul(ZZ[0], Diff(U))), ZZ) return ZZ[1] } // Substitute V for x in U, where the leading term of V is zero // let U = u + xUU // let V = v + xVV // then S(U,V) = u + VVS(V,UU) // bug: a nonzero constant term is ignored func Subst(U, V PS) PS { Z := mkPS() go func(U, V, Z PS) { VV := Split(V) <-Z.req u := get(U) Z.dat <- u if end(u) == 0 { if end(get(VV[0])) != 0 { put(finis, Z) } else { copy(Mul(VV[0], Subst(U, VV[1])), Z) } } }(U, V, Z) return Z } // Monomial Substitution: U(c x^n) // Each Ui is multiplied by c^i and followed by n-1 zeros func MonSubst(U PS, c0 rat, n int) PS { Z := mkPS() go func(U, Z PS, c0 rat, n int) { c := one for { <-Z.req u := get(U) Z.dat <- mul(u, c) c = mul(c, c0) if end(u) != 0 { Z.dat <- finis break } for i := 1; i < n; i++ { <-Z.req Z.dat <- zero } } }(U, Z, c0, n) return Z } func Init() { chnameserial = -1 seqno = 0 chnames = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" zero = itor(0) one = itor(1) finis = i2tor(1, 0) Ones = Rep(one) Twos = Rep(itor(2)) } func check(U PS, c rat, count int, str string) { for i := 0; i < count; i++ { r := get(U) if !r.eq(c) { print("got: ") r.pr() print("should get ") c.pr() print("\n") panic(str) } } } const N = 10 func checka(U PS, a []rat, str string) { for i := 0; i < N; i++ { check(U, a[i], 1, str) } } func main() { Init() if len(os.Args) > 1 { // print print("Ones: ") Printn(Ones, 10) print("Twos: ") Printn(Twos, 10) print("Add: ") Printn(Add(Ones, Twos), 10) print("Diff: ") Printn(Diff(Ones), 10) print("Integ: ") Printn(Integ(zero, Ones), 10) print("CMul: ") Printn(Cmul(neg(one), Ones), 10) print("Sub: ") Printn(Sub(Ones, Twos), 10) print("Mul: ") Printn(Mul(Ones, Ones), 10) print("Exp: ") Printn(Exp(Ones), 15) print("MonSubst: ") Printn(MonSubst(Ones, neg(one), 2), 10) print("ATan: ") Printn(Integ(zero, MonSubst(Ones, neg(one), 2)), 10) } else { // test check(Ones, one, 5, "Ones") check(Add(Ones, Ones), itor(2), 0, "Add Ones Ones") // 1 1 1 1 1 check(Add(Ones, Twos), itor(3), 0, "Add Ones Twos") // 3 3 3 3 3 a := make([]rat, N) d := Diff(Ones) for i := 0; i < N; i++ { a[i] = itor(int64(i + 1)) } checka(d, a, "Diff") // 1 2 3 4 5 in := Integ(zero, Ones) a[0] = zero // integration constant for i := 1; i < N; i++ { a[i] = i2tor(1, int64(i)) } checka(in, a, "Integ") // 0 1 1/2 1/3 1/4 1/5 check(Cmul(neg(one), Twos), itor(-2), 10, "CMul") // -1 -1 -1 -1 -1 check(Sub(Ones, Twos), itor(-1), 0, "Sub Ones Twos") // -1 -1 -1 -1 -1 m := Mul(Ones, Ones) for i := 0; i < N; i++ { a[i] = itor(int64(i + 1)) } checka(m, a, "Mul") // 1 2 3 4 5 e := Exp(Ones) a[0] = itor(1) a[1] = itor(1) a[2] = i2tor(3, 2) a[3] = i2tor(13, 6) a[4] = i2tor(73, 24) a[5] = i2tor(167, 40) a[6] = i2tor(4051, 720) a[7] = i2tor(37633, 5040) a[8] = i2tor(43817, 4480) a[9] = i2tor(4596553, 362880) checka(e, a, "Exp") // 1 1 3/2 13/6 73/24 at := Integ(zero, MonSubst(Ones, neg(one), 2)) for c, i := 1, 0; i < N; i++ { if i%2 == 0 { a[i] = zero } else { a[i] = i2tor(int64(c), int64(i)) c = -1 } } checka(at, a, "ATan") // 0 -1 0 -1/3 0 -1/5 / t := Revert(Integ(zero, MonSubst(Ones, neg(one), 2))) a[0] = zero a[1] = itor(1) a[2] = zero a[3] = i2tor(1,3) a[4] = zero a[5] = i2tor(2,15) a[6] = zero a[7] = i2tor(17,315) a[8] = zero a[9] = i2tor(62,2835) checka(t, a, "Tan") // 0 1 0 1/3 0 2/15 */ } }	13.29 KB	2024-02-02 18:09
📄 select.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test simple select. package main var counter uint var shift uint func GetValue() uint { counter++ return 1 << shift } func Send(a, b chan uint) int { var i int LOOP: for { select { case a <- GetValue(): i++ a = nil case b <- GetValue(): i++ b = nil default: break LOOP } shift++ } return i } func main() { a := make(chan uint, 1) b := make(chan uint, 1) if v := Send(a, b); v != 2 { println("Send returned", v, "!= 2") panic("fail") } if av, bv := <-a, <-b; av\|bv != 3 { println("bad values", av, bv) panic("fail") } if v := Send(a, nil); v != 1 { println("Send returned", v, "!= 1") panic("fail") } if counter != 10 { println("counter is", counter, "!= 10") panic("fail") } }	913 B	2024-02-02 18:09
📄 select2.go // run // Copyright 2010 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test that selects do not consume undue memory. package main import "runtime" func sender(c chan int, n int) { for i := 0; i < n; i++ { c <- 1 } } func receiver(c, dummy chan int, n int) { for i := 0; i < n; i++ { select { case <-c: // nothing case <-dummy: panic("dummy") } } } func main() { runtime.MemProfileRate = 0 c := make(chan int) dummy := make(chan int) // warm up go sender(c, 100000) receiver(c, dummy, 100000) runtime.GC() memstats := new(runtime.MemStats) runtime.ReadMemStats(memstats) alloc := memstats.Alloc // second time shouldn't increase footprint by much go sender(c, 100000) receiver(c, dummy, 100000) runtime.GC() runtime.ReadMemStats(memstats) // Be careful to avoid wraparound. if memstats.Alloc > alloc && memstats.Alloc-alloc > 1.1e5 { println("BUG: too much memory for 100,000 selects:", memstats.Alloc-alloc) } }	1.04 KB	2024-02-02 18:09
📄 select3.go // run // Copyright 2010 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test the semantics of the select statement // for basic empty/non-empty cases. package main import "time" const always = "function did not" const never = "function did" func unreachable() { panic("control flow shouldn't reach here") } // Calls f and verifies that f always/never panics depending on signal. func testPanic(signal string, f func()) { defer func() { s := never if recover() != nil { s = always // f panicked } if s != signal { panic(signal + " panic") } }() f() } // Calls f and empirically verifies that f always/never blocks depending on signal. func testBlock(signal string, f func()) { c := make(chan string) go func() { f() c <- never // f didn't block }() go func() { if signal == never { // Wait a long time to make sure that we don't miss our window by accident on a slow machine. time.Sleep(10 * time.Second) } else { // Wait as short a time as we can without false negatives. // 10ms should be long enough to catch most failures. time.Sleep(10 * time.Millisecond) } c <- always // f blocked always }() if <-c != signal { panic(signal + " block") } } func main() { const async = 1 // asynchronous channels var nilch chan int closedch := make(chan int) close(closedch) // sending/receiving from a nil channel blocks testBlock(always, func() { nilch <- 7 }) testBlock(always, func() { <-nilch }) // sending/receiving from a nil channel inside a select is never selected testPanic(never, func() { select { case nilch <- 7: unreachable() default: } }) testPanic(never, func() { select { case <-nilch: unreachable() default: } }) // sending to an async channel with free buffer space never blocks testBlock(never, func() { ch := make(chan int, async) ch <- 7 }) // receiving from a closed channel never blocks testBlock(never, func() { for i := 0; i < 10; i++ { if <-closedch != 0 { panic("expected zero value when reading from closed channel") } if x, ok := <-closedch; x != 0 \|\| ok { println("closedch:", x, ok) panic("expected 0, false from closed channel") } } }) // sending to a closed channel panics. testPanic(always, func() { closedch <- 7 }) // receiving from a non-ready channel always blocks testBlock(always, func() { ch := make(chan int) <-ch }) // empty selects always block testBlock(always, func() { select {} }) // selects with only nil channels always block testBlock(always, func() { select { case <-nilch: unreachable() } }) testBlock(always, func() { select { case nilch <- 7: unreachable() } }) testBlock(always, func() { select { case <-nilch: unreachable() case nilch <- 7: unreachable() } }) // selects with non-ready non-nil channels always block testBlock(always, func() { ch := make(chan int) select { case <-ch: unreachable() } }) // selects with default cases don't block testBlock(never, func() { select { default: } }) testBlock(never, func() { select { case <-nilch: unreachable() default: } }) testBlock(never, func() { select { case nilch <- 7: unreachable() default: } }) // selects with ready channels don't block testBlock(never, func() { ch := make(chan int, async) select { case ch <- 7: default: unreachable() } }) testBlock(never, func() { ch := make(chan int, async) ch <- 7 select { case <-ch: default: unreachable() } }) // selects with closed channels behave like ordinary operations testBlock(never, func() { select { case <-closedch: } }) testBlock(never, func() { select { case x := (<-closedch): _ = x } }) testBlock(never, func() { select { case x, ok := (<-closedch): _, _ = x, ok } }) testPanic(always, func() { select { case closedch <- 7: } }) // select should not get confused if it sees itself testBlock(always, func() { c := make(chan int) select { case c <- 1: case <-c: } }) }	4.07 KB	2024-02-02 18:09
📄 select4.go // run // Copyright 2010 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file // Test that a select statement proceeds when a value is ready. package main func f() int { println("BUG: called f") return new(int) } func main() { var x struct { a int } c := make(chan int, 1) c1 := make(chan int) c <- 42 select { case f() = <-c1: // nothing case x.a = <-c: if x.a != 42 { println("BUG:", x.a) } } }	513 B	2024-02-02 18:09
📄 select5.go // runoutput // Copyright 2011 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Generate test of channel operations and simple selects. // The output of this program is compiled and run to do the // actual test. // Each test does only one real send or receive at a time, but phrased // in various ways that the compiler may or may not rewrite // into simpler expressions. package main import ( "bufio" "fmt" "io" "os" "text/template" ) func main() { out := bufio.NewWriter(os.Stdout) fmt.Fprintln(out, header) a := new(arg) // Generate each test as a separate function to avoid // hitting the gc optimizer with one enormous function. // If we name all the functions init we don't have to // maintain a list of which ones to run. do := func(t template.Template) { for ; next(); a.reset() { fmt.Fprintln(out, `func init() {`) run(t, a, out) fmt.Fprintln(out, `}`) } } do(recv) do(send) do(recvOrder) do(sendOrder) do(nonblock) fmt.Fprintln(out, "//", a.nreset, "cases") out.Flush() } func run(t template.Template, a interface{}, out io.Writer) { if err := t.Execute(out, a); err != nil { panic(err) } } type arg struct { def bool nreset int } func (a arg) Maybe() bool { return maybe() } func (a arg) MaybeDefault() bool { if a.def { return false } a.def = maybe() return a.def } func (a arg) MustDefault() bool { return !a.def } func (a arg) reset() { a.def = false a.nreset++ } const header = `// GENERATED BY select5.go; DO NOT EDIT package main // channel is buffered so test is single-goroutine. // we are not interested in the concurrency aspects // of select, just testing that the right calls happen. var c = make(chan int, 1) var nilch chan int var n = 1 var x int var i interface{} var dummy = make(chan int) var m = make(map[int]int) var order = 0 func f(p int) int { return p } // check order of operations by ensuring that // successive calls to checkorder have increasing o values. func checkorder(o int) { if o <= order { println("invalid order", o, "after", order) panic("order") } order = o } func fc(c chan int, o int) chan int { checkorder(o) return c } func fp(p int, o int) int { checkorder(o) return p } func fn(n, o int) int { checkorder(o) return n } func die(x int) { println("have", x, "want", n) panic("chan") } func main() { // everything happens in init funcs } ` func parse(name, s string) template.Template { t, err := template.New(name).Parse(s) if err != nil { panic(fmt.Sprintf("%q: %s", name, err)) } return t } var recv = parse("recv", ` {{/ Send n, receive it one way or another into x, check that they match. /}} c <- n {{if .Maybe}} x = <-c {{else}} select { {{/ Blocking or non-blocking, before the receive. /}} {{/ The compiler implements two-case select where one is default with custom code, /}} {{/ so test the default branch both before and after the send. /}} {{if .MaybeDefault}} default: panic("nonblock") {{end}} {{/ Receive from c. Different cases are direct, indirect, :=, interface, and map assignment. /}} {{if .Maybe}} case x = <-c: {{else}}{{if .Maybe}} case f(&x) = <-c: {{else}}{{if .Maybe}} case y := <-c: x = y {{else}}{{if .Maybe}} case i = <-c: x = i.(int) {{else}} case m[13] = <-c: x = m[13] {{end}}{{end}}{{end}}{{end}} {{/* Blocking or non-blocking again, after the receive. /}} {{if .MaybeDefault}} default: panic("nonblock") {{end}} {{/ Dummy send, receive to keep compiler from optimizing select. /}} {{if .Maybe}} case dummy <- 1: panic("dummy send") {{end}} {{if .Maybe}} case <-dummy: panic("dummy receive") {{end}} {{/ Nil channel send, receive to keep compiler from optimizing select. /}} {{if .Maybe}} case nilch <- 1: panic("nilch send") {{end}} {{if .Maybe}} case <-nilch: panic("nilch recv") {{end}} } {{end}} if x != n { die(x) } n++ `) var recvOrder = parse("recvOrder", ` {{/ Send n, receive it one way or another into x, check that they match. /}} {{/ Check order of operations along the way by calling functions that check /}} {{/ that the argument sequence is strictly increasing. /}} order = 0 c <- n {{if .Maybe}} {{/ Outside of select, left-to-right rule applies. /}} {{/ (Inside select, assignment waits until case is chosen, /}} {{/ so right hand side happens before anything on left hand side. /}} fp(&x, 1) = <-fc(c, 2) {{else}}{{if .Maybe}} m[fn(13, 1)] = <-fc(c, 2) x = m[13] {{else}} select { {{/* Blocking or non-blocking, before the receive. /}} {{/ The compiler implements two-case select where one is default with custom code, /}} {{/ so test the default branch both before and after the send. /}} {{if .MaybeDefault}} default: panic("nonblock") {{end}} {{/ Receive from c. Different cases are direct, indirect, :=, interface, and map assignment. /}} {{if .Maybe}} case fp(&x, 100) = <-fc(c, 1): {{else}}{{if .Maybe}} case y := <-fc(c, 1): x = y {{else}}{{if .Maybe}} case i = <-fc(c, 1): x = i.(int) {{else}} case m[fn(13, 100)] = <-fc(c, 1): x = m[13] {{end}}{{end}}{{end}} {{/* Blocking or non-blocking again, after the receive. /}} {{if .MaybeDefault}} default: panic("nonblock") {{end}} {{/ Dummy send, receive to keep compiler from optimizing select. /}} {{if .Maybe}} case fc(dummy, 2) <- fn(1, 3): panic("dummy send") {{end}} {{if .Maybe}} case <-fc(dummy, 4): panic("dummy receive") {{end}} {{/ Nil channel send, receive to keep compiler from optimizing select. /}} {{if .Maybe}} case fc(nilch, 5) <- fn(1, 6): panic("nilch send") {{end}} {{if .Maybe}} case <-fc(nilch, 7): panic("nilch recv") {{end}} } {{end}}{{end}} if x != n { die(x) } n++ `) var send = parse("send", ` {{/ Send n one way or another, receive it into x, check that they match. /}} {{if .Maybe}} c <- n {{else}} select { {{/ Blocking or non-blocking, before the receive (same reason as in recv). /}} {{if .MaybeDefault}} default: panic("nonblock") {{end}} {{/ Send c <- n. No real special cases here, because no values come back /}} {{/ from the send operation. /}} case c <- n: {{/ Blocking or non-blocking. /}} {{if .MaybeDefault}} default: panic("nonblock") {{end}} {{/ Dummy send, receive to keep compiler from optimizing select. /}} {{if .Maybe}} case dummy <- 1: panic("dummy send") {{end}} {{if .Maybe}} case <-dummy: panic("dummy receive") {{end}} {{/ Nil channel send, receive to keep compiler from optimizing select. /}} {{if .Maybe}} case nilch <- 1: panic("nilch send") {{end}} {{if .Maybe}} case <-nilch: panic("nilch recv") {{end}} } {{end}} x = <-c if x != n { die(x) } n++ `) var sendOrder = parse("sendOrder", ` {{/ Send n one way or another, receive it into x, check that they match. /}} {{/ Check order of operations along the way by calling functions that check /}} {{/ that the argument sequence is strictly increasing. /}} order = 0 {{if .Maybe}} fc(c, 1) <- fn(n, 2) {{else}} select { {{/ Blocking or non-blocking, before the receive (same reason as in recv). /}} {{if .MaybeDefault}} default: panic("nonblock") {{end}} {{/ Send c <- n. No real special cases here, because no values come back /}} {{/ from the send operation. /}} case fc(c, 1) <- fn(n, 2): {{/ Blocking or non-blocking. /}} {{if .MaybeDefault}} default: panic("nonblock") {{end}} {{/ Dummy send, receive to keep compiler from optimizing select. /}} {{if .Maybe}} case fc(dummy, 3) <- fn(1, 4): panic("dummy send") {{end}} {{if .Maybe}} case <-fc(dummy, 5): panic("dummy receive") {{end}} {{/ Nil channel send, receive to keep compiler from optimizing select. /}} {{if .Maybe}} case fc(nilch, 6) <- fn(1, 7): panic("nilch send") {{end}} {{if .Maybe}} case <-fc(nilch, 8): panic("nilch recv") {{end}} } {{end}} x = <-c if x != n { die(x) } n++ `) var nonblock = parse("nonblock", ` x = n {{/ Test various combinations of non-blocking operations. /}} {{/ Receive assignments must not edit or even attempt to compute the address of the lhs. /}} select { {{if .MaybeDefault}} default: {{end}} {{if .Maybe}} case dummy <- 1: panic("dummy <- 1") {{end}} {{if .Maybe}} case nilch <- 1: panic("nilch <- 1") {{end}} {{if .Maybe}} case <-dummy: panic("<-dummy") {{end}} {{if .Maybe}} case x = <-dummy: panic("<-dummy x") {{end}} {{if .Maybe}} case (int)(nil) = <-dummy: panic("<-dummy (and didn't crash saving result!)") {{end}} {{if .Maybe}} case <-nilch: panic("<-nilch") {{end}} {{if .Maybe}} case x = <-nilch: panic("<-nilch x") {{end}} {{if .Maybe}} case (*int)(nil) = <-nilch: panic("<-nilch (and didn't crash saving result!)") {{end}} {{if .MustDefault}} default: {{end}} } if x != n { die(x) } n++ `) // Code for enumerating all possible paths through // some logic. The logic should call choose(n) when // it wants to choose between n possibilities. // On successive runs through the logic, choose(n) // will return 0, 1, ..., n-1. The helper maybe() is // similar but returns true and then false. // // Given a function gen that generates an output // using choose and maybe, code can generate all // possible outputs using // // for next() { // gen() // } type choice struct { i, n int } var choices []choice var cp int = -1 func maybe() bool { return choose(2) == 0 } func choose(n int) int { if cp >= len(choices) { // never asked this before: start with 0. choices = append(choices, choice{0, n}) cp = len(choices) return 0 } // otherwise give recorded answer if n != choices[cp].n { panic("inconsistent choices") } i := choices[cp].i cp++ return i } func next() bool { if cp < 0 { // start a new round cp = 0 return true } // increment last choice sequence cp = len(choices) - 1 for cp >= 0 && choices[cp].i == choices[cp].n-1 { cp-- } if cp < 0 { choices = choices[:0] return false } choices[cp].i++ choices = choices[:cp+1] cp = 0 return true }	9.97 KB	2024-02-02 18:09
📄 select6.go // run // Copyright 2011 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test for select: Issue 2075 // A bug in select corrupts channel queues of failed cases // if there are multiple waiters on those channels and the // select is the last in the queue. If further waits are made // on the channel without draining it first then those waiters // will never wake up. In the code below c1 is such a channel. package main func main() { c1 := make(chan bool) c2 := make(chan bool) c3 := make(chan bool) go func() { <-c1 }() go func() { select { case <-c1: panic("dummy") case <-c2: c3 <- true } <-c1 }() go func() { c2 <- true }() <-c3 c1 <- true c1 <- true }	783 B	2024-02-02 18:09
📄 select7.go // run // Copyright 2011 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test select when discarding a value. package main import "runtime" func recv1(c <-chan int) { <-c } func recv2(c <-chan int) { select { case <-c: } } func recv3(c <-chan int) { c2 := make(chan int) select { case <-c: case <-c2: } } func send1(recv func(<-chan int)) { c := make(chan int) go recv(c) runtime.Gosched() c <- 1 } func send2(recv func(<-chan int)) { c := make(chan int) go recv(c) runtime.Gosched() select { case c <- 1: } } func send3(recv func(<-chan int)) { c := make(chan int) go recv(c) runtime.Gosched() c2 := make(chan int) select { case c <- 1: case c2 <- 1: } } func main() { send1(recv1) send2(recv1) send3(recv1) send1(recv2) send2(recv2) send3(recv2) send1(recv3) send2(recv3) send3(recv3) }	932 B	2024-02-02 18:09
📄 select8.go // run // Copyright 2019 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test break statements in a select. // Gccgo had a bug in handling this. // Test 1,2,3-case selects, so it covers both the general // code path and the specialized optimizations for one- // and two-case selects. package main var ch = make(chan int) func main() { go func() { for { ch <- 5 } }() select { case <-ch: break panic("unreachable") } select { default: break panic("unreachable") } select { case <-ch: break panic("unreachable") default: break panic("unreachable") } select { case <-ch: break panic("unreachable") case ch <- 10: panic("unreachable") default: break panic("unreachable") } }	826 B	2024-02-02 18:09
📄 sendstmt.go // run // Copyright 2011 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test various parsing cases that are a little // different now that send is a statement, not an expression. package main func main() { chanchan() sendprec() } func chanchan() { cc := make(chan chan int, 1) c := make(chan int, 1) cc <- c select { case <-cc <- 2: default: panic("nonblock") } if <-c != 2 { panic("bad receive") } } func sendprec() { c := make(chan bool, 1) c <- false \|\| true // not a syntax error: same as c <- (false \|\| true) if !<-c { panic("sent false") } }	672 B	2024-02-02 18:09
📄 sieve1.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test concurrency primitives: classical inefficient concurrent prime sieve. // Generate primes up to 100 using channels, checking the results. // This sieve consists of a linear chain of divisibility filters, // equivalent to trial-dividing each n by all primes p ≤ n. package main // Send the sequence 2, 3, 4, ... to channel 'ch'. func Generate(ch chan<- int) { for i := 2; ; i++ { ch <- i // Send 'i' to channel 'ch'. } } // Copy the values from channel 'in' to channel 'out', // removing those divisible by 'prime'. func Filter(in <-chan int, out chan<- int, prime int) { for i := range in { // Loop over values received from 'in'. if i%prime != 0 { out <- i // Send 'i' to channel 'out'. } } } // The prime sieve: Daisy-chain Filter processes together. func Sieve(primes chan<- int) { ch := make(chan int) // Create a new channel. go Generate(ch) // Start Generate() as a subprocess. for { // Note that ch is different on each iteration. prime := <-ch primes <- prime ch1 := make(chan int) go Filter(ch, ch1, prime) ch = ch1 } } func main() { primes := make(chan int) go Sieve(primes) a := []int{2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97} for i := 0; i < len(a); i++ { if x := <-primes; x != a[i] { println(x, " != ", a[i]) panic("fail") } } }	1.49 KB	2024-02-02 18:09
📄 sieve2.go // run // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test concurrency primitives: prime sieve of Eratosthenes. // Generate primes up to 100 using channels, checking the results. // This sieve is Eratosthenesque and only considers odd candidates. // See discussion at <http://blog.onideas.ws/eratosthenes.go>. package main import ( "container/heap" "container/ring" ) // Return a chan of odd numbers, starting from 5. func odds() chan int { out := make(chan int, 50) go func() { n := 5 for { out <- n n += 2 } }() return out } // Return a chan of odd multiples of the prime number p, starting from pp. func multiples(p int) chan int { out := make(chan int, 10) go func() { n := p p for { out <- n n += 2 * p } }() return out } type PeekCh struct { head int ch chan int } // Heap of PeekCh, sorting by head values, satisfies Heap interface. type PeekChHeap []PeekCh func (h PeekChHeap) Less(i, j int) bool { return (h)[i].head < (h)[j].head } func (h PeekChHeap) Swap(i, j int) { (h)[i], (h)[j] = (h)[j], (h)[i] } func (h PeekChHeap) Len() int { return len(h) } func (h PeekChHeap) Pop() (v interface{}) { h, v = (h)[:h.Len()-1], (h)[h.Len()-1] return } func (h PeekChHeap) Push(v interface{}) { h = append(h, v.(PeekCh)) } // Return a channel to serve as a sending proxy to 'out'. // Use a goroutine to receive values from 'out' and store them // in an expanding buffer, so that sending to 'out' never blocks. func sendproxy(out chan<- int) chan<- int { proxy := make(chan int, 10) go func() { n := 16 // the allocated size of the circular queue first := ring.New(n) last := first var c chan<- int var e int for { c = out if first == last { // buffer empty: disable output c = nil } else { e = first.Value.(int) } select { case e = <-proxy: last.Value = e if last.Next() == first { // buffer full: expand it last.Link(ring.New(n)) n = 2 } last = last.Next() case c <- e: first = first.Next() } } }() return proxy } // Return a chan int of primes. func Sieve() chan int { // The output values. out := make(chan int, 10) out <- 2 out <- 3 // The channel of all composites to be eliminated in increasing order. composites := make(chan int, 50) // The feedback loop. primes := make(chan int, 10) primes <- 3 // Merge channels of multiples of 'primes' into 'composites'. go func() { var h PeekChHeap min := 15 for { m := multiples(<-primes) head := <-m for min < head { composites <- min minchan := heap.Pop(&h).(PeekCh) min = minchan.head minchan.head = <-minchan.ch heap.Push(&h, minchan) } for min == head { minchan := heap.Pop(&h).(PeekCh) min = minchan.head minchan.head = <-minchan.ch heap.Push(&h, minchan) } composites <- head heap.Push(&h, &PeekCh{<-m, m}) } }() // Sieve out 'composites' from 'candidates'. go func() { // In order to generate the nth prime we only need multiples of // primes ≤ sqrt(nth prime). Thus, the merging goroutine will // receive from 'primes' much slower than this goroutine // will send to it, making the buffer accumulate and block this // goroutine from sending, causing a deadlock. The solution is to // use a proxy goroutine to do automatic buffering. primes := sendproxy(primes) candidates := odds() p := <-candidates for { c := <-composites for p < c { primes <- p out <- p p = <-candidates } if p == c { p = <-candidates } } }() return out } func main() { primes := Sieve() a := []int{2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97} for i := 0; i < len(a); i++ { if x := <-primes; x != a[i] { println(x, " != ", a[i]) panic("fail") } } }	3.88 KB	2024-02-02 18:09
📄 zerosize.go // run // Copyright 2011 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Test making channels of a zero-sized type. package main func main() { _ = make(chan [0]byte) _ = make(chan [0]byte, 1) _ = make(chan struct{}) _ = make(chan struct{}, 1) }	349 B	2024-02-02 18:09

Edit File:

Terminal