Function BenchmarkCaches

cachebench/cache_bench_test.go:360–421

(b *testing.B)

}

func BenchmarkCaches(b *testing.B) {
	zipfList := zipfKeyList()
	oneList := oneKeyList()

	// two datasets (zipf, onekey)
	// 3 caches (bigcache, freecache, sync.Map)
	// 3 types of benchmark (read, write, mixed)
	benchmarks := []struct {
		name      string
		cache     Cache
		keys      [][]byte
		pctWrites uint64
	}{
		{"BigCacheZipfRead", newBigCache(b.N), zipfList, 0},
		{"FastCacheZipfRead", newFastCache(b.N), zipfList, 0},
		{"FreeCacheZipfRead", newFreeCache(b.N), zipfList, 0},
		{"GroupCacheZipfRead", newGroupCache(b.N), zipfList, 0},
		{"RistrettoZipfRead", newRistretto(b.N), zipfList, 0},
		{"SyncMapZipfRead", newSyncMap(), zipfList, 0},

		{"BigCacheOneKeyRead", newBigCache(b.N), oneList, 0},
		{"FastCacheOneKeyRead", newFastCache(b.N), oneList, 0},
		{"FreeCacheOneKeyRead", newFreeCache(b.N), oneList, 0},
		{"GroupCacheOneKeyRead", newGroupCache(b.N), oneList, 0},
		{"RistrettoOneKeyRead", newRistretto(b.N), oneList, 0},
		{"SyncMapOneKeyRead", newSyncMap(), oneList, 0},

		{"BigCacheZipfWrite", newBigCache(b.N), zipfList, 100},
		{"FastCacheZipfWrite", newFastCache(b.N), zipfList, 100},
		{"FreeCacheZipfWrite", newFreeCache(b.N), zipfList, 100},
		{"GroupCacheZipfWrite", newGroupCache(b.N), zipfList, 100},
		{"RistrettoZipfWrite", newRistretto(b.N), zipfList, 100},
		{"SyncMapZipfWrite", newSyncMap(), zipfList, 100},

		{"BigCacheOneKeyWrite", newBigCache(b.N), oneList, 100},
		{"FastCacheOneKeyWrite", newFastCache(b.N), oneList, 100},
		{"FreeCacheOneKeyWrite", newFreeCache(b.N), oneList, 100},
		{"GroupCacheOneKeyWrite", newGroupCache(b.N), oneList, 100},
		{"RistrettoOneKeyWrite", newRistretto(b.N), oneList, 100},
		{"SyncMapOneKeyWrite", newSyncMap(), oneList, 100},

		{"BigCacheZipfMixed", newBigCache(b.N), zipfList, 25},
		{"FastCacheZipfMixed", newFastCache(b.N), zipfList, 25},
		{"FreeCacheZipfMixed", newFreeCache(b.N), zipfList, 25},
		{"GroupCacheZipfMixed", newGroupCache(b.N), zipfList, 25},
		{"RistrettoZipfMixed", newRistretto(b.N), zipfList, 25},
		{"SyncMapZipfMixed", newSyncMap(), zipfList, 25},

		{"BigCacheOneKeyMixed", newBigCache(b.N), oneList, 25},
		{"FastCacheOneKeyMixed", newFastCache(b.N), oneList, 25},
		{"FreeCacheOneKeyMixed", newFreeCache(b.N), oneList, 25},
		{"GroupCacheOneKeyMixed", newGroupCache(b.N), oneList, 25},
		{"RistrettoOneKeyMixed", newRistretto(b.N), oneList, 25},
		{"SyncMapOneKeyMixed", newSyncMap(), oneList, 25},
	}

	for _, bm := range benchmarks {
		b.Run(bm.name, func(b *testing.B) {