Implement cache items visitor.

Author: andreiavrammsd

README.md

@@ -46,8 +46,7 @@ BenchmarkSyncMapGet-4       	    5000	   2316508 ns/op	  28.29 MB/s	    2543 B/o
 BenchmarkSyncMapSetGet-4    	    2000	  10444529 ns/op	  12.55 MB/s	 3412527 B/op	  262210 allocs/op
 BenchmarkSaveToFile-4       	      50	 259800249 ns/op	 129.15 MB/s	55739129 B/op	    3091 allocs/op
 BenchmarkLoadFromFile-4     	     100	 121189395 ns/op	 276.88 MB/s	98089036 B/op	    8748 allocs/op
-BenchmarkCache_Keys-8   	      100000	     18359 ns/op	  16.34 MB/s	   39072 B/op	      30 allocs/op
-
+BenchmarkCache_VisitAllEntries-4   50000        245913 ns/op      40.66 MB/s         170 B/op          2 allocs/op
 ```
 
 `MB/s` column here actually means `millions of operations per second`.

fastcache.go

@@ -2,7 +2,6 @@ package fastcache
 
 import (
 	"fmt"
-	"regexp"
 	"sync"
 	"sync/atomic"
 
@@ -122,24 +121,38 @@ func (c *Cache) UpdateStats(s *Stats) {
 	}
 }
 
-// Keys retrieves all cached keys matching regex pattern
-func (c *Cache) Keys(pattern string) (keys [][]byte, err error) {
-	r, err := regexp.Compile(pattern)
-	if err != nil {
-		return
-	}
-
+// VisitAllEntries calls f for all the cache entries.
+//
+// The function returns immediately if f returns non-nil error.
+// It returns the given error.
+//
+// f cannot hold pointers to k and v contents after returning.
+func (c *Cache) VisitAllEntries(f func(k, v []byte) error) error {
 	for _, b := range c.buckets {
-		for _, chunk := range b.chunks {
-			if len(chunk) > 0 {
-				if key := chunk[4 : 4+chunk[1]]; r.Match(key) {
-					keys = append(keys, key)
-				}
+		b.mu.RLock()
+		for _, idx := range b.m {
+			idx &= (1 << bucketSizeBits) - 1
+			chunkIdx := idx / chunkSize
+			chunk := b.chunks[chunkIdx]
+
+			kvLenBuf := chunk[idx : idx+4]
+			keyLen := (uint64(kvLenBuf[0]) << 8) | uint64(kvLenBuf[1])
+			valLen := (uint64(kvLenBuf[2]) << 8) | uint64(kvLenBuf[3])
+
+			idx += 4
+			key := chunk[idx : idx+keyLen]
+
+			idx += keyLen
+			value := chunk[idx : idx+valLen]
+
+			if err := f(key, value); err != nil {
+				return err
 			}
 		}
+		b.mu.RUnlock()
 	}
 
-	return
+	return nil
 }
 
 type bucket struct {

fastcache_test.go

@@ -166,73 +166,26 @@ func TestCacheGetSetConcurrent(t *testing.T) {
 	}
 }
 
-func TestCacheKeys(t *testing.T) {
-	keys := []string{
-		"username",
-		"firstname",
-		"lastname",
-	}
-
-	c := New(100 * len(keys))
+func TestCacheVisitAllEntries(t *testing.T) {
+	itemsCount := 10000
+	c := New(30 * itemsCount)
 	defer c.Reset()
 
-	for _, k := range keys {
-		c.Set([]byte(k), nil)
-	}
+	data := make(map[string][]byte)
 
-	tests := []struct {
-		Pattern  string
-		Expected []string
-	}{
-		{
-			Pattern:  "",
-			Expected: keys,
-		},
-		{
-			Pattern:  "name$",
-			Expected: keys,
-		},
-		{
-			Pattern: "st",
-			Expected: []string{
-				"firstname",
-				"lastname",
-			},
-		},
-		{
-			Pattern:  " ",
-			Expected: nil,
-		},
+	for i := 0; i < itemsCount; i++ {
+		k := []byte(fmt.Sprintf("key %d", i))
+		v := []byte(fmt.Sprintf("value %d", i))
+		c.Set(k, v)
+		data[string(k)] = v
 	}
 
-	for _, tt := range tests {
-		result, err := c.Keys(tt.Pattern)
-		if err != nil {
-			t.Fatal(err)
+	_ = c.VisitAllEntries(func(k, v []byte) error {
+		if string(data[string(k)]) != string(v) {
+			t.Fatal("error fetching (k, v) pair")
 		}
-
-		count := 0
-		for _, r := range result {
-			for _, e := range tt.Expected {
-				if string(r) == e {
-					count++
-					break
-				}
-			}
-		}
-
-		if count != len(tt.Expected) {
-			t.Fatalf("failed to retrievs keys by pattern: \"%s\"", tt.Pattern)
-		}
-	}
-
-	result, err := c.Keys("*")
-	if result != nil {
-		t.Fatal("expected no matches")
-	}
-	if err == nil {
-		t.Fatal("expected regex error")
-	}
+		return nil
+	})
 }
 
 func testCacheGetSet(c *Cache, itemsCount int) error {

fastcache_timing_test.go

@@ -388,35 +388,26 @@ func BenchmarkSyncMapSetGet(b *testing.B) {
 	})
 }
 
-func BenchmarkCache_Keys(b *testing.B) {
-	keys := []string{
-		"username",
-		"firstname",
-		"lastname",
-	}
-	pattern := "name$"
-
-	items := 100 * len(keys)
-
-	c := New(items)
+func BenchmarkCache_VisitAllEntries(b *testing.B) {
+	itemsCount := 10000
+	c := New(30 * itemsCount)
 	defer c.Reset()
 
 	b.ReportAllocs()
-	b.SetBytes(int64(items))
+	b.SetBytes(int64(itemsCount))
 
-	for _, k := range keys {
-		c.Set([]byte(k), nil)
+	data := make(map[string][]byte)
+
+	for i := 0; i < itemsCount; i++ {
+		k := []byte(fmt.Sprintf("key %d", i))
+		v := []byte(fmt.Sprintf("value %d", i))
+		c.Set(k, v)
+		data[string(k)] = v
 	}
 
 	for n := 0; n < b.N; n++ {
-		keys, err := c.Keys(pattern)
-
-		if err != nil {
-			panic(fmt.Errorf("BUG: error for valid pattern \"%s\" (%s)", pattern, err))
-		}
-
-		if len(keys) == 0 {
-			panic(fmt.Errorf("BUG: no key for valid pattern \"%s\"", pattern))
-		}
+		_ = c.VisitAllEntries(func(k, v []byte) error {
+			return nil
+		})
 	}
 }