rename

Author: csimplestring

map.go

@@ -1,99 +1,37 @@
 package lrc
 
-import (
-	"runtime"
-	"sync/atomic"
-)
-
-const ReadOnLeft int32 = -1
-const ReadOnRight int32 = 1
-
 type LRMap struct {
-	readIndicators [2]*readIndicator
-	versionIndex   *int32
-	sideToRead     *int32
+	*LeftRight
 
 	left  map[int]int
 	right map[int]int
 }
 
-func New() *LRMap {
+func newIntMap() *LRMap {
 
 	m := &LRMap{
-		readIndicators: [2]*readIndicator{
-			newReadIndicator(),
-			newReadIndicator(),
-		},
-		versionIndex: new(int32),
-		sideToRead:   new(int32),
-
 		left:  make(map[int]int),
 		right: make(map[int]int),
 	}
 
-	*m.versionIndex = 0
-	*m.sideToRead = ReadOnLeft
-	return m
-}
-
-func (lr *LRMap) arrive() int {
-	idx := atomic.LoadInt32(lr.versionIndex)
-	lr.readIndicators[idx].arrive()
-	return int(idx)
-}
-
-func (lr *LRMap) depart(localVI int) {
-	lr.readIndicators[localVI].depart()
-}
-
-func (lr *LRMap) toggleVersionAndWait() {
-
-	localVI := atomic.LoadInt32(lr.versionIndex)
-	prevVI := int(localVI % 2)
-	nextVI := int((localVI + 1) % 2)
-
-	for !lr.readIndicators[nextVI].isEmpty() {
-		runtime.Gosched()
-	}
-
-	atomic.StoreInt32(lr.versionIndex, int32(nextVI))
+	m.LeftRight = New()
 
-	for !lr.readIndicators[prevVI].isEmpty() {
-		runtime.Gosched()
-	}
+	return m
 }
 
 func (lr *LRMap) Get(k int) (val int, exist bool) {
 
-	lvi := lr.arrive()
-
-	which := atomic.LoadInt32(lr.sideToRead)
-	if which == ReadOnLeft {
-		val, exist = lr.left[k]
-	} else {
-		val, exist = lr.right[k]
-	}
+	lr.ApplyReadFn(lr.left, lr.right, func(instance interface{}) {
+		m := instance.(map[int]int)
+		val, exist = m[k]
+	})
 
-	lr.depart(lvi)
 	return
 }
 
 func (lr *LRMap) Put(key, val int) {
-
-	side := atomic.LoadInt32(lr.sideToRead)
-	if side == ReadOnLeft {
-		// write on right
-		lr.right[key] = val
-		atomic.StoreInt32(lr.sideToRead, ReadOnRight)
-		lr.toggleVersionAndWait()
-		lr.left[key] = val
-	} else if side == ReadOnRight {
-		// write on left
-		lr.left[key] = val
-		atomic.StoreInt32(lr.sideToRead, ReadOnLeft)
-		lr.toggleVersionAndWait()
-		lr.right[key] = val
-	} else {
-		panic("illegal state: you can only read on LEFT or RIGHT")
-	}
+	lr.ApplyWriteFn(lr.left, lr.right, func(instance interface{}) {
+		m := instance.(map[int]int)
+		m[key] = val
+	})
 }

map_bench_test.go

@@ -45,7 +45,7 @@ func InitLockMap(num int) *LockMap {
 }
 
 func InitLRMap(num int) *LRMap {
-	lrmap := New()
+	lrmap := newIntMap()
 
 	for i := 0; i < num; i++ {
 		lrmap.Put(i, i)

map_test.go

@@ -7,7 +7,7 @@ import (
 )
 
 func TestLRMap(t *testing.T) {
-	lrmap := New()
+	lrmap := newIntMap()
 
 	wg := sync.WaitGroup{}
 

primitive.go

@@ -0,0 +1,93 @@
+package lrc
+
+import (
+	"runtime"
+	"sync/atomic"
+)
+
+const ReadOnLeft int32 = -1
+const ReadOnRight int32 = 1
+
+type LeftRight struct {
+	readIndicators [2]*readIndicator
+	versionIndex   *int32
+	sideToRead     *int32
+}
+
+func New() *LeftRight {
+
+	m := &LeftRight{
+		readIndicators: [2]*readIndicator{
+			newReadIndicator(),
+			newReadIndicator(),
+		},
+		versionIndex: new(int32),
+		sideToRead:   new(int32),
+	}
+
+	*m.versionIndex = 0
+	*m.sideToRead = ReadOnLeft
+	return m
+}
+
+func (lr *LeftRight) arrive() int {
+	idx := atomic.LoadInt32(lr.versionIndex)
+	lr.readIndicators[idx].arrive()
+	return int(idx)
+}
+
+func (lr *LeftRight) depart(localVI int) {
+	lr.readIndicators[localVI].depart()
+}
+
+func (lr *LeftRight) toggleVersionAndWait() {
+
+	localVI := atomic.LoadInt32(lr.versionIndex)
+	prevVI := int(localVI % 2)
+	nextVI := int((localVI + 1) % 2)
+
+	for !lr.readIndicators[nextVI].isEmpty() {
+		runtime.Gosched()
+	}
+
+	atomic.StoreInt32(lr.versionIndex, int32(nextVI))
+
+	for !lr.readIndicators[prevVI].isEmpty() {
+		runtime.Gosched()
+	}
+}
+
+func (lr *LeftRight) ApplyReadFn(l interface{}, r interface{}, fn func(interface{})) {
+
+	lvi := lr.arrive()
+
+	which := atomic.LoadInt32(lr.sideToRead)
+	if which == ReadOnLeft {
+		fn(l)
+	} else {
+		fn(r)
+	}
+
+	lr.depart(lvi)
+	return
+}
+
+func (lr *LRMap) ApplyWriteFn(l interface{}, r interface{}, fn func(interface{})) {
+
+	side := atomic.LoadInt32(lr.sideToRead)
+	if side == ReadOnLeft {
+		// write on right
+		fn(r)
+		atomic.StoreInt32(lr.sideToRead, ReadOnRight)
+		lr.toggleVersionAndWait()
+		fn(l)
+	} else if side == ReadOnRight {
+		// write on left
+		fn(l)
+		atomic.StoreInt32(lr.sideToRead, ReadOnLeft)
+		lr.toggleVersionAndWait()
+		fn(r)
+	} else {
+		panic("illegal state: you can only read on LEFT or RIGHT")
+	}
+}