source: doc/theses/colby_parsons_MMAth/benchmarks/channels/go/contend.go@ e10714a

package main

import (
        "fmt"
        "sync"
        "time"
        "runtime"
        "os"
        "strconv"
)

var Processors, Channels, ProdsPerChan, ConsPerChan, ChannelSize int = 1, 1, 1, 1, 128
var cons_done, prod_done bool = false, false;
var total_operations, cons_check, prod_check uint64 = 0, 0, 0
var m sync.Mutex

var prodJoin chan int = make(chan int, ProdsPerChan * Channels + 1)
var consJoin chan int = make(chan int, ConsPerChan * Channels + 1)

func consumer( channel chan uint64 ) {
        var count uint64 = 0
        var checksum uint64 = 0
        for {
                if cons_done { break }
                j := <- channel
                checksum = checksum ^ j
                if ! prod_done { count++ }
        }
        m.Lock()
        total_operations += count
        cons_check = cons_check ^ checksum
        // fmt.Print("C: ",count)
        m.Unlock()
        consJoin <- 0
}

func producer( channel chan uint64 ) {
        var count uint64 = 0
        var checksum uint64 = 0
        for {
                if prod_done { break }
                checksum = checksum ^ count
                channel <- count
                count++
        }
        m.Lock()
        total_operations += count
        prod_check = prod_check ^ checksum
        // fmt.Print("P: ",count, " ")
        m.Unlock()
        prodJoin <- 0
}

func usage() {
        fmt.Printf( "Usage: %v " +
                "[ processors (> 0) | 'd' (default %v) ] " +
                "[ ChannelSize (> 0) | 'd' (default %v) ]\n",
                os.Args[0], Processors, ChannelSize );
        os.Exit( 1 );
}

func main() {
        switch len( os.Args ) {
                case 3:
                        if os.Args[2] != "d" {                                                  // default ?
                                ChannelSize, _ = strconv.Atoi( os.Args[1] )
                                        if ChannelSize < 0 { usage(); }
                        } // if
                fallthrough
                case 2:
                        if os.Args[1] != "d" {                                                  // default ?
                                Processors, _ = strconv.Atoi( os.Args[1] )
                                if Processors < 1 { usage(); }
                        } // if
                case 1:                                                                                 // use defaults
                default:
                usage();
        } // switch
        runtime.GOMAXPROCS( Processors );
        ProdsPerChan = Processors
        ConsPerChan = Processors

        // fmt.Println("Processors: ",Processors," Channels: ",Channels," ProdsPerChan: ",ProdsPerChan," ConsPerChan: ",ConsPerChan," Channel Size: ",ChannelSize)
        
        chans := make( [] chan uint64, Channels )
        for i := range chans {
                chans[i] = make(chan uint64, ChannelSize)
        }
        for i := range chans {
                for j := 0; j < ProdsPerChan; j++ {
                        go producer( chans[i] )
                }

                for j := 0; j < ConsPerChan; j++ {
                        go consumer( chans[i] )
                }
        }
                

        // wait 10 seconds
        time.Sleep(time.Second * 10)
        // fmt.Println("prod done\n")
        prod_done = true
        for j := 0; j < ProdsPerChan * Channels ; j++ {
                <-prodJoin
        }
        // fmt.Println("cons done\n")
        cons_done = true
        for i := range chans {
                J: for j := 0; j < ConsPerChan; j++ {
                        select {
                                case chans[i] <- 0:
                                        
                                default:
                                        break J
                        }
                }
        }
        for j := 0; j < ConsPerChan * Channels; j++{
                <-consJoin
        }
        
        // for i := range chans {
        //      L: for {
        //              select {
        //                      case k := <-chans[i]:
        //                              cons_check = cons_check ^ k
        //                      default:
        //                              break L
        //              }
        //      }
        // }
        if cons_check != prod_check {
                fmt.Println("\nChecksum mismatch: Cons: %d, Prods: %d", cons_check, prod_check)
        }
        for i := range chans {
                close(chans[i])
        }
    fmt.Println(total_operations)
}