minor optimizations

Author: OneOfOne

cmap.go

@@ -61,58 +61,56 @@ func NewSize(shardCount int) *CMap {
 	return cm
 }
 
-func (cm *CMap) shard(key KT) *lmap {
+func (cm *CMap) shardForKey(key KT) *lmap {
 	h := cm.HashFn(key)
 	return &cm.shards[h&cm.mod]
 }
 
 // Get is the equivalent of `val := map[key]`.
 func (cm *CMap) Get(key KT) (val VT) {
-	return cm.shard(key).Get(key)
+	return cm.shardForKey(key).Get(key)
 }
 
 // GetOK is the equivalent of `val, ok := map[key]`.
 func (cm *CMap) GetOK(key KT) (val VT, ok bool) {
-	return cm.shard(key).GetOK(key)
+	return cm.shardForKey(key).GetOK(key)
 }
 
 // Set is the equivalent of `map[key] = val`.
 func (cm *CMap) Set(key KT, val VT) {
-	cm.shard(key).Set(key, val)
+	cm.shardForKey(key).Set(key, val)
 }
 
 // SetIfNotExists will only assign val to key if it wasn't already set.
 // Use `CMap.Update` if you need more logic.
 func (cm *CMap) SetIfNotExists(key KT, val VT) (set bool) {
 	cm.Update(key, func(oldVal VT) (newVal VT) {
-		switch oldVal.(type) {
-		case nil:
+		if set = oldVal == nil; set {
 			return newVal
-		default:
-			return oldVal
 		}
+		return oldVal
 	})
 	return
 }
 
 // Has is the equivalent of `_, ok := map[key]`.
-func (cm *CMap) Has(key KT) bool { return cm.shard(key).Has(key) }
+func (cm *CMap) Has(key KT) bool { return cm.shardForKey(key).Has(key) }
 
 // Delete is the equivalent of `delete(map, key)`.
-func (cm *CMap) Delete(key KT) { cm.shard(key).Delete(key) }
+func (cm *CMap) Delete(key KT) { cm.shardForKey(key).Delete(key) }
 
 // DeleteAndGet is the equivalent of `oldVal := map[key]; delete(map, key)`.
-func (cm *CMap) DeleteAndGet(key KT) VT { return cm.shard(key).DeleteAndGet(key) }
+func (cm *CMap) DeleteAndGet(key KT) VT { return cm.shardForKey(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.shard(key).Update(key, fn)
+	cm.shardForKey(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.shard(key).Swap(key, val)
+	return cm.shardForKey(key).Swap(key, val)
 }
 
 // Keys returns a slice of all the keys of the map.
@@ -192,12 +190,10 @@ func (cm *CMap) iterContext(ctx context.Context, ch chan<- *KV, locked bool) {
 			return nil
 		}
 	}
-	for i := range cm.shards {
-		if locked {
-			cm.shards[i].ForEachLocked(fn)
-		} else {
-			cm.shards[i].ForEach(fn)
-		}
+	if locked {
+		cm.ForEachLocked(fn)
+	} else {
+		cm.ForEach(fn)
 	}
 }
 

stringcmap/cmap.go

@@ -6,6 +6,13 @@ import (
 	"github.com/OneOfOne/cmap"
 )
 
+type (
+	KV struct {
+		Key   string
+		Value interface{}
+	}
+)
+
 // DefaultShardCount is the default number of shards to use when New() or NewFromJSON() are called.
 // The default is 256.
 const DefaultShardCount = cmap.DefaultShardCount
@@ -42,58 +49,56 @@ func NewSize(shardCount int) *CMap {
 	return cm
 }
 
-func (cm *CMap) shard(key string) *lmap {
+func (cm *CMap) shardForKey(key string) *lmap {
 	h := cmap.Fnv32(key)
 	return &cm.shards[h&cm.mod]
 }
 
 // Get is the equivalent of `val := map[key]`.
 func (cm *CMap) Get(key string) (val interface{}) {
-	return cm.shard(key).Get(key)
+	return cm.shardForKey(key).Get(key)
 }
 
 // GetOK is the equivalent of `val, ok := map[key]`.
 func (cm *CMap) GetOK(key string) (val interface{}, ok bool) {
-	return cm.shard(key).GetOK(key)
+	return cm.shardForKey(key).GetOK(key)
 }
 
 // Set is the equivalent of `map[key] = val`.
 func (cm *CMap) Set(key string, val interface{}) {
-	cm.shard(key).Set(key, val)
+	cm.shardForKey(key).Set(key, val)
 }
 
 // SetIfNotExists will only assign val to key if it wasn't already set.
 // Use `CMap.Update` if you need more logic.
 func (cm *CMap) SetIfNotExists(key string, val interface{}) (set bool) {
 	cm.Update(key, func(oldVal interface{}) (newVal interface{}) {
-		switch oldVal.(type) {
-		case nil:
+		if set = oldVal == nil; set {
 			return newVal
-		default:
-			return oldVal
 		}
+		return oldVal
 	})
 	return
 }
 
 // Has is the equivalent of `_, ok := map[key]`.
-func (cm *CMap) Has(key string) bool { return cm.shard(key).Has(key) }
+func (cm *CMap) Has(key string) bool { return cm.shardForKey(key).Has(key) }
 
 // Delete is the equivalent of `delete(map, key)`.
-func (cm *CMap) Delete(key string) { cm.shard(key).Delete(key) }
+func (cm *CMap) Delete(key string) { cm.shardForKey(key).Delete(key) }
 
 // DeleteAndGet is the equivalent of `oldVal := map[key]; delete(map, key)`.
-func (cm *CMap) DeleteAndGet(key string) interface{} { return cm.shard(key).DeleteAndGet(key) }
+func (cm *CMap) DeleteAndGet(key string) interface{} { return cm.shardForKey(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 string, fn func(oldval interface{}) (newval interface{})) {
-	cm.shard(key).Update(key, fn)
+	cm.shardForKey(key).Update(key, fn)
 }
 
 // Swap is the equivalent of `oldVal, map[key] = map[key], newVal`.
 func (cm *CMap) Swap(key string, val interface{}) interface{} {
-	return cm.shard(key).Swap(key, val)
+	return cm.shardForKey(key).Swap(key, val)
 }
 
 // Keys returns a slice of all the keys of the map.
@@ -112,12 +117,12 @@ func (cm *CMap) Keys() []string {
 
 // ForEach loops over all the key/values in all the shards in order.
 // You can break early by returning an error.
-// it is safe to change the map inside fn.
+// It **is** safe to modify the map while using this iterator, however it uses more memory and is slightly slower.
 func (cm *CMap) ForEach(fn func(key string, val interface{}) error) error {
 	for i := range cm.shards {
 		if err := cm.shards[i].ForEach(fn); err != nil {
 			if err == cmap.Break {
-				err = nil
+				return nil
 			}
 			return err
 		}
@@ -127,10 +132,10 @@ func (cm *CMap) ForEach(fn func(key string, val interface{}) error) error {
 
 // ForEachLocked loops over all the key/values in the map.
 // You can break early by returning an error.
-// It is **NOT** safe to change the map during this call.
+// It is **NOT* safe to modify the map while using this iterator.
 func (cm *CMap) ForEachLocked(fn func(key string, val interface{}) error) error {
 	for i := range cm.shards {
-		if err := cm.shards[i].ForEach(fn); err != nil {
+		if err := cm.shards[i].ForEachLocked(fn); err != nil {
 			if err == cmap.Break {
 				return nil
 			}
@@ -140,34 +145,43 @@ func (cm *CMap) ForEachLocked(fn func(key string, val interface{}) error) error
 	return nil
 }
 
-// KV is returned from the Iter channel.
-type KV struct {
-	Key   string
-	Value interface{}
-}
-
 // Iter returns a channel to be used in for range.
-// **Warning** breaking early will leak up to cm.NumShards() goroutines, use IterWithCancel if you intend to break early.
-// It is safe to modify the map while using this iterator.
+// Use `context.WithCancel` if you intend to break early or goroutines will leak.
+// It **is** safe to modify the map while using this iterator, however it uses more memory and is slightly slower.
 func (cm *CMap) Iter(ctx context.Context, buffer int) <-chan *KV {
 	ch := make(chan *KV, buffer)
 	go func() {
-		cm.iterContext(ctx, ch)
+		cm.iterContext(ctx, ch, false)
 		close(ch)
 	}()
 	return ch
 }
 
-func (cm *CMap) iterContext(ctx context.Context, ch chan<- *KV) {
-	for i := range cm.shards {
-		cm.shards[i].ForEach(func(k string, v interface{}) error {
-			select {
-			case <-ctx.Done():
-				return cmap.Break
-			case ch <- &KV{k, v}:
-				return nil
-			}
-		})
+// IterLocked returns a channel to be used in for range.
+// Use `context.WithCancel` if you intend to break early or goroutines will leak and map access will deadlock.
+// It is **NOT* safe to modify the map while using this iterator.
+func (cm *CMap) IterLocked(ctx context.Context, buffer int) <-chan *KV {
+	ch := make(chan *KV, buffer)
+	go func() {
+		cm.iterContext(ctx, ch, false)
+		close(ch)
+	}()
+	return ch
+}
+
+func (cm *CMap) iterContext(ctx context.Context, ch chan<- *KV, locked bool) {
+	fn := func(k string, v interface{}) error {
+		select {
+		case <-ctx.Done():
+			return cmap.Break
+		case ch <- &KV{k, v}:
+			return nil
+		}
+	}
+	if locked {
+		cm.ForEachLocked(fn)
+	} else {
+		cm.ForEach(fn)
 	}
 }
 

utils.go

@@ -49,13 +49,22 @@ func DefaultKeyHasher(key KT) uint32 {
 	}
 }
 
+const prime32 = uint32(16777619)
+
 // Fnv32 the default hash func we use for strings.
 func Fnv32(key string) uint32 {
-	const prime32 = uint32(16777619)
 	hash := uint32(2166136261)
-	for i := 0; i < len(key); i++ {
+
+	// workaround not being able to inline for loops
+	// watching https://github.com/golang/go/issues/21490
+	if len(key) > 0 {
+		i := 0
+	L:
 		hash *= prime32
 		hash ^= uint32(key[i])
+		if i++; i < len(key) {
+			goto L
+		}
 	}
 	return hash
 }