Subversion Repositories openrisc

// $G $D/$F.go && $L $F.$A && ./$A.out

// 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.

package main

import "os"
import "runtime"
import "sync"

var randx int

func nrand(n int) int {
        randx += 10007
        if randx >= 1000000 {
                randx -= 1000000
        }
        return randx % n
}

type Chan struct {
        sc, rc chan int // send and recv chan
        sv, rv int      // send and recv seq
}

var (
        nproc      int
        nprocLock  sync.Mutex
        cval       int
        end        int = 10000
        totr, tots int
        totLock    sync.Mutex
        nc         *Chan
)

func init() {
        nc = new(Chan)
}

func changeNproc(adjust int) int {
        nprocLock.Lock()
        nproc += adjust
        ret := nproc
        nprocLock.Unlock()
        return ret
}

func mkchan(c, n int) []*Chan {
        ca := make([]*Chan, n)
        for i := 0; i < n; i++ {
                cval = cval + 100
                ch := new(Chan)
                ch.sc = make(chan int, c)
                ch.rc = ch.sc
                ch.sv = cval
                ch.rv = cval
                ca[i] = ch
        }
        return ca
}

func expect(v, v0 int) (newv int) {
        if v == v0 {
                if v%100 == 75 {
                        return end
                }
                return v + 1
        }
        print("got ", v, " expected ", v0+1, "\n")
        panic("fail")
}

func (c *Chan) send() bool {
        //      print("send ", c.sv, "\n");
        totLock.Lock()
        tots++
        totLock.Unlock()
        c.sv = expect(c.sv, c.sv)
        if c.sv == end {
                c.sc = nil
                return true
        }
        return false
}

func send(c *Chan) {
        for {
                for r := nrand(10); r >= 0; r-- {
                        runtime.Gosched()
                }
                c.sc <- c.sv
                if c.send() {
                        break
                }
        }
        changeNproc(-1)
}

func (c *Chan) recv(v int) bool {
        //      print("recv ", v, "\n");
        totLock.Lock()
        totr++
        totLock.Unlock()
        c.rv = expect(c.rv, v)
        if c.rv == end {
                c.rc = nil
                return true
        }
        return false
}

func recv(c *Chan) {
        var v int

        for {
                for r := nrand(10); r >= 0; r-- {
                        runtime.Gosched()
                }
                v = <-c.rc
                if c.recv(v) {
                        break
                }
        }
        changeNproc(-1)
}

func sel(r0, r1, r2, r3, s0, s1, s2, s3 *Chan) {
        var v int

        a := 0 // local chans running

        if r0.rc != nil {
                a++
        }
        if r1.rc != nil {
                a++
        }
        if r2.rc != nil {
                a++
        }
        if r3.rc != nil {
                a++
        }
        if s0.sc != nil {
                a++
        }
        if s1.sc != nil {
                a++
        }
        if s2.sc != nil {
                a++
        }
        if s3.sc != nil {
                a++
        }

        for {
                for r := nrand(5); r >= 0; r-- {
                        runtime.Gosched()
                }

                select {
                case v = <-r0.rc:
                        if r0.recv(v) {
                                a--
                        }
                case v = <-r1.rc:
                        if r1.recv(v) {
                                a--
                        }
                case v = <-r2.rc:
                        if r2.recv(v) {
                                a--
                        }
                case v = <-r3.rc:
                        if r3.recv(v) {
                                a--
                        }
                case s0.sc <- s0.sv:
                        if s0.send() {
                                a--
                        }
                case s1.sc <- s1.sv:
                        if s1.send() {
                                a--
                        }
                case s2.sc <- s2.sv:
                        if s2.send() {
                                a--
                        }
                case s3.sc <- s3.sv:
                        if s3.send() {
                                a--
                        }
                }
                if a == 0 {
                        break
                }
        }
        changeNproc(-1)
}

// direct send to direct recv
func test1(c *Chan) {
        changeNproc(2)
        go send(c)
        go recv(c)
}

// direct send to select recv
func test2(c int) {
        ca := mkchan(c, 4)

        changeNproc(4)
        go send(ca[0])
        go send(ca[1])
        go send(ca[2])
        go send(ca[3])

        changeNproc(1)
        go sel(ca[0], ca[1], ca[2], ca[3], nc, nc, nc, nc)
}

// select send to direct recv
func test3(c int) {
        ca := mkchan(c, 4)

        changeNproc(4)
        go recv(ca[0])
        go recv(ca[1])
        go recv(ca[2])
        go recv(ca[3])

        changeNproc(1)
        go sel(nc, nc, nc, nc, ca[0], ca[1], ca[2], ca[3])
}

// select send to select recv
func test4(c int) {
        ca := mkchan(c, 4)

        changeNproc(2)
        go sel(nc, nc, nc, nc, ca[0], ca[1], ca[2], ca[3])
        go sel(ca[0], ca[1], ca[2], ca[3], nc, nc, nc, nc)
}

func test5(c int) {
        ca := mkchan(c, 8)

        changeNproc(2)
        go sel(ca[4], ca[5], ca[6], ca[7], ca[0], ca[1], ca[2], ca[3])
        go sel(ca[0], ca[1], ca[2], ca[3], ca[4], ca[5], ca[6], ca[7])
}

func test6(c int) {
        ca := mkchan(c, 12)

        changeNproc(4)
        go send(ca[4])
        go send(ca[5])
        go send(ca[6])
        go send(ca[7])

        changeNproc(4)
        go recv(ca[8])
        go recv(ca[9])
        go recv(ca[10])
        go recv(ca[11])

        changeNproc(2)
        go sel(ca[4], ca[5], ca[6], ca[7], ca[0], ca[1], ca[2], ca[3])
        go sel(ca[0], ca[1], ca[2], ca[3], ca[8], ca[9], ca[10], ca[11])
}

// wait for outstanding tests to finish
func wait() {
        runtime.Gosched()
        for changeNproc(0) != 0 {
                runtime.Gosched()
        }
}

// run all tests with specified buffer size
func tests(c int) {
        ca := mkchan(c, 4)
        test1(ca[0])
        test1(ca[1])
        test1(ca[2])
        test1(ca[3])
        wait()

        test2(c)
        wait()

        test3(c)
        wait()

        test4(c)
        wait()

        test5(c)
        wait()

        test6(c)
        wait()
}

// run all test with 4 buffser sizes
func main() {

        tests(0)
        tests(1)
        tests(10)
        tests(100)

        t := 4 * // buffer sizes
                (4*4 + // tests 1,2,3,4 channels
                        8 + // test 5 channels
                        12) * // test 6 channels
                76 // sends/recvs on a channel

        if tots != t || totr != t {
                print("tots=", tots, " totr=", totr, " sb=", t, "\n")
                os.Exit(1)
        }
        os.Exit(0)
}