KyotoCabinet TreeDB 大规模数据写入性能分析与基准测试指南

# ./kyotobench
...
1024000 records, type t 1m39.120917207s throughput: 10330 /sec
2048000 records, type t 3m41.720146906s throughput: 9236 /sec
4096000 records, type t 15m26.041653712s throughput: 4423 /sec
8192000 records, type t 5h5m31.431477812s throughput: 446 /sec

4000 records, type t 10.220836ms throughput: 391357 /sec
...
8192000 records, type t 23.142591222s throughput: 353979 /sec
16384000 records, type t 46.90204795s throughput: 349323 /sec

package main

import (
    "fmt"
    "math/rand"
    "time"
    // "github.com/c9s/kyotocabinet-go/kc" // 假设使用 Go 语言绑定
    // 实际应用中需要引入 KyotoCabinet 库
)

// Pair 结构体用于存储预生成的键值对
type Pair struct {
    key   string
    value string
}

// genRandomString 辅助函数：生成指定长度的随机字符串
// 注意：实际应用中应确保键的唯一性，特别是当测试非碰撞行为时
func genRandomString(length int) string {
    const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
    b := make([]byte, length)
    for i := range b {
        b[i] = charset[rand.Intn(len(charset))]
    }
    return string(b)
}

// setupRandomPairs 预生成指定数量的随机键值对
func setupRandomPairs(count int) []Pair {
    pairs := make([]Pair, count)
    // 使用一个 map 来确保键的唯一性，防止随机生成重复键
    // 在实际基准测试中，如果需要模拟冲突，可以移除此逻辑
    uniqueKeys := make(map[string]struct{}) 
    for i := 0; i < count; i++ {
        keyLen := rand.Intn(1024) + 1 // 1到1024
        valLen := rand.Intn(1024) + 1 // 1到1024

        key := genRandomString(keyLen)
        for { // 确保键唯一
            if _, exists := uniqueKeys[key]; !exists {
                uniqueKeys[key] = struct{}{}
                break
            }
            key = genRandomString(keyLen)
        }

        pairs[i] = Pair{
            key:   key,
            value: genRandomString(valLen),
        }
    }
    fmt.Printf("预生成 %d 条随机键值对完成。\n", count)
    return pairs
}

// runBenchmark 执行数据库写入基准测试
func runBenchmark(pairs []Pair, dbFilePath string) {
    // 1. 初始化数据库 (排除在计时之外)
    // db := kc.NewTreeDB() // 假设初始化 TreeDB
    // if !db.Open(dbFilePath, kc.DB_OWRITER|kc.DB_OCREATE) {
    //     panic("无法打开数据库: " + db.Error())
    // }
    // defer db.Close()
    // defer os.Remove(dbFilePath) // 清理文件

    fmt.Printf("开始写入 %d 条记录...\n", len(pairs))
    startTime := time.Now()

    // 2. 核心数据库写入循环 (在计时之内)
    // const transactionBatchSize = 50000 // 每5万次写入提交一次事务
    for i, pair := range pairs {
        // if i%transactionBatchSize == 0 {
        //     if i > 0 {
        //         db.EndTran(true) // 提交前一个事务
        //     }
        //     db.BeginTran() // 开始新事务
        // }

        // if !db.Set([]byte(pair.key), []byte(pair.value)) {
        //     panic("写入失败: " + db.Error())
        // }
        // 模拟写入操作
        _ = pair.key
        _ = pair.value
    }

    // if len(pairs) > 0 {
    //     db.EndTran(true) // 提交最后一个事务
    // }

    duration := time.Since(startTime)
    throughput := float64(len(pairs)) / duration.Seconds()

    fmt.Printf("写入完成。总耗时: %v, 吞吐量: %.2f /sec\n", duration, throughput)
}

func main() {
    recordCounts := []int{1000, 2000, 4000, 8000, 16000, 32000, 64000, 128000, 256000, 512000, 1024000, 2048000, 4096000, 8192000}
    rand.Seed(time.Now().UnixNano()) // 初始化随机数种子

    for _, count := range recordCounts {
        // 1. 预生成数据 (排除在计时之外)
        dataPairs := setupRandomPairs(count)

        // 2. 执行基准测试
        // 每次测试使用不同的数据库文件，确保测试独立性
        dbFileName := fmt.Sprintf("test_treedb_%d.kct", count)
        runBenchmark(dataPairs, dbFileName)
        fmt.Println("------------------------------------")
    }
}