move to genx

Author: OneOfOne

README.md

@@ -1,5 +1,5 @@
 # cmap [![GoDoc](https://godoc.org/github.com/OneOfOne/cmap?status.svg)](https://godoc.org/github.com/OneOfOne/cmap) [![Build Status](https://travis-ci.org/OneOfOne/cmap.svg?branch=master)](https://travis-ci.org/OneOfOne/cmap) [![Coverage](https://gocover.io/_badge/github.com/OneOfOne/cmap)](https://gocover.io/github.com/OneOfOne/cmap)
---
+
 
 CMap (concurrent-map) is a sharded map implementation to support fast concurrent access.
 

cmap.go

@@ -1,20 +1,25 @@
-// AUTO-GENERATED by cmap-gen
-// DO NOT EDIT"
-// generated from github.com/OneOfOne/cmap/internal/cmap
+// This file was automatically generated by genx.
+// Any changes will be lost if this file is regenerated.
+// see https://github.com/OneOfOne/genx
+// command: genx -pkg ./internal/cmap -t KT=interface{} -t VT=interface{} -m -o ./cmap.go
 
 package cmap
 
 import (
 	"context"
 	"sync"
+
+	"github.com/OneOfOne/cmap/hashers"
 )
 
+// DefaultShardCount is the default number of shards to use when New() or NewFromJSON() are called. The default is 256.
+const DefaultShardCount = 1 << 8
+
 // CMap is a concurrent safe sharded map to scale on multiple cores.
 type CMap struct {
 	shards   []*LMap
 	keysPool sync.Pool
-	// HashFn allows using a custom hash function that's used to determain the key's shard.
-	// Defaults to DefaultKeyHasher.
+	// HashFn allows using a custom hash function that's used to determain the key's shard. Defaults to DefaultKeyHasher.
 	HashFn func(interface{}) uint32
 }
 
@@ -31,17 +36,22 @@ func NewSize(shardCount int) *CMap {
 	} else if shardCount&(shardCount-1) != 0 {
 		panic("shardCount must be a power of 2")
 	}
+
 	cm := &CMap{
 		shards: make([]*LMap, shardCount),
 		HashFn: DefaultKeyHasher,
 	}
+
 	cm.keysPool.New = func() interface{} {
 		out := make([]interface{}, 0, DefaultShardCount) // good starting round
-		return &out                                      // return a ptr to avoid extra allocation on Get/Put
+
+		return &out // return a ptr to avoid extra allocation on Get/Put
 	}
+
 	for i := range cm.shards {
 		cm.shards[i] = NewLMapSize(shardCount)
 	}
+
 	return cm
 }
 
@@ -58,7 +68,7 @@ func (cm *CMap) Set(key interface{}, val interface{}) {
 }
 
 // SetIfNotExists will only assign val to key if it wasn't already set.
-// Use `CMap.Update` if you need more logic.
+// Use `Update` if you need more logic.
 func (cm *CMap) SetIfNotExists(key interface{}, val interface{}) (set bool) {
 	h := cm.HashFn(key)
 	return cm.shards[h&uint32(len(cm.shards)-1)].SetIfNotExists(key, val)
@@ -122,12 +132,14 @@ func (cm *CMap) Keys() []interface{} {
 func (cm *CMap) ForEach(fn func(key interface{}, val interface{}) bool) bool {
 	keysP := cm.keysPool.Get().(*[]interface{})
 	defer cm.keysPool.Put(keysP)
+
 	for _, lm := range cm.shards {
 		keys := (*keysP)[:0]
 		if !lm.ForEach(keys, fn) {
 			return false
 		}
 	}
+
 	return false
 }
 
@@ -140,6 +152,7 @@ func (cm *CMap) ForEachLocked(fn func(key interface{}, val interface{}) bool) bo
 			return false
 		}
 	}
+
 	return true
 }
 
@@ -192,6 +205,7 @@ func (cm *CMap) iterContext(ctx context.Context, ch chan<- *KV, locked bool) {
 			return true
 		}
 	}
+
 	if locked {
 		_ = cm.ForEachLocked(fn)
 	} else {
@@ -202,6 +216,9 @@ func (cm *CMap) iterContext(ctx context.Context, ch chan<- *KV, locked bool) {
 // NumShards returns the number of shards in the map.
 func (cm *CMap) NumShards() int { return len(cm.shards) }
 
+// DefaultKeyHasher is an alias for hashers.TypeHasher32(key).
+func DefaultKeyHasher(key interface{}) uint32 { return hashers.TypeHasher32(key) }
+
 // LMap is a simple sync.RWMutex locked map.
 // Used by CMap internally for sharding.
 type LMap struct {
@@ -214,7 +231,7 @@ func NewLMap() *LMap {
 	return NewLMapSize(0)
 }
 
-// NewLMapSize is the equivalent of `m := make(map[interface{}]interface{}, cap)`
+// NewLMapSize is the equivalent of `m := make(map[KT]VT, cap)`
 func NewLMapSize(cap int) *LMap {
 	return &LMap{
 		m: make(map[interface{}]interface{}, cap),
@@ -306,6 +323,7 @@ func (lm *LMap) ForEach(keys []interface{}, fn func(key interface{}, val interfa
 		keys = append(keys, key)
 	}
 	lm.l.RUnlock()
+
 	for _, key := range keys {
 		lm.l.RLock()
 		val, ok := lm.m[key]
@@ -317,6 +335,7 @@ func (lm *LMap) ForEach(keys []interface{}, fn func(key interface{}, val interfa
 			return false
 		}
 	}
+
 	return true
 }
 
@@ -326,11 +345,13 @@ func (lm *LMap) ForEach(keys []interface{}, fn func(key interface{}, val interfa
 func (lm *LMap) ForEachLocked(fn func(key interface{}, val interface{}) bool) bool {
 	lm.l.RLock()
 	defer lm.l.RUnlock()
+
 	for key, val := range lm.m {
 		if !fn(key, val) {
 			return false
 		}
 	}
+
 	return true
 }
 

cmap_go18_test.go

@@ -4,13 +4,12 @@ import (
 	"context"
 	"fmt"
 	"strconv"
-	"sync"
 	"testing"
 
 	"github.com/OneOfOne/cmap"
 )
 
-var keys [1e5]string
+var keys [1e5]interface{}
 
 func init() {
 	for i := range keys {
@@ -63,26 +62,8 @@ func BenchmarkCMap(b *testing.B) {
 	}
 }
 
-type mutexMap struct {
-	sync.RWMutex
-	m map[interface{}]interface{}
-}
-
-func (mm *mutexMap) Set(k interface{}, v interface{}) {
-	mm.Lock()
-	mm.m[k] = v
-	mm.Unlock()
-}
-
-func (mm *mutexMap) Get(k interface{}) interface{} {
-	mm.RLock()
-	v := mm.m[k]
-	mm.RUnlock()
-	return v
-}
-
-func BenchmarkMutexMap(b *testing.B) {
-	cm := mutexMap{m: make(map[interface{}]interface{}, cmap.DefaultShardCount)}
+func BenchmarkLMap(b *testing.B) {
+	cm := cmap.NewLMapSize(cmap.DefaultShardCount)
 	b.ResetTimer()
 	b.RunParallel(func(pb *testing.PB) {
 		var i int
@@ -96,6 +77,6 @@ func BenchmarkMutexMap(b *testing.B) {
 		}
 	})
 	if testing.Verbose() {
-		b.Logf("size: %v", len(cm.m))
+		b.Logf("size: %v", cm.Len())
 	}
 }