Make GC comparisons more realistic

caches_gc_overhead_comparison.go

@@ -41,7 +41,7 @@ func main() {
 	fmt.Println("Number of repeats: ", repeat)
 	fmt.Println("Value size:        ", valueSize)
 
-	var benchFunc func(entries, valueSize int)
+	var benchFunc func(kv *keyValueStore)
 
 	switch c {
 	case "freecache":
@@ -55,74 +55,98 @@ func main() {
 		os.Exit(1)
 	}
 
-	benchFunc(entries, valueSize)
+	kv := newKeyValueStore(entries, valueSize)
+
+	benchFunc(kv)
 	fmt.Println("GC pause for startup: ", gcPause())
 	for i := 0; i < repeat; i++ {
-		benchFunc(entries, valueSize)
+		benchFunc(kv)
 	}
 
 	fmt.Printf("GC pause for %s: %s\n", c, gcPause())
 }
 
-func stdMap(entries, valueSize int) {
+func stdMap(kv *keyValueStore) {
 	mapCache := make(map[string][]byte)
-	for i := 0; i < entries; i++ {
-		key, val := generateKeyValue(i, valueSize)
-		mapCache[key] = val
+	for i := 0; i < kv.Size(); i++ {
+		mapCache[kv.Key(i)] = kv.Value(i)
 	}
 }
 
-func freeCache(entries, valueSize int) {
-	freeCache := freecache.NewCache(entries * 200) //allocate entries * 200 bytes
-	for i := 0; i < entries; i++ {
-		key, val := generateKeyValue(i, valueSize)
-		if err := freeCache.Set([]byte(key), val, 0); err != nil {
+func freeCache(kv *keyValueStore) {
+	freeCache := freecache.NewCache(kv.Size() * 200) //allocate entries * 200 bytes
+	for i := 0; i < kv.Size(); i++ {
+		if err := freeCache.Set([]byte(kv.Key(i)), kv.Value(i), 0); err != nil {
 			fmt.Println("Error in set: ", err.Error())
 		}
 	}
 
-	firstKey, _ := generateKeyValue(1, valueSize)
-	v, err := freeCache.Get([]byte(firstKey))
-	checkFirstElement(valueSize, v, err)
+	v, err := freeCache.Get([]byte(kv.Key(1)))
+	checkFirstElement(kv.Value(1), v, err)
 
 	if freeCache.OverwriteCount() != 0 {
 		fmt.Println("Overwritten: ", freeCache.OverwriteCount())
 	}
 }
 
-func bigCache(entries, valueSize int) {
+func bigCache(kv *keyValueStore) {
 	config := bigcache.Config{
 		Shards:             256,
 		LifeWindow:         100 * time.Minute,
-		MaxEntriesInWindow: entries,
+		MaxEntriesInWindow: kv.Size(),
 		MaxEntrySize:       200,
 		Verbose:            true,
 	}
 
 	bigcache, _ := bigcache.NewBigCache(config)
-	for i := 0; i < entries; i++ {
-		key, val := generateKeyValue(i, valueSize)
-		bigcache.Set(key, val)
+	for i := 0; i < kv.Size(); i++ {
+		bigcache.Set(kv.Key(i), kv.Value(i))
 	}
 
-	firstKey, _ := generateKeyValue(1, valueSize)
-	v, err := bigcache.Get(firstKey)
-	checkFirstElement(valueSize, v, err)
+	v, err := bigcache.Get(kv.Key(1))
+	checkFirstElement(kv.Value(1), v, err)
 }
 
-func checkFirstElement(valueSize int, val []byte, err error) {
-	_, expectedVal := generateKeyValue(1, valueSize)
+func checkFirstElement(expectedVal []byte, val []byte, err error) {
 	if err != nil {
 		fmt.Println("Error in get: ", err.Error())
 	} else if string(val) != string(expectedVal) {
 		fmt.Println("Wrong first element: ", string(val))
 	}
 }
 
-func generateKeyValue(index int, valSize int) (string, []byte) {
-	key := fmt.Sprintf("key-%010d", index)
-	fixedNumber := []byte(fmt.Sprintf("%010d", index))
-	val := append(make([]byte, valSize-10), fixedNumber...)
+type keyValueStore struct {
+	valueSize int
+	keys      []string
+	values    []byte
+}
+
+func newKeyValueStore(entries int, valueSize int) *keyValueStore {
+	keys := make([]string, entries)
+	values := make([]byte, entries*valueSize)
+
+	for i := 0; i < entries; i++ {
+		keys[i] = fmt.Sprintf("key-%010d", i)
+		// Reuse the underlying data of key to generate the value without allocating more memory.
+		value := (([]byte)(keys[i]))[4:]
+		copy(values[(i+1)*valueSize-len(value):], value)
+	}
+
+	return &keyValueStore{
+		valueSize: valueSize,
+		keys:      keys,
+		values:    values,
+	}
+}
+
+func (store *keyValueStore) Size() int {
+	return len(store.keys)
+}
+
+func (store *keyValueStore) Key(index int) string {
+	return store.keys[index]
+}
 
-	return key, val
+func (store *keyValueStore) Value(index int) []byte {
+	return store.values[index*store.valueSize : (index+1)*store.valueSize]
 }