Decent optimization, prevent most of heap leaks.

Before:
```
BenchmarkCMap/2048-8    50000000               105 ns/op              48 B/op          3 allocs/op
BenchmarkCMap/4096-8    50000000               109 ns/op              48 B/op          3 allocs/op
BenchmarkCMap/8192-8    50000000               107 ns/op              48 B/op          3 allocs/op
```

After:
```
BenchmarkCMap/2048-8    100000000               84.1 ns/op            48 B/op          3 allocs/op
BenchmarkCMap/4096-8    100000000               86.3 ns/op            48 B/op          3 allocs/op
BenchmarkCMap/8192-8    100000000               92.1 ns/op            48 B/op          3 allocs/op
```

Author: OneOfOne

README.md

@@ -48,21 +48,21 @@ func main() {
 
 ## Benchmark
 ```bash
-➤ go1.9rc2 test -v -bench=. -benchtime=5s -tags streamrail -benchmem -cpu 8 -short ./ ./stringcmap
+➤ go1.9rc2 test -v -bench=. -benchtime=5s -tags streamrail -benchmem -cpu 8 -short ./...
 
 goos: linux
 goarch: amd64
 pkg: github.com/OneOfOne/cmap
 
-BenchmarkCMap/2048-8  	50000000	       147 ns/op	      48 B/op	       3 allocs/op
-BenchmarkCMap/4096-8  	50000000	       134 ns/op	      48 B/op	       3 allocs/op
-BenchmarkCMap/8192-8  	50000000	       128 ns/op	      48 B/op	       3 allocs/op
+BenchmarkCMap/2048-8  	100000000	        85.3 ns/op	      48 B/op	       3 allocs/op
+BenchmarkCMap/4096-8  	100000000	        88.2 ns/op	      48 B/op	       3 allocs/op
+BenchmarkCMap/8192-8  	100000000	        92.3 ns/op	      48 B/op	       3 allocs/op
 
 # simple map[interface{}]interface{} wrapped with a sync.RWMutex
-BenchmarkMutexMap-8   	20000000	       404 ns/op	      32 B/op	       2 allocs/op
+BenchmarkMutexMap-8   	20000000	       491 ns/op	      32 B/op	       2 allocs/op
 
 # sync.Map
-BenchmarkSyncMap-8    	50000000	       141 ns/op	      48 B/op	       3 allocs/op
+BenchmarkSyncMap-8    	50000000	       124 ns/op	      48 B/op	       3 allocs/op
 
 PASS
 ok  	github.com/OneOfOne/cmap	40.197s
@@ -72,14 +72,14 @@ goarch: amd64
 pkg: github.com/OneOfOne/cmap/stringcmap
 
 # specialized version of CMap, using map[string]interface{} internally
-BenchmarkStringCMap/2048-8         	100000000	        61.5 ns/op	      16 B/op	       1 allocs/op
-BenchmarkStringCMap/4096-8         	100000000	        58.0 ns/op	      16 B/op	       1 allocs/op
-BenchmarkStringCMap/8192-8         	100000000	        51.1 ns/op	      16 B/op	       1 allocs/op
+BenchmarkStringCMap/2048-8         	200000000	        38.3 ns/op	      16 B/op	       1 allocs/op
+BenchmarkStringCMap/4096-8         	200000000	        39.8 ns/op	      16 B/op	       1 allocs/op
+BenchmarkStringCMap/8192-8         	200000000	        41.3 ns/op	      16 B/op	       1 allocs/op
 
 # github.com/streamrail/concurrent-map
-BenchmarkStreamrail/2048-8         	100000000	        64.7 ns/op	      16 B/op	       1 allocs/op
-BenchmarkStreamrail/4096-8         	100000000	        62.1 ns/op	      16 B/op	       1 allocs/op
-BenchmarkStreamrail/8192-8         	100000000	        61.5 ns/op	      16 B/op	       1 allocs/op
+BenchmarkStreamrail/2048-8         	100000000	        51.6 ns/op	      16 B/op	       1 allocs/op
+BenchmarkStreamrail/4096-8         	100000000	        51.2 ns/op	      16 B/op	       1 allocs/op
+BenchmarkStreamrail/8192-8         	100000000	        50.6 ns/op	      16 B/op	       1 allocs/op
 
 PASS
 ok  	github.com/OneOfOne/cmap/stringcmap	36.413s

cmap.go

@@ -1,21 +1,14 @@
 package cmap
 
-import "context"
-
-type (
-
-	// KT is the KeyType of the map, used for generating specialized versions.
-	KT interface{}
-	// VT is the ValueType of the map.
-	VT interface{}
-
-	// KV is returned from the Iter channel.
-	KV struct {
-		Key   KT
-		Value VT
-	}
+import (
+	"context"
 )
 
+type KV struct {
+	Key   KT
+	Value VT
+}
+
 // DefaultShardCount is the default number of shards to use when New() or NewFromJSON() are called.
 // The default is 256.
 const DefaultShardCount = 1 << 8
@@ -27,7 +20,7 @@ type KeyHasher interface {
 
 // CMap is a concurrent safe sharded map to scale on multiple cores.
 type CMap struct {
-	shards []lmap
+	shards []*lmap
 	// HashFn allows using a custom hash function that's used to determain the key's shard.
 	// Defaults to DefaultKeyHasher
 	HashFn func(KT) uint32
@@ -49,36 +42,36 @@ func NewSize(shardCount int) *CMap {
 	}
 
 	cm := &CMap{
-		shards: make([]lmap, shardCount),
+		shards: make([]*lmap, shardCount),
 		mod:    uint32(shardCount) - 1,
 		HashFn: DefaultKeyHasher,
 	}
 
 	for i := range cm.shards {
-		cm.shards[i].m = make(map[KT]VT)
+		cm.shards[i] = newLmap(shardCount)
 	}
 
 	return cm
 }
 
-func (cm *CMap) shardForKey(key KT) *lmap {
+func (cm *CMap) shard(key KT) *lmap {
 	h := cm.HashFn(key)
-	return &cm.shards[h&cm.mod]
+	return cm.shards[h&cm.mod]
 }
 
 // Get is the equivalent of `val := map[key]`.
 func (cm *CMap) Get(key KT) (val VT) {
-	return cm.shardForKey(key).Get(key)
+	return cm.shard(key).Get(key)
 }
 
 // GetOK is the equivalent of `val, ok := map[key]`.
 func (cm *CMap) GetOK(key KT) (val VT, ok bool) {
-	return cm.shardForKey(key).GetOK(key)
+	return cm.shard(key).GetOK(key)
 }
 
 // Set is the equivalent of `map[key] = val`.
 func (cm *CMap) Set(key KT, val VT) {
-	cm.shardForKey(key).Set(key, val)
+	cm.shard(key).Set(key, val)
 }
 
 // SetIfNotExists will only assign val to key if it wasn't already set.
@@ -94,30 +87,30 @@ func (cm *CMap) SetIfNotExists(key KT, val VT) (set bool) {
 }
 
 // Has is the equivalent of `_, ok := map[key]`.
-func (cm *CMap) Has(key KT) bool { return cm.shardForKey(key).Has(key) }
+func (cm *CMap) Has(key KT) bool { return cm.shard(key).Has(key) }
 
 // Delete is the equivalent of `delete(map, key)`.
-func (cm *CMap) Delete(key KT) { cm.shardForKey(key).Delete(key) }
+func (cm *CMap) Delete(key KT) { cm.shard(key).Delete(key) }
 
 // DeleteAndGet is the equivalent of `oldVal := map[key]; delete(map, key)`.
-func (cm *CMap) DeleteAndGet(key KT) VT { return cm.shardForKey(key).DeleteAndGet(key) }
+func (cm *CMap) DeleteAndGet(key KT) VT { return cm.shard(key).DeleteAndGet(key) }
 
 // Update calls `fn` with the key's old value (or nil if it didn't exist) and assign the returned value to the key.
 // The shard containing the key will be locked, it is NOT safe to call other cmap funcs inside `fn`.
 func (cm *CMap) Update(key KT, fn func(oldval VT) (newval VT)) {
-	cm.shardForKey(key).Update(key, fn)
+	cm.shard(key).Update(key, fn)
 }
 
 // Swap is the equivalent of `oldVal, map[key] = map[key], newVal`.
 func (cm *CMap) Swap(key KT, val VT) VT {
-	return cm.shardForKey(key).Swap(key, val)
+	return cm.shard(key).Swap(key, val)
 }
 
 // Keys returns a slice of all the keys of the map.
 func (cm *CMap) Keys() []KT {
 	out := make([]KT, 0, cm.Len())
 	for i := range cm.shards {
-		sh := &cm.shards[i]
+		sh := cm.shards[i]
 		sh.l.RLock()
 		for k := range sh.m {
 			out = append(out, k)

lmap.go

@@ -4,82 +4,89 @@ import "sync"
 
 type lmap struct {
 	m map[KT]VT
-	l sync.RWMutex
+	l *sync.RWMutex
 }
 
-func (ms *lmap) Set(key KT, v VT) {
-	ms.l.Lock()
-	ms.m[key] = v
-	ms.l.Unlock()
+func newLmap(cap int) *lmap {
+	return &lmap{
+		m: make(map[KT]VT, cap),
+		l: new(sync.RWMutex),
+	}
+}
+
+func (lm lmap) Set(key KT, v VT) {
+	lm.l.Lock()
+	lm.m[key] = v
+	lm.l.Unlock()
 }
 
-func (ms *lmap) Update(key KT, fn func(oldVal VT) (newVal VT)) {
-	ms.l.Lock()
-	ms.m[key] = fn(ms.m[key])
-	ms.l.Unlock()
+func (lm lmap) Update(key KT, fn func(oldVal VT) (newVal VT)) {
+	lm.l.Lock()
+	lm.m[key] = fn(lm.m[key])
+	lm.l.Unlock()
 }
 
-func (ms *lmap) Swap(key KT, newV VT) (oldV VT) {
-	ms.l.Lock()
-	oldV = ms.m[key]
-	ms.m[key] = newV
-	ms.l.Unlock()
+func (lm lmap) Swap(key KT, newV VT) (oldV VT) {
+	lm.l.Lock()
+	oldV = lm.m[key]
+	lm.m[key] = newV
+	lm.l.Unlock()
 	return
 }
 
-func (ms *lmap) Get(key KT) (v VT) {
-	ms.l.RLock()
-	v = ms.m[key]
-	ms.l.RUnlock()
+func (lm lmap) Get(key KT) (v VT) {
+	lm.l.RLock()
+	v = lm.m[key]
+	lm.l.RUnlock()
 	return
 }
-func (ms *lmap) GetOK(key KT) (v VT, ok bool) {
-	ms.l.RLock()
-	v, ok = ms.m[key]
-	ms.l.RUnlock()
+func (lm lmap) GetOK(key KT) (v VT, ok bool) {
+	lm.l.RLock()
+	v, ok = lm.m[key]
+	lm.l.RUnlock()
 	return
 }
 
-func (ms *lmap) Has(key KT) (ok bool) {
-	ms.l.RLock()
-	_, ok = ms.m[key]
-	ms.l.RUnlock()
+func (lm lmap) Has(key KT) (ok bool) {
+	lm.l.RLock()
+	_, ok = lm.m[key]
+	lm.l.RUnlock()
 	return
 }
 
-func (ms *lmap) Delete(key KT) {
-	ms.l.Lock()
-	delete(ms.m, key)
-	ms.l.Unlock()
+func (lm lmap) Delete(key KT) {
+	lm.l.Lock()
+	delete(lm.m, key)
+	lm.l.Unlock()
 }
 
-func (ms *lmap) DeleteAndGet(key KT) (v VT) {
-	ms.l.Lock()
-	v = ms.m[key]
-	delete(ms.m, key)
-	ms.l.Unlock()
+func (lm lmap) DeleteAndGet(key KT) (v VT) {
+	lm.l.Lock()
+	v = lm.m[key]
+	delete(lm.m, key)
+	lm.l.Unlock()
 	return v
 }
 
-func (ms *lmap) Len() (ln int) {
-	ms.l.RLock()
-	ln = len(ms.m)
-	ms.l.RUnlock()
+func (lm lmap) Len() (ln int) {
+	lm.l.RLock()
+	ln = len(lm.m)
+	lm.l.RUnlock()
 	return
 }
 
-func (ms *lmap) ForEach(fn func(key KT, val VT) error) (err error) {
-	ms.l.RLock()
-	keys := make([]KT, 0, len(ms.m))
-	for key := range ms.m {
+func (lm lmap) ForEach(fn func(key KT, val VT) error) (err error) {
+	lm.l.RLock()
+	keys := make([]KT, 0, len(lm.m))
+	for key := range lm.m {
 		keys = append(keys, key)
 	}
-	ms.l.RUnlock()
+	lm.l.RUnlock()
 
 	for _, key := range keys {
-		ms.l.RLock()
-		val, ok := ms.m[key]
-		ms.l.RUnlock()
+		lm.l.RLock()
+		val, ok := lm.m[key]
+		lm.l.RUnlock()
 		if !ok {
 			continue
 		}
@@ -91,11 +98,11 @@ func (ms *lmap) ForEach(fn func(key KT, val VT) error) (err error) {
 	return
 }
 
-func (ms *lmap) ForEachLocked(fn func(key KT, val VT) error) (err error) {
-	ms.l.RLock()
-	defer ms.l.RUnlock()
+func (lm lmap) ForEachLocked(fn func(key KT, val VT) error) (err error) {
+	lm.l.RLock()
+	defer lm.l.RUnlock()
 
-	for key, val := range ms.m {
+	for key, val := range lm.m {
 		if err = fn(key, val); err != nil {
 			return
 		}

stringcmap/cmap.go

@@ -19,7 +19,7 @@ const DefaultShardCount = cmap.DefaultShardCount
 
 // CMap is a concurrent safe sharded map to scale on multiple cores.
 type CMap struct {
-	shards []lmap
+	shards []*lmap
 	mod    uint32
 }
 
@@ -38,20 +38,20 @@ func NewSize(shardCount int) *CMap {
 	}
 
 	cm := &CMap{
-		shards: make([]lmap, shardCount),
+		shards: make([]*lmap, shardCount),
 		mod:    uint32(shardCount) - 1,
 	}
 
 	for i := range cm.shards {
-		cm.shards[i].m = make(map[string]interface{})
+		cm.shards[i] = newLmap(shardCount)
 	}
 
 	return cm
 }
 
 func (cm *CMap) shardForKey(key string) *lmap {
 	h := cmap.Fnv32(key)
-	return &cm.shards[h&cm.mod]
+	return cm.shards[h&cm.mod]
 }
 
 // Get is the equivalent of `val := map[key]`.
@@ -105,7 +105,7 @@ func (cm *CMap) Swap(key string, val interface{}) interface{} {
 func (cm *CMap) Keys() []string {
 	out := make([]string, 0, cm.Len())
 	for i := range cm.shards {
-		sh := &cm.shards[i]
+		sh := cm.shards[i]
 		sh.l.RLock()
 		for k := range sh.m {
 			out = append(out, k)