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 字节
}

// MarshalBinary 将 LogEntry 序列化为紧凑的二进制格式
// 它会处理变长字符串：先写入字符串长度(uint32), 再写入字符串内容
func (le *LogEntry) MarshalBinary() []byte {
	// 估算初始容量，避免频繁扩容
	// 8(Timestamp) + 1(Level) + 4(SourceLen) + len(Source) + 4(MessageLen) + len(Message) + 4(UserID) + 1(IsCritical)
	initialCap := 8 + 1 + 4 + len(le.Source) + 4 + len(le.Message) + 4 + 1
	buf := make([]byte, 0, initialCap)

	// Timestamp (8 bytes)
	buf = binary.LittleEndian.AppendUint64(buf, uint64(le.Timestamp))
	// Level (1 byte)
	buf = append(buf, le.Level)

	// Source (length + data)
	buf = binary.LittleEndian.AppendUint32(buf, uint32(len(le.Source)))
	buf = append(buf, []byte(le.Source)...)

	// Message (length + data)
	buf = binary.LittleEndian.AppendUint32(buf, uint32(len(le.Message)))
	buf = append(buf, []byte(le.Message)...)

	// UserID (4 bytes)
	buf = binary.LittleEndian.AppendUint32(buf, le.UserID)
	// IsCritical (1 byte)
	if le.IsCritical {
		buf = append(buf, 1)
	} else {
		buf = append(buf, 0)
	}
	return buf
}

// UnmarshalBinary 从紧凑的二进制格式中反序列化 LogEntry
// 它会根据长度前缀读取变长字符串
func (le *LogEntry) UnmarshalBinary(data []byte) error {
	offset := 0

	// Timestamp (8 bytes)
	if offset+8 > len(data) {
		return errors.New("UnmarshalBinary: data too short for Timestamp")
	}
	le.Timestamp = int64(binary.LittleEndian.Uint64(data[offset : offset+8]))
	offset += 8

	// Level (1 byte)
	if offset+1 > len(data) {
		return errors.New("UnmarshalBinary: data too short for Level")
	}
	le.Level = data[offset]
	offset += 1

	// Source (length + data)
	if offset+4 > len(data) { // Check for length prefix
		return errors.New("UnmarshalBinary: data too short for Source length")
	}
	sourceLen := binary.LittleEndian.Uint32(data[offset : offset+4])
	offset += 4
	if offset+int(sourceLen) > len(data) { // Check for string data
		return errors.New("UnmarshalBinary: data too short for Source string data")
	}
	le.Source = string(data[offset : offset+int(sourceLen)])
	offset += int(sourceLen)

	// Message (length + data)
	if offset+4 > len(data) { // Check for length prefix
		return errors.New("UnmarshalBinary: data too short for Message length")
	}
	messageLen := binary.LittleEndian.Uint32(data[offset : offset+4])
	offset += 4
	if offset+int(messageLen) > len(data) { // Check for string data
		return errors.New("UnmarshalBinary: data too short for Message string data")
	}
	le.Message = string(data[offset : offset+int(messageLen)])
	offset += int(messageLen)

	// UserID (4 bytes)
	if offset+4 > len(data) {
		return errors.New("UnmarshalBinary: data too short for UserID")
	}
	le.UserID = binary.LittleEndian.Uint32(data[offset : offset+4])
	offset += 4

	// IsCritical (1 byte)
	if offset+1 > len(data) {
		return errors.New("UnmarshalBinary: data too short for IsCritical")
	}
	le.IsCritical = data[offset] == 1
	return nil
}

// --- 辅助函数：内存统计 ---
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])
}

// --- 场景一：使用普通的 map[string]*LogEntry ---
func testRawMap() {
	fmt.Println("--- Running Test: map[string]*LogEntry ---")

	runtime.GC()                       // 强制GC，确保内存统计相对干净
	time.Sleep(time.Millisecond * 100) // 等待GC完成
	printMemUsage("Initial Memory Usage for Raw Map Test")

	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 - This is a longer message.", 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"]

	fmt.Println("--- Raw Map Test Finished ---")
}

// --- 场景二：使用 fastcache ---
func testFastCache() {
	fmt.Println("--- Running Test: fastcache ---")

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

	// 估算 fastcache 容量：
	// 每个 LogEntry 序列化后：固定部分约 18 字节 + 2 * (字符串长度 + 4字节长度前缀)。
	// 假设 Source 平均 25 字节，Message 平均 100 字节。
	// 序列化后平均大小约为：18 + (25+4) + (100+4) = 18 + 29 + 104 = 151 字节。
	// 200万个对象 * 151字节/对象 = 302 MB。
	// 留出一些额外空间和 fastcache 内部索引的开销，例如 350 MB。
	cacheSize := 350 * 1024 * 1024 // 350 MB
	cache := fastcache.New(cacheSize)

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

	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 - This is a much longer and more variable message to simulate real logs.", 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{}
	if err := retrievedEntry.UnmarshalBinary(retrievedData); err != nil {
		fmt.Printf("Error unmarshalling retrieved data: %v\n", err)
	}

	fmt.Println("--- FastCache Test Finished ---")
}

// --- 主入口函数 ---
func main() {
	// 定义命令行参数
	runRaw := flag.Bool("raw", false, "Run the raw map[string]*LogEntry memory comparison.")
	runFastCache := flag.Bool("fastcache", false, "Run the fastcache memory comparison.")
	flag.Parse() // 解析命令行参数

	if !*runRaw && !*runFastCache {
		fmt.Println("Please specify which test to run: --raw or --fastcache")
		fmt.Println("Example: go run mem_compare_v3.go --raw")
		fmt.Println("Example: go run mem_compare_v3.go --fastcache")
		return
	}

	if *runRaw {
		testRawMap()
	}

	if *runFastCache {
		testFastCache()
	}

	fmt.Println("Demo execution completed.")
}

➜  demo go run mem_compare_v3.go --raw         # 运行原生 map
--- Running Test: map[string]*LogEntry ---
--- Initial Memory Usage for Raw Map Test ---
Heap Alloc = 148.8 KB
Total Objects = 262
Sys Memory = 6.4 MB
NumGC = 1

--- Memory after storing in map[string]*LogEntry ---
Heap Alloc = 473.0 MB                    # 堆上申请的内存
Total Objects = 8008429
Sys Memory = 517.6 MB                    # 实际消耗的内存
NumGC = 10

--- Raw Map Test Finished ---
Demo execution completed.


➜  demo go run mem_compare_v3.go --fastcache    # 运行fastcache
--- Running Test: fastcache ---
--- Initial Memory Usage for FastCache Test ---
Heap Alloc = 147.5 KB
Total Objects = 256
Sys Memory = 6.4 MB
NumGC = 1

--- Memory after storing in fastcache ---
Heap Alloc = 72.5 MB                      # 堆的内存极大的减少
Total Objects = 10005 
Sys Memory = 133.8 MB                     # 实际消耗的内存降低了8成
NumGC = 64

--- FastCache Test Finished ---
Demo execution completed.