README

Author: Thomas Stromberg

Makefile

@@ -8,12 +8,12 @@ tag:
 		exit 1; \
 	fi
 	@echo "Tagging all modules with $(VERSION)..."
-	@git tag $(VERSION)
+	@git tag -a $(VERSION) -m "$(VERSION)"
 	@find . -name go.mod -not -path "./go.mod" | while read mod; do \
 		dir=$$(dirname $$mod); \
 		dir=$${dir#./}; \
 		echo "  $$dir/$(VERSION)"; \
-		git tag $$dir/$(VERSION); \
+		git tag -a $$dir/$(VERSION) -m "$(VERSION)"; \
 	done
 	@echo ""
 	@echo "Created tags:"

README.md

@@ -65,86 +65,94 @@ cache, _ := sfcache.NewTiered[string, User](p)
 
 ## Performance against the Competition
 
-sfcache prioritizes high hit-rates and low read latency, but it performs quite well all around.
-
-Here's the results from an M4 MacBook Pro - run `make bench` to see the results for yourself:
+sfcache prioritizes high hit-rates and low read latency, but it's excellent all around. Run `make bench` to see the results for yourself:
 
 ```
->>> TestLatency: Single-Threaded Latency (go test -run=TestLatency -v)
+>>> TestLatencyNoEviction: Latency - No Evictions (Set cycles within cache size) (go test -run=TestLatencyNoEviction -v)
+| Cache         | Get ns/op | Get B/op | Get allocs | Set ns/op | Set B/op | Set allocs |
+|---------------|-----------|----------|------------|-----------|----------|------------|
+| sfcache       |       7.0 |        0 |          0 |      21.0 |        0 |          0 |
+| lru           |      21.0 |        0 |          0 |      21.0 |        0 |          0 |
+| ristretto     |      32.0 |       14 |          0 |      76.0 |      121 |          4 |
+| otter         |      34.0 |        0 |          0 |     137.0 |       51 |          1 |
+| freecache     |      57.0 |        8 |          1 |      48.0 |        0 |          0 |
+| tinylfu       |      71.0 |        0 |          0 |     108.0 |      168 |          3 |
 
-### Single-Threaded Latency (sorted by Get)
+- 🔥 Get: 200% better than next best (lru)
+- 🔥 Set: 0.000% better than next best (lru)
 
+>>> TestLatencyWithEviction: Latency - With Evictions (Set uses 20x unique keys) (go test -run=TestLatencyWithEviction -v)
 | Cache         | Get ns/op | Get B/op | Get allocs | Set ns/op | Set B/op | Set allocs |
 |---------------|-----------|----------|------------|-----------|----------|------------|
-| sfcache       |       8.0 |        0 |          0 |      21.0 |        0 |          0 |
-| lru           |      23.0 |        0 |          0 |      22.0 |        0 |          0 |
-| ristretto     |      32.0 |       14 |          0 |      65.0 |      118 |          3 |
-| otter         |      35.0 |        0 |          0 |     131.0 |       48 |          1 |
-| freecache     |      62.0 |        8 |          1 |      49.0 |        0 |          0 |
-| tinylfu       |      75.0 |        0 |          0 |      97.0 |      168 |          3 |
+| sfcache       |       8.0 |        0 |          0 |      79.0 |        0 |          0 |
+| lru           |      21.0 |        0 |          0 |      80.0 |       80 |          1 |
+| ristretto     |      30.0 |       13 |          0 |      74.0 |      119 |          3 |
+| otter         |      34.0 |        0 |          0 |     175.0 |       60 |          1 |
+| freecache     |      58.0 |        8 |          1 |      94.0 |        1 |          0 |
+| tinylfu       |      73.0 |        0 |          0 |     108.0 |      168 |          3 |
 
-- 🔥 Get: 188% better than next best (lru)
-- 🔥 Set: 4.8% better than next best (lru)
+- 🔥 Get: 162% better than next best (lru)
+- 💧 Set: 6.8% worse than best (ristretto)
 
 >>> TestZipfThroughput1: Zipf Throughput (1 thread) (go test -run=TestZipfThroughput1 -v)
 
 ### Zipf Throughput (alpha=0.99, 75% read / 25% write): 1 threads
 
 | Cache         | QPS        |
 |---------------|------------|
-| sfcache       |   96.94M   |
-| lru           |   46.24M   |
-| tinylfu       |   19.21M   |
-| freecache     |   15.02M   |
-| otter         |   12.95M   |
-| ristretto     |   11.34M   |
+| sfcache       |   98.80M   |
+| lru           |   47.40M   |
+| tinylfu       |   20.10M   |
+| freecache     |   15.59M   |
+| otter         |   13.37M   |
+| ristretto     |   11.41M   |
 
-- 🔥 Throughput: 110% faster than next best (lru)
+- 🔥 Throughput: 108% faster than next best (lru)
 
 >>> TestZipfThroughput16: Zipf Throughput (16 threads) (go test -run=TestZipfThroughput16 -v)
 
 ### Zipf Throughput (alpha=0.99, 75% read / 25% write): 16 threads
 
 | Cache         | QPS        |
 |---------------|------------|
-| sfcache       |   43.27M   |
+| sfcache       |   42.18M   |
 | freecache     |   15.08M   |
-| ristretto     |   14.20M   |
-| otter         |   10.85M   |
-| lru           |    5.64M   |
-| tinylfu       |    4.25M   |
+| ristretto     |   14.10M   |
+| otter         |   10.70M   |
+| lru           |    6.03M   |
+| tinylfu       |    4.21M   |
 
-- 🔥 Throughput: 187% faster than next best (freecache)
+- 🔥 Throughput: 180% faster than next best (freecache)
 
 >>> TestMetaTrace: Meta Trace Hit Rate (10M ops) (go test -run=TestMetaTrace -v)
 
 ### Meta Trace Hit Rate (10M ops from Meta KVCache)
 
 | Cache         | 50K cache | 100K cache |
 |---------------|-----------|------------|
-| sfcache       |   68.19%  |   76.03%   |
-| otter         |   41.31%  |   55.41%   |
-| ristretto     |   40.33%  |   48.91%   |
+| sfcache       |   68.53%  |   76.34%   |
+| otter         |   41.37%  |   56.14%   |
+| ristretto     |   40.35%  |   48.95%   |
 | tinylfu       |   53.70%  |   54.79%   |
 | freecache     |   56.86%  |   65.52%   |
 | lru           |   65.21%  |   74.22%   |
 
-- 🔥 Meta trace: 2.4% better than next best (lru)
+- 🔥 Meta trace: 2.9% better than next best (lru)
 
 >>> TestHitRate: Zipf Hit Rate (go test -run=TestHitRate -v)
 
 ### Hit Rate (Zipf alpha=0.99, 1M ops, 1M keyspace)
 
 | Cache         | Size=1% | Size=2.5% | Size=5% |
 |---------------|---------|-----------|---------|
-| sfcache       |  64.19% |    69.23% |  72.50% |
-| otter         |  61.64% |    67.94% |  71.38% |
-| ristretto     |  34.88% |    41.25% |  46.62% |
+| sfcache       |  64.41% |    69.24% |  72.57% |
+| otter         |  62.28% |    67.81% |  71.42% |
+| ristretto     |  34.87% |    41.25% |  46.49% |
 | tinylfu       |  63.83% |    68.25% |  71.56% |
 | freecache     |  56.65% |    57.75% |  63.39% |
 | lru           |  57.33% |    64.55% |  69.92% |
 
-- 🔥 Hit rate: 1.1% better than next best (tinylfu)
+- 🔥 Hit rate: 1.3% better than next best (tinylfu)
 ```
 
 Cache performance is a game of balancing trade-offs. There will be workloads where other cache implementations are better, but nobody blends speed and persistence like we do.