Index: benchmark/readyQ/locality.go
===================================================================
--- benchmark/readyQ/locality.go	(revision 90ecadea9792707606c9a33a28ac43a7f894d078)
+++ benchmark/readyQ/locality.go	(revision 2dd0689c02bb6821208983de34ad547817d60011)
@@ -2,4 +2,5 @@
 
 import (
+	"context"
 	"flag"
 	"fmt"
@@ -8,34 +9,60 @@
 	"sync/atomic"
 	"time"
+	"unsafe"
+	"golang.org/x/sync/semaphore"
 	"golang.org/x/text/language"
 	"golang.org/x/text/message"
 )
 
-func handshake(stop chan struct {}, c chan [] uint64, data [] uint64, share bool) (bool, [] uint64) {
-	var s [] uint64 = data
-	if !share {
-		s = nil
+type GoCtx struct {
+	s * semaphore.Weighted
+	d * [] uint64
+}
+
+type Spot struct {
+	ptr uintptr
+}
+
+func (this * Spot) put( s * semaphore.Weighted, data [] uint64, share bool) ([] uint64) {
+	ctx := GoCtx{s, &data}
+
+	var raw uintptr
+	for true {
+		raw = this.ptr
+		if raw == uintptr(1) {
+			return nil
+		}
+		if atomic.CompareAndSwapUintptr(&this.ptr, raw, uintptr(unsafe.Pointer(&ctx))) {
+			break
+		}
 	}
 
-	// send the data
-	select {
-	case <- stop:
-		return true, nil
-	case c <- s:
+	if raw != uintptr(0) {
+		val := (*GoCtx)(unsafe.Pointer(raw))
+		if share {
+			val.d = &data
+		}
+
+		val.s.Release(1)
 	}
 
-	// get the new data chunk
-	select {
-	case <- stop:
-		return true, nil
-	case n := <- c:
-		if share {
-			return false, n
-		}
-		return false, data
-	}
+	ctx.s.Acquire(context.Background(), 1)
+
+	return *ctx.d
 }
 
-func local(result chan uint64, start chan struct{}, stop chan struct{}, size uint64, cnt uint64, channels []chan [] uint64, chan_cnt uint64, share bool) {
+func (this * Spot) release() {
+	val := (*GoCtx)(unsafe.Pointer(atomic.SwapUintptr(&this.ptr, uintptr(1))))
+	if val == nil {
+		return
+	}
+
+	val.s.Release(1)
+}
+
+
+
+func local(result chan uint64, start chan struct{}, size uint64, cnt uint64, channels [] Spot, share bool) {
+    	lrand := rand.New(rand.NewSource(rand.Int63()))
 	var data [] uint64
 	data = make([]uint64, size)
@@ -43,18 +70,24 @@
 		data[i] = 0
 	}
+
+	sem := semaphore.NewWeighted(1)
+	sem.Acquire(context.Background(), 1)
+
 	count := uint64(0)
 	<- start
 	for true {
 		for i := uint64(0); i < cnt; i++ {
-			data[rand.Uint64() % size] += 1
+			data[lrand.Uint64() % size] += 1
 		}
 
-		i := rand.Uint64() % chan_cnt
-		var closed bool
-		closed, data = handshake(stop, channels[i], data, share)
+		i := lrand.Int() % len(channels)
+		data = channels[i].put(sem, data, share)
 		count += 1
 
-		if  closed { break }
+		if  clock_mode && atomic.LoadInt32(&stop) == 1 { break }
 		if !clock_mode && count >= stop_count { break }
+		if uint64(len(data)) != size {
+			panic("Data has weird size")
+		}
 	}
 
@@ -64,10 +97,9 @@
 
 func main() {
-
 	work_sizeOpt := flag.Uint64("w", 2    , "Number of words (uint64) per threads")
 	countOpt     := flag.Uint64("c", 2    , "Number of words (uint64) to touch")
 	shareOpt     := flag.Bool  ("s", false, "Pass the work data to the next thread when blocking")
 
-	bench_init()
+	defer bench_init()()
 
 	size  := *work_sizeOpt
@@ -81,17 +113,17 @@
 
 	barrierStart := make(chan struct{})
-	barrierStop  := make(chan struct{})
 	threads_left = int64(nthreads)
 	result  := make(chan uint64)
-	channels := make([]chan [] uint64, nthreads - nprocs)
+	channels := make([]Spot, nthreads - nprocs)
 	for i := range channels {
-		channels[i] = make(chan [] uint64, 1)
+		channels[i] = Spot{uintptr(0)}
 	}
 
 	for i := 0; i < nthreads; i++ {
-		go local(result, barrierStart, barrierStop, size, cnt, channels, uint64(nthreads - nprocs), share)
+		go local(result, barrierStart, size, cnt, channels, share)
 	}
 	fmt.Printf("Starting\n");
 
+	atomic.StoreInt32(&stop, 0)
 	start := time.Now()
 	close(barrierStart)
@@ -99,9 +131,13 @@
 	wait(start, true);
 
-	close(barrierStop)
+	atomic.StoreInt32(&stop, 1)
 	end := time.Now()
 	delta := end.Sub(start)
 
 	fmt.Printf("\nDone\n")
+
+	for i := range channels {
+		channels[i].release()
+	}
 
 	global_counter := uint64(0)