《后端架构设计·分布式与数据一致性》2.2 逻辑时钟与向量时钟：因果关系怎么编码

=== RUN   TestLamportOrdersButCannotProveConcurrency
    vector_test.go:12: independent events: node-a=1 node-b=1 equal=true
    vector_test.go:21: node-a later=2 node-b=1
--- PASS: TestLamportOrdersButCannotProveConcurrency (0.00s)

// file: internal/platform/causality/vector.go
// tier: L1
// verify: go test ./internal/platform/causality/ -count=1
package causality

import "sort"

// Lamport is a scalar logical clock. It orders causally related events but
// cannot prove that two events are concurrent.
type Lamport struct{ n uint64 }

func (l *Lamport) Tick() uint64 { l.n++; return l.n }

func (l *Lamport) Observe(remote uint64) uint64 {
	if remote > l.n {
		l.n = remote
	}
	l.n++
	return l.n
}

func (l *Lamport) Value() uint64 { return l.n }

// VectorClock counts events per node.
type VectorClock map[string]uint64

func (v VectorClock) Tick(node string) uint64 {
	v[node]++
	return v[node]
}

func (v VectorClock) Observe(node string, remote uint64) uint64 {
	if remote > v[node] {
		v[node] = remote
	}
	v[node]++
	return v[node]
}

// Merge takes the pointwise maximum of two clocks.
func (v VectorClock) Merge(other VectorClock) {
	for node, counter := range other {
		if counter > v[node] {
			v[node] = counter
		}
	}
}

// Nodes returns node IDs in sorted order for stable output.
func (v VectorClock) Nodes() []string {
	nodes := make([]string, 0, len(v))
	for node := range v {
		nodes = append(nodes, node)
	}
	sort.Strings(nodes)
	return nodes
}

// Relation is the result of comparing two vector clocks.
type Relation int

const (
	Equal Relation = iota
	Before
	After
	Concurrent
)

func (r Relation) String() string {
	switch r {
	case Equal:
		return "equal"
	case Before:
		return "before"
	case After:
		return "after"
	case Concurrent:
		return "concurrent"
	default:
		return "unknown"
	}
}

// Compare classifies two unpruned clocks. Missing nodes count as zero.
func (v VectorClock) Compare(other VectorClock) Relation {
	lessOrEqual, greaterOrEqual := true, true
	for node, a := range v {
		b := other[node]
		if a > b {
			lessOrEqual = false
		}
		if a < b {
			greaterOrEqual = false
		}
	}
	for node, b := range other {
		a := v[node]
		if a > b {
			lessOrEqual = false
		}
		if a < b {
			greaterOrEqual = false
		}
	}
	switch {
	case lessOrEqual && greaterOrEqual:
		return Equal
	case lessOrEqual:
		return Before
	case greaterOrEqual:
		return After
	default:
		return Concurrent
	}
}

$ go test ./internal/platform/causality/ -run TestVectorClockRelations -v -count=1
=== RUN   TestVectorClockRelations/equal
    vector_test.go:44: map[a:2 b:1] compare map[a:2 b:1] = equal
=== RUN   TestVectorClockRelations/before
    vector_test.go:44: map[a:1 b:1] compare map[a:1 b:2 c:1] = before
=== RUN   TestVectorClockRelations/after
    vector_test.go:44: map[a:1 b:2 c:1] compare map[a:1 b:1] = after
=== RUN   TestVectorClockRelations/concurrent
    vector_test.go:44: map[a:2 b:1] compare map[a:1 b:2] = concurrent
=== RUN   TestVectorClockRelations/disjoint
    vector_test.go:44: map[a:1] compare map[b:1] = concurrent
=== RUN   TestVectorClockRelations/empty_vs_event
    vector_test.go:44: map[] compare map[a:1] = before
--- PASS: TestVectorClockRelations (0.00s)

// file: internal/platform/causality/prune.go
// tier: L1
// verify: go test ./internal/platform/causality/ -run TestPrune -count=1
package causality

import (
	"errors"
	"fmt"
)

// ErrUnsafeFloor means the floor is above a counter still present in the clock.
var ErrUnsafeFloor = errors.New("causality: prune floor exceeds a known counter")

// ErrFloorMismatch means two pruned clocks are from different epochs.
var ErrFloorMismatch = errors.New("causality: pruned clocks have different floors")

// PrunedClock replaces entries at or below Floor with the floor itself.
type PrunedClock struct {
	Floor  uint64
	Counts VectorClock
}

// Prune drops counters equal to floor and rejects counters below it.
func (v VectorClock) Prune(floor uint64) (PrunedClock, error) {
	for node, counter := range v {
		if counter < floor {
			return PrunedClock{}, fmt.Errorf("%w: node %s counter %d floor %d",
				ErrUnsafeFloor, node, counter, floor)
		}
	}
	counts := make(VectorClock)
	for node, counter := range v {
		if counter > floor {
			counts[node] = counter
		}
	}
	return PrunedClock{Floor: floor, Counts: counts}, nil
}

// Get returns a counter, treating an absent node as the floor.
func (p PrunedClock) Get(node string) uint64 {
	if counter, ok := p.Counts[node]; ok {
		return counter
	}
	return p.Floor
}

// Compare classifies two clocks pruned at the same floor.
func (p PrunedClock) Compare(other PrunedClock) (Relation, error) {
	if p.Floor != other.Floor {
		return Equal, fmt.Errorf("%w: %d != %d", ErrFloorMismatch, p.Floor, other.Floor)
	}
	nodes := make(map[string]struct{}, len(p.Counts)+len(other.Counts))
	for node := range p.Counts {
		nodes[node] = struct{}{}
	}
	for node := range other.Counts {
		nodes[node] = struct{}{}
	}
	lessOrEqual, greaterOrEqual := true, true
	for node := range nodes {
		a, b := p.Get(node), other.Get(node)
		if a > b {
			lessOrEqual = false
		}
		if a < b {
			greaterOrEqual = false
		}
	}
	switch {
	case lessOrEqual && greaterOrEqual:
		return Equal, nil
	case lessOrEqual:
		return Before, nil
	case greaterOrEqual:
		return After, nil
	default:
		return Concurrent, nil
	}
}

=== RUN   TestPrunePreservesComparison
    vector_test.go:79: pruned a=map[a:5] b=map[a:6] relation=before
=== RUN   TestPruneRejectsFloorAboveCounter
    vector_test.go:95: prune error=causality: prune floor exceeds a known counter: node b counter 2 floor 3
=== RUN   TestPrunedCompareRejectsFloorMismatch
    vector_test.go:111: compare error=causality: pruned clocks have different floors: 3 != 4
--- PASS