GOMAXPROCS=4 go test github.com/VictoriaMetrics/fastcache -bench='Set|Get' -benchtime=10s
goos: linux
goarch: amd64
pkg: github.com/VictoriaMetrics/fastcache
BenchmarkBigCacheSet-4      	    2000	  10566656 ns/op	   6.20 MB/s	 4660369 B/op	       6 allocs/op
BenchmarkBigCacheGet-4      	    2000	   6902694 ns/op	   9.49 MB/s	  684169 B/op	  131076 allocs/op
BenchmarkBigCacheSetGet-4   	    1000	  17579118 ns/op	   7.46 MB/s	 5046744 B/op	  131083 allocs/op
BenchmarkCacheSet-4         	    5000	   3808874 ns/op	  17.21 MB/s	    1142 B/op	       2 allocs/op
BenchmarkCacheGet-4         	    5000	   3293849 ns/op	  19.90 MB/s	    1140 B/op	       2 allocs/op
BenchmarkCacheSetGet-4      	    2000	   8456061 ns/op	  15.50 MB/s	    2857 B/op	       5 allocs/op
BenchmarkStdMapSet-4        	    2000	  10559382 ns/op	   6.21 MB/s	  268413 B/op	   65537 allocs/op
BenchmarkStdMapGet-4        	    5000	   2687404 ns/op	  24.39 MB/s	    2558 B/op	      13 allocs/op
BenchmarkStdMapSetGet-4     	     100	 154641257 ns/op	   0.85 MB/s	  387405 B/op	   65558 allocs/op
BenchmarkSyncMapSet-4       	     500	  24703219 ns/op	   2.65 MB/s	 3426543 B/op	  262411 allocs/op
BenchmarkSyncMapGet-4       	    5000	   2265892 ns/op	  28.92 MB/s	    2545 B/op	      79 allocs/op
BenchmarkSyncMapSetGet-4    	    1000	  14595535 ns/op	   8.98 MB/s	 3417190 B/op	  262277 allocs/op

package main

import (
	"fmt"

	"github.com/VictoriaMetrics/fastcache"
)

func main() {
	// 初始化一个大小为 32MB 的缓存
	cache := fastcache.New(32 * 1024 * 1024)

	key := []byte(`hello`)
	val := []byte(`world`)

	cache.Set(key, val)                      // 设置 K-V
	fmt.Println(cache.Has(key))              // true
	fmt.Println(cache.Has([]byte(`hello2`))) // false

	fmt.Printf("hello = %s\n", cache.Get(nil, key)) // hello= world
    
	cache.Del(key)
	fmt.Println(cache.Has(key)) // fasle
}

// --- 简洁的 LogEntry 结构体 ---
type LogEntry struct {
	Timestamp  int64  `json:"timestamp"`  // 8 字节
	Level      byte   `json:"level"`      // 1 字节
	Source     string `json:"source"`     // 字符串头 16 字节
	Message    string `json:"message"`    // 字符串头 16 字节
	UserID     uint32 `json:"user_id"`    // 4 字节
	IsCritical bool   `json:"is_critical"`// 1 字节
}

func (le *LogEntry) MarshalBinary() []byte {
	leBytes, err := json.Marshal(le)
	if err != nil {
		panic("marshal failed")
	}
	return leBytes
}

func (le *LogEntry) UnmarshalBinary(data []byte) error {
	if le == nil {
		return errors.New("LogEntry pointer is nil")
	}
	return json.Unmarshal(data, le)
}

// --- 辅助函数：内存统计 ---
func printMemUsage(msg string) {
	var m runtime.MemStats
	runtime.ReadMemStats(&m)
	fmt.Printf("--- %s ---\n", msg)
	fmt.Printf("Heap Alloc = %s\n", formatBytes(m.HeapAlloc)) // 当前堆上已分配并仍在使用的字节数
	fmt.Printf("Total Objects = %d\n", m.HeapObjects)         // 堆上对象的总数
	fmt.Printf("Sys Memory = %s\n", formatBytes(m.Sys))       // 操作系统为进程分配的总内存
	fmt.Printf("NumGC = %d\n\n", m.NumGC)                     // 完成的GC循环次数
}

func formatBytes(b uint64) string {
	const unit = 1024
	if b < unit {
		return fmt.Sprintf("%d B", b)
	}
	div, exp := uint64(unit), 0
	for n := b / unit; n >= unit; n /= unit {
		div *= unit
		exp++
	}
	return fmt.Sprintf("%.1f %cB", float64(b)/float64(div), "KMGTPE"[exp])
}

// --- 主函数 ---
func main() {
	const numObjects = 2_000_000 // 200万个对象

	// 1. 初始内存使用
	runtime.GC()                       // 强制GC，确保内存统计相对干净
	time.Sleep(time.Millisecond * 100) // 等待GC完成
	printMemUsage("Initial Memory Usage")

	// --- 场景一：使用普通的 map[string]*LogEntry ---
	fmt.Println("--- Storing objects in map[string]*LogEntry ---")
	objMap := make(map[string]*LogEntry, numObjects) // 预分配容量

	for i := 0; i < numObjects; i++ {
		key := "log_" + strconv.Itoa(i)
		entry := &LogEntry{
			Timestamp:  time.Now().UnixNano() + int64(i),
			Level:      byte(i % 5),
			Source:     "server_node_" + strconv.Itoa(i%100),
			Message:    fmt.Sprintf("User %d performed action X. Data: %s. Level %d", i, key, i%5), // 确保字符串长度变化
			UserID:     uint32(i),
			IsCritical: i%1000 == 0,
		}
		objMap[key] = entry
	}

	runtime.GC() // 强制GC
	time.Sleep(time.Millisecond * 100)
	printMemUsage("Memory after storing in map[string]*LogEntry")

	// 保持对 objMap 的引用，避免被GC过早回收
	_ = objMap["log_0"]

	// --- 清理 map，为 fastcache 场景腾出内存 ---
	fmt.Println("--- Cleaning map and running GC ---")
	objMap = nil // 解除引用，允许GC回收
	runtime.GC() // 强制GC
	time.Sleep(time.Millisecond * 100)
	printMemUsage("Memory after map cleanup")

	// --- 场景二：使用 fastcache ---
	fmt.Println("--- Storing objects in fastcache ---")
	// 估算 fastcache 容量：
	// 每个 LogEntry 序列化后：固定部分约 18 字节 + 2 * (字符串长度 + 4字节长度前缀)。
	// 假设 Source 平均 20 字节，Message 平均 80 字节。
	// 序列化后平均大小约为：18 + (20+4) + (80+4) = 18 + 24 + 84 = 126 字节。
	// 200万个对象 * 126字节/对象 = 252 MB。
	// 留出一些额外空间和 fastcache 内部索引的开销，例如 300 MB。
	cacheSize := 300 * 1024 * 1024 // 300 MB
	cache := fastcache.New(cacheSize)

	// 用于 fastcache.Get 的 dst 缓冲区，避免每次Get都重新分配
	// 估算单个序列化对象最大可能大小，例如 200字节
	getDstBuf := make([]byte, 200)

	for i := 0; i < numObjects; i++ {
		key := []byte("log_" + strconv.Itoa(i))
		entry := &LogEntry{
			Timestamp:  time.Now().UnixNano() + int64(i),
			Level:      byte(i % 5),
			Source:     "server_node_" + strconv.Itoa(i%100),
			Message:    fmt.Sprintf("User %d performed action X. Data: %s. Level %d", i, string(key), i%5),
			UserID:     uint32(i),
			IsCritical: i%1000 == 0,
		}

		serializedData := entry.MarshalBinary()
		cache.Set(key, serializedData)
	}

	runtime.GC() // 强制GC
	time.Sleep(time.Millisecond * 100)
	printMemUsage("Memory after storing in fastcache")

	// 验证 fastcache get (并保持引用)
	retrievedData := cache.Get(getDstBuf, []byte("log_0"))
	retrievedEntry := &LogEntry{}
	_ = retrievedEntry.UnmarshalBinary(retrievedData) // 实际应用需要检查错误

	fmt.Println("Demo finished. Observe the 'Heap Alloc' and 'Total Objects' differences.")
	fmt.Println("Note: fastcache's primary data is managed efficiently within its pre-allocated segments, significantly reducing Go GC's object count. Its internal index (map) still contributes to heap objects.")
}

➜  demo go run main.go                                   
--- Initial Memory Usage ---
Heap Alloc = 147.1 KB
Total Objects = 257
Sys Memory = 6.4 MB
NumGC = 1

--- Storing objects in map[string]*LogEntry ---
--- Memory after storing in map[string]*LogEntry ---
Heap Alloc = 412.0 MB
Total Objects = 8008429
Sys Memory = 451.7 MB
NumGC = 10

--- Cleaning map and running GC ---
--- Memory after map cleanup ---
Heap Alloc = 163.9 KB
Total Objects = 278
Sys Memory = 451.7 MB
NumGC = 11

--- Storing objects in fastcache ---
--- Memory after storing in fastcache ---
Heap Alloc = 72.4 MB
Total Objects = 10076
Sys Memory = 452.0 MB
NumGC = 78

Demo finished. Observe the 'Heap Alloc' and 'Total Objects' differences.
Note: fastcache's primary data is managed efficiently within its pre-allocated segments, significantly reducing Go GC's object count. Its internal index (map) still contributes to heap objects.