《互联网产品的服务端架构·产品、流量与基础能力》8.1 读多写少的产品事实

// file: internal/cache/profile.go
// tier: L1
// verify: go test ./internal/cache/

package cache

import "fmt"

// Traffic 是一段时间内可测量的读写事实，不是按 DAU 拍出来的假设。
// Reads 与 Writes 统计到达缓存层的请求次数，DistinctKeys 统计
// 这段时间内出现过的独立键数量，AvgValueBytes 是单个值的平均大小。
type Traffic struct {
	Reads         int64
	Writes        int64
	DistinctKeys  int64
	AvgValueBytes int
}

// Profile 是读多写的事实画像。
// ReadPerWrite 为 -1 表示完全没有写，而不是除零。
type Profile struct {
	ReadPerWrite    float64
	WorkingSetBytes int64
}

// Plan 是缓存建议。NeedsCache 为 false 时其余字段没有意义。
// MinHitRate 是盈亏平衡命中率，低于它缓存只会增加一层复杂度。
type Plan struct {
	NeedsCache bool
	MinHitRate float64
}

// CacheReadWriteThreshold 是建议缓存的读多写比下限。
const CacheReadWriteThreshold = 20.0

// Analyze 把原始流量换算成可用于决策的画像。
func Analyze(t Traffic) (Profile, error) {
	if t.Reads < 0 {
		return Profile{}, fmt.Errorf("reads must be >= 0, got %d", t.Reads)
	}
	if t.Writes < 0 {
		return Profile{}, fmt.Errorf("writes must be >= 0, got %d", t.Writes)
	}
	if t.DistinctKeys < 0 {
		return Profile{}, fmt.Errorf("distinct keys must be >= 0, got %d", t.DistinctKeys)
	}
	if t.AvgValueBytes < 0 {
		return Profile{}, fmt.Errorf("avg value bytes must be >= 0, got %d", t.AvgValueBytes)
	}

	ratio := -1.0
	if t.Writes > 0 {
		ratio = float64(t.Reads) / float64(t.Writes)
	}

	return Profile{
		ReadPerWrite:    ratio,
		WorkingSetBytes: t.DistinctKeys * int64(t.AvgValueBytes),
	}, nil
}

// Recommend 只回答两个问题：要不要缓存，以及命中率至少要到多少。
// 纯读流量没有写放大，任意命中都是净收益，因此不设命中率下限。
func Recommend(p Profile) Plan {
	if p.ReadPerWrite < 0 {
		return Plan{NeedsCache: true}
	}
	if p.ReadPerWrite < CacheReadWriteThreshold {
		return Plan{}
	}
	// 写请求占总请求的比例，就是缓存至少要挡掉的比例。
	return Plan{
		NeedsCache: true,
		MinHitRate: 1 / (1 + p.ReadPerWrite),
	}
}

// file: internal/cache/profile_test.go
// tier: L1
// verify: go test ./internal/cache/

package cache

import (
	"math"
	"testing"
)

func almostEqual(a, b float64) bool { return math.Abs(a-b) < 1e-9 }

func TestAnalyzeComputesRatioAndWorkingSet(t *testing.T) {
	got, err := Analyze(Traffic{
		Reads:         4000,
		Writes:        100,
		DistinctKeys:  12000,
		AvgValueBytes: 512,
	})
	if err != nil {
		t.Fatalf("Analyze returned error: %v", err)
	}
	if !almostEqual(got.ReadPerWrite, 40) {
		t.Fatalf("ReadPerWrite = %v, want 40", got.ReadPerWrite)
	}
	if got.WorkingSetBytes != 12000*512 {
		t.Fatalf("WorkingSetBytes = %d, want %d", got.WorkingSetBytes, 12000*512)
	}
}

func TestAnalyzeReadOnlyUsesMinusOne(t *testing.T) {
	got, err := Analyze(Traffic{Reads: 90, Writes: 0, DistinctKeys: 3, AvgValueBytes: 100})
	if err != nil {
		t.Fatalf("Analyze returned error: %v", err)
	}
	if got.ReadPerWrite != -1 {
		t.Fatalf("ReadPerWrite = %v, want -1", got.ReadPerWrite)
	}
	if got.WorkingSetBytes != 300 {
		t.Fatalf("WorkingSetBytes = %d, want 300", got.WorkingSetBytes)
	}
}

func TestAnalyzeRejectsNegativeInput(t *testing.T) {
	cases := []Traffic{
		{Reads: -1},
		{Writes: -1},
		{DistinctKeys: -1},
		{AvgValueBytes: -1},
	}
	for i, tc := range cases {
		if _, err := Analyze(tc); err == nil {
			t.Fatalf("case %d: expected an error", i)
		}
	}
}

func TestRecommendBelowThreshold(t *testing.T) {
	got := Recommend(Profile{ReadPerWrite: 4})
	if got.NeedsCache {
		t.Fatalf("NeedsCache = true for ratio 4, want false")
	}
}

func TestRecommendAtThreshold(t *testing.T) {
	got := Recommend(Profile{ReadPerWrite: 20})
	if !got.NeedsCache {
		t.Fatal("NeedsCache = false for ratio 20, want true")
	}
	if !almostEqual(got.MinHitRate, 1.0/21.0) {
		t.Fatalf("MinHitRate = %v, want %v", got.MinHitRate, 1.0/21.0)
	}
}

func TestRecommendReadOnly(t *testing.T) {
	got := Recommend(Profile{ReadPerWrite: -1})
	if !got.NeedsCache {
		t.Fatal("NeedsCache = false for a read-only workload")
	}
	if got.MinHitRate != 0 {
		t.Fatalf("MinHitRate = %v, want 0", got.MinHitRate)
	}
}

cd .local/checks/webapp-lab && go test ./internal/cache/ -count=1 -run 'TestAnalyze|TestRecommend' -v

=== RUN   TestAnalyzeComputesRatioAndWorkingSet
--- PASS: TestAnalyzeComputesRatioAndWorkingSet (0.00s)
=== RUN   TestAnalyzeReadOnlyUsesMinusOne
--- PASS: TestAnalyzeReadOnlyUsesMinusOne (0.00s)
=== RUN   TestAnalyzeRejectsNegativeInput
--- PASS: TestAnalyzeRejectsNegativeInput (0.00s)
=== RUN   TestRecommendBelowThreshold
--- PASS: TestRecommendBelowThreshold (0.00s)
=== RUN   TestRecommendAtThreshold
--- PASS: TestRecommendAtThreshold (0.00s)
=== RUN   TestRecommendReadOnly
--- PASS: TestRecommendReadOnly (0.00s)
PASS
ok  	webapp/internal/cache	0.231s