all: move to golang.design/x/lockfree

changkun · changkun · commit dc21d35b6daa · 2020-09-25T11:09:27.000+02:00
diff --git a/.github/workflows/lockfree.yml b/.github/workflows/lockfree.yml
@@ -0,0 +1,37 @@
+name: lockfree
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+
+    - name: Set up Go 1.x
+      uses: actions/setup-go@v2
+      with:
+        go-version: ^1.13
+      id: go
+
+    - name: Check out code into the Go module directory
+      uses: actions/checkout@v2
+
+    - name: Get dependencies
+      run: |
+        go get -v -t -d ./...
+
+    - name: Test
+      run: |
+        go test -v -race -timeout 60m -coverprofile=coverage.txt -covermode=atomic ./...
+
+    - name: Upload coverage profile
+      uses: codecov/codecov-action@v1
+      with:
+        token: ${{secrets.CODECOV_TOKEN}}
+        file: coverage.txt
diff --git a/.travis.yml b/.travis.yml
diff --git a/LICENSE b/LICENSE
@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019 Ou Changkun
+Copyright (c) 2019-2020 The golang.design Authors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/Makefile b/Makefile
@@ -1,3 +1,7 @@
+# Copyright 2020 The golang.design Initiative authors.
+# All rights reserved. Use of this source code is governed
+# by a MIT license that can be found in the LICENSE file.
+
 COUNT := $(if $(COUNT),$(COUNT),1)
 
 all:
diff --git a/README.md b/README.md
@@ -1,47 +1,19 @@
 # lockfree
 
-[![GoDoc](https://godoc.org/github.com/changkun/lockfree?status.svg)](https://godoc.org/github.com/changkun/lockfree)
-[![Build Status](https://travis-ci.org/changkun/lockfree.svg?branch=master)](https://travis-ci.org/changkun/lockfree) [![Go Report Card](https://goreportcard.com/badge/github.com/changkun/lockfree)](https://goreportcard.com/report/github.com/changkun/lockfree) [![codecov](https://codecov.io/gh/changkun/lockfree/branch/master/graph/badge.svg)](https://codecov.io/gh/changkun/lockfree) [![](https://img.shields.io/github/release/changkun/lockfree/all.svg)](https://github.com/changkun/lockfree/releases)
+[![PkgGoDev](https://pkg.go.dev/badge/golang.design/x/lockfree)](https://pkg.go.dev/golang.design/x/lockfree) [![Go Report Card](https://goreportcard.com/badge/golang.design/x/lockfree)](https://goreportcard.com/report/golang.design/x/lockfree)
+![lockfree](https://github.com/golang-design/lockfree/workflows/lockfree/badge.svg?branch=master)
+[![codecov](https://codecov.io/gh/golang-design/lockfree/branch/master/graph/badge.svg)](https://codecov.io/gh/golang-design/lockfree)
 
-Package lock-free offers lock-free utilities in Go.
-
-## Contributing
-
-We would love to have your experiences. Feel free to [submit an issue](https://github.com/changkun/lockfree/issues/new) for requesting new implementation or bug report.
-
-## List of Algorithms
-
-### Linked List
-
-- [ ] Harris, Timothy L. "A pragmatic implementation of non-blocking linked-lists." International Symposium on Distributed Computing. Springer, Berlin, Heidelberg, 2001. [PDF](https://pdfs.semanticscholar.org/68a9/005a5ec10daece36ca5ecb9cad7be44770b1.pdf)
-- [ ] Sundell, Hakan, and Philippas Tsigas. "Lock-Free and Practical Deques and Doubly Linked Lists using Single-Word Compare-And-Swap." 2004 [PDF](https://pdfs.semanticscholar.org/8a68/f45bd32ed050a96faa24139ab71178258f13.pdf)
-- [ ] Valois, John D. "Lock-free linked lists using compare-and-swap." PODC. Vol. 95. 1995. [PDF](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.41.9506&rep=rep1&type=pdf)
-
-### Queue
 
-- [x] Maged M. Michael and Michael L. Scott. 1996. Simple, fast, and practical non-blocking and blocking concurrent queue algorithms. In Proceedings of the fifteenth annual ACM symposium on Principles of distributed computing (PODC '96). ACM, New York, NY, USA, 267-275. [PDF](https://apps.dtic.mil/dtic/tr/fulltext/u2/a309412.pdf)
-- [ ] Shann, Chien-Hua, Ting-Lu Huang, and Cheng Chen. "A practical nonblocking queue algorithm using compare-and-swap." Proceedings Seventh International Conference on Parallel and Distributed Systems (Cat. No. PR00568). IEEE, 2000. [PDF](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.199.7928&rep=rep1&type=pdf)
-- [ ] Fober, Dominique, Yann Orlarey, and Stéphane Letz. "Optimised lock-free FIFO queue." (2001). [PDF](https://hal.archives-ouvertes.fr/hal-02158792/document)
-- [ ] Evequoz, Claude. "Non-blocking concurrent fifo queues with single word synchronization primitives." 2008 37th International Conference on Parallel Processing. IEEE, 2008. [PDF](https://www.liblfds.org/downloads/white%20papers/%5BQueue%5D%20-%20%5BEvequoz%5D%20-%20Non-Blocking%20Concurrent%20FIFO%20Queues%20With%20Single%20Word%20Synchroniation%20Primitives.pdf)
-
-### Skip-list
-
-- [ ] Fomitchev, Mikhail, and Eric Ruppert. "Lock-free linked lists and skip lists." Proceedings of the twenty-third annual ACM symposium on Principles of distributed computing. ACM, 2004. [PDF](http://people.scs.carleton.ca/~edwardduong/PDF_files_of_relevant_papers/2004%20-%20Lock-free%20Linked%20List%20and%20Skip%20Lists.pdf)
-- [ ] Herlihy, Maurice, et al. "A provably correct scalable concurrent skip list." Conference On Principles of Distributed Systems (OPODIS). 2006. [PDF](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.170.719&rep=rep1&type=pdf)
-
-### Stack
-
-- [ ] Hendler, Danny, Nir Shavit, and Lena Yerushalmi. "A scalable lock-free stack algorithm." Proceedings of the sixteenth annual ACM symposium on Parallelism in algorithms and architectures. ACM, 2004. [PDF](http://www.inf.ufsc.br/~dovicchi/pos-ed/pos/artigos/p206-hendler.pdf)
-
-### Tree
+Package lock-free offers lock-free utilities in Go.
 
-- [ ] Bronson, Nathan G., et al. "A practical concurrent binary search tree." ACM Sigplan Notices. Vol. 45. No. 5. ACM, 2010. [PDF](http://www.academia.edu/download/42135309/ppopp207-bronson.pdf)
-- [ ] Braginsky, Anastasia, and Erez Petrank. "A lock-free B+ tree." Proceedings of the twenty-fourth annual ACM symposium on Parallelism in algorithms and architectures. ACM, 2012. [PDF](http://www.cs.technion.ac.il/~erez/Papers/lfbtree-full.pdf)
-- [ ] Kim, Jong Ho, Helen Cameron, and Peter Graham. "Lock-free red-black trees using cas." Concurrency and Computation: Practice and experience (2006): 1-40. [PDF](https://www.cs.umanitoba.ca/~hacamero/Research/RBTreesKim.pdf)
+```
+import "golang.design/x/lockfree"
+```
 
-### Hash
+## Contributing
 
-- [ ] Michael, Maged M. "High performance dynamic lock-free hash tables and list-based sets." Proceedings of the fourteenth annual ACM symposium on Parallel algorithms and architectures. ACM, 2002. [PDF](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.114.5854&rep=rep1&type=pdf)
+We would love to have your experiences. Feel free to [submit an issue](https://golang.design/x/lockfree/issues/new) for requesting a new implementation or bug report.
 
 ## License
 
diff --git a/TODO.md b/TODO.md
@@ -0,0 +1,35 @@
+# TODO LIST
+
+## List of Algorithms
+
+### Linked List
+
+- [ ] Harris, Timothy L. "A pragmatic implementation of non-blocking linked-lists." International Symposium on Distributed Computing. Springer, Berlin, Heidelberg, 2001. [PDF](https://pdfs.semanticscholar.org/68a9/005a5ec10daece36ca5ecb9cad7be44770b1.pdf)
+- [ ] Sundell, Hakan, and Philippas Tsigas. "Lock-Free and Practical Deques and Doubly Linked Lists using Single-Word Compare-And-Swap." 2004 [PDF](https://pdfs.semanticscholar.org/8a68/f45bd32ed050a96faa24139ab71178258f13.pdf)
+- [ ] Valois, John D. "Lock-free linked lists using compare-and-swap." PODC. Vol. 95. 1995. [PDF](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.41.9506&rep=rep1&type=pdf)
+
+### Queue
+
+- [x] Maged M. Michael and Michael L. Scott. 1996. Simple, fast, and practical non-blocking and blocking concurrent queue algorithms. In Proceedings of the fifteenth annual ACM symposium on Principles of distributed computing (PODC '96). ACM, New York, NY, USA, 267-275. [PDF](https://apps.dtic.mil/dtic/tr/fulltext/u2/a309412.pdf)
+- [ ] Shann, Chien-Hua, Ting-Lu Huang, and Cheng Chen. "A practical nonblocking queue algorithm using compare-and-swap." Proceedings Seventh International Conference on Parallel and Distributed Systems (Cat. No. PR00568). IEEE, 2000. [PDF](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.199.7928&rep=rep1&type=pdf)
+- [ ] Fober, Dominique, Yann Orlarey, and Stéphane Letz. "Optimised lock-free FIFO queue." (2001). [PDF](https://hal.archives-ouvertes.fr/hal-02158792/document)
+- [ ] Evequoz, Claude. "Non-blocking concurrent fifo queues with single word synchronization primitives." 2008 37th International Conference on Parallel Processing. IEEE, 2008. [PDF](https://www.liblfds.org/downloads/white%20papers/%5BQueue%5D%20-%20%5BEvequoz%5D%20-%20Non-Blocking%20Concurrent%20FIFO%20Queues%20With%20Single%20Word%20Synchroniation%20Primitives.pdf)
+
+### Skip-list
+
+- [ ] Fomitchev, Mikhail, and Eric Ruppert. "Lock-free linked lists and skip lists." Proceedings of the twenty-third annual ACM symposium on Principles of distributed computing. ACM, 2004. [PDF](http://people.scs.carleton.ca/~edwardduong/PDF_files_of_relevant_papers/2004%20-%20Lock-free%20Linked%20List%20and%20Skip%20Lists.pdf)
+- [ ] Herlihy, Maurice, et al. "A provably correct scalable concurrent skip list." Conference On Principles of Distributed Systems (OPODIS). 2006. [PDF](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.170.719&rep=rep1&type=pdf)
+
+### Stack
+
+- [ ] Hendler, Danny, Nir Shavit, and Lena Yerushalmi. "A scalable lock-free stack algorithm." Proceedings of the sixteenth annual ACM symposium on Parallelism in algorithms and architectures. ACM, 2004. [PDF](http://www.inf.ufsc.br/~dovicchi/pos-ed/pos/artigos/p206-hendler.pdf)
+
+### Tree
+
+- [ ] Bronson, Nathan G., et al. "A practical concurrent binary search tree." ACM Sigplan Notices. Vol. 45. No. 5. ACM, 2010. [PDF](http://www.academia.edu/download/42135309/ppopp207-bronson.pdf)
+- [ ] Braginsky, Anastasia, and Erez Petrank. "A lock-free B+ tree." Proceedings of the twenty-fourth annual ACM symposium on Parallelism in algorithms and architectures. ACM, 2012. [PDF](http://www.cs.technion.ac.il/~erez/Papers/lfbtree-full.pdf)
+- [ ] Kim, Jong Ho, Helen Cameron, and Peter Graham. "Lock-free red-black trees using cas." Concurrency and Computation: Practice and experience (2006): 1-40. [PDF](https://www.cs.umanitoba.ca/~hacamero/Research/RBTreesKim.pdf)
+
+### Hash
+
+- [ ] Michael, Maged M. "High performance dynamic lock-free hash tables and list-based sets." Proceedings of the fourteenth annual ACM symposium on Parallel algorithms and architectures. ACM, 2002. [PDF](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.114.5854&rep=rep1&type=pdf)
diff --git a/arithmetic.go b/arithmetic.go
@@ -1,3 +1,7 @@
+// Copyright 2020 The golang.design Initiative authors.
+// All rights reserved. Use of this source code is governed
+// by a MIT license that can be found in the LICENSE file.
+
 package lockfree
 
 import (
diff --git a/arithmetic_test.go b/arithmetic_test.go
@@ -1,10 +1,14 @@
+// Copyright 2020 The golang.design Initiative authors.
+// All rights reserved. Use of this source code is governed
+// by a MIT license that can be found in the LICENSE file.
+
 package lockfree_test
 
 import (
 	"sync"
 	"testing"
 
-	"github.com/changkun/lockfree"
+	"golang.design/x/lockfree"
 )
 
 func TestAddFloat64(t *testing.T) {
diff --git a/common.go b/common.go
@@ -1,3 +1,7 @@
+// Copyright 2020 The golang.design Initiative authors.
+// All rights reserved. Use of this source code is governed
+// by a MIT license that can be found in the LICENSE file.
+
 package lockfree
 
 import (
diff --git a/doc.go b/doc.go
@@ -1,2 +1,8 @@
+// Copyright 2020 The golang.design Initiative authors.
+// All rights reserved. Use of this source code is governed
+// by a MIT license that can be found in the LICENSE file.
+
 // Package lockfree offers lock-free utilities
-package lockfree
+//
+// Note that this package is under development and not for production use.
+package lockfree // import "golang.design/x/lockfree"
diff --git a/go.mod b/go.mod
@@ -1,3 +1,3 @@
-module github.com/changkun/lockfree
+module golang.design/x/lockfree
 
-go 1.12
+go 1.13
diff --git a/go.sum b/go.sum
diff --git a/queue.go b/queue.go
@@ -1,3 +1,7 @@
+// Copyright 2020 The golang.design Initiative authors.
+// All rights reserved. Use of this source code is governed
+// by a MIT license that can be found in the LICENSE file.
+
 package lockfree
 
 import (
diff --git a/queue_test.go b/queue_test.go
@@ -1,3 +1,7 @@
+// Copyright 2020 The golang.design Initiative authors.
+// All rights reserved. Use of this source code is governed
+// by a MIT license that can be found in the LICENSE file.
+
 package lockfree_test
 
 import (
@@ -7,7 +11,7 @@ import (
 	"sync/atomic"
 	"testing"
 
-	"github.com/changkun/lockfree"
+	"golang.design/x/lockfree"
 )
 
 func TestQueueDequeueEmpty(t *testing.T) {
diff --git a/rbtree.go b/rbtree.go
@@ -1,3 +1,7 @@
+// Copyright 2020 The golang.design Initiative authors.
+// All rights reserved. Use of this source code is governed
+// by a MIT license that can be found in the LICENSE file.
+
 package lockfree
 
 import "fmt"
diff --git a/rbtree_test.go b/rbtree_test.go
@@ -1,11 +1,15 @@
+// Copyright 2020 The golang.design Initiative authors.
+// All rights reserved. Use of this source code is governed
+// by a MIT license that can be found in the LICENSE file.
+
 package lockfree_test
 
 import (
 	"fmt"
 	"math/rand"
 	"testing"
 
-	"github.com/changkun/lockfree"
+	"golang.design/x/lockfree"
 )
 
 type UniqueRand struct {
diff --git a/ringbuffer.go b/ringbuffer.go
@@ -0,0 +1,70 @@
+// Copyright 2020 The golang.design Initiative authors.
+// All rights reserved. Use of this source code is governed
+// by a MIT license that can be found in the LICENSE file.
+
+package lockfree
+
+// RingBuffer implements ring buffer queue
+type RingBuffer struct {
+	buf        []interface{}
+	head, tail int
+	len, cap   int
+}
+
+// NewRingBuffer creates a ring buffer with given capacity
+func NewRingBuffer(capacity int) *RingBuffer {
+	return &RingBuffer{
+		buf: make([]interface{}, capacity),
+		cap: capacity,
+	}
+}
+
+// Put puts x into ring buffer
+func (rb *RingBuffer) Put(x interface{}) (ok bool) {
+	if rb.len == rb.cap {
+		return
+	}
+
+	rb.buf[rb.tail] = x
+	rb.tail++
+	if rb.tail > rb.cap-1 {
+		rb.tail = 0
+	}
+	rb.len++
+	ok = true
+	return
+}
+
+// Get gets the first element from queue
+func (rb *RingBuffer) Get() (x interface{}) {
+	x = rb.buf[rb.head]
+	rb.head++
+	if rb.head > rb.cap-1 {
+		rb.head = 0
+	}
+	rb.len--
+	return
+}
+
+// IsFull checks if the ring buffer is full
+func (rb *RingBuffer) IsFull() bool {
+	return rb.len == rb.cap
+}
+
+// LookAll reads all elements from ring buffer
+// this method doesn't consume all elements
+func (rb *RingBuffer) LookAll() []interface{} {
+	all := make([]interface{}, rb.len)
+	j := 0
+	for i := rb.head; ; i++ {
+		if i > rb.cap-1 {
+			i = 0
+		}
+		if i == rb.tail && j > 0 {
+			break
+		}
+		all[j] = rb.buf[i]
+		j++
+	}
+	return all
+}
diff --git a/ringbuffer_test.go b/ringbuffer_test.go
@@ -0,0 +1,44 @@
+// Copyright 2020 The golang.design Initiative authors.
+// All rights reserved. Use of this source code is governed
+// by a MIT license that can be found in the LICENSE file.
+
+package lockfree_test
+
+import (
+	"reflect"
+	"testing"
+
+	"golang.design/x/lockfree"
+)
+
+func TestRingBuffer(t *testing.T) {
+	rb := lockfree.NewRingBuffer(10)
+
+	for i := 0; i < 20; i++ {
+		ok := rb.Put(i)
+		if i < 10 && !ok {
+			t.Errorf("put failed, %v:%v", i, ok)
+		}
+		if i > 9 && ok {
+			t.Errorf("put failed, %v:%v", i, ok)
+		}
+	}
+	v := rb.LookAll()
+	want := []interface{}{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
+	if !reflect.DeepEqual(v, want) {
+		t.Errorf("not equal: %v", v)
+	}
+
+	for i := 0; i < 5; i++ {
+		v := rb.Get()
+		if v != i {
+			t.Errorf("get failed, %v:%v", v, i)
+		}
+	}
+
+	v = rb.LookAll()
+	want = []interface{}{5, 6, 7, 8, 9}
+	if !reflect.DeepEqual(v, want) {
+		t.Errorf("not equal")
+	}
+}
diff --git a/search.go b/search.go
@@ -1,3 +1,7 @@
+// Copyright 2020 The golang.design Initiative authors.
+// All rights reserved. Use of this source code is governed
+// by a MIT license that can be found in the LICENSE file.
+
 package lockfree
 
 // BinarySearch implements binary search algorithm.
diff --git a/search_test.go b/search_test.go
@@ -1,9 +1,13 @@
+// Copyright 2020 The golang.design Initiative authors.
+// All rights reserved. Use of this source code is governed
+// by a MIT license that can be found in the LICENSE file.
+
 package lockfree_test
 
 import (
 	"testing"
 
-	"github.com/changkun/lockfree"
+	"golang.design/x/lockfree"
 )
 
 func TestBinarySearch(t *testing.T) {
diff --git a/skiplist.go b/skiplist.go
diff --git a/skiplist_test.go b/skiplist_test.go
diff --git a/stack.go b/stack.go
diff --git a/stack_test.go b/stack_test.go
