不猜瓶颈:基于 PProf 的定向性能迭代

func TopKDirectHeap(items []Item, k int) []Item {
	if len(items) <= k {
		res := make([]Item, len(items))
		copy(res, items)
		return res
	}

	h := make([]Item, k)
	copy(h, items[:k])
	// 初始化建堆: 仅调整 20 个元素
	for i := k/2 - 1; i >= 0; i-- {
		siftDown(h, i, k)
	}

	// 遍历后续元素: 绝大多数低分项在堆顶处仅做 1 次比对即可丢弃
	for i := k; i < len(items); i++ {
		if items[i].Score > h[0].Score {
			h[0] = items[i]
			siftDown(h, 0, k)
		}
	}

	slices.SortFunc(h, func(a, b Item) int {
		return cmp.Compare(b.Score, a.Score)
	})
	return h
}

func siftDown(h []Item, i, n int) {
	for {
		left := 2*i + 1
		if left >= n || left < 0 {
			break
		}
		smallest := left
		if right := left + 1; right < n && h[right].Score < h[left].Score {
			smallest = right
		}
		if h[i].Score <= h[smallest].Score {
			break
		}
		h[i], h[smallest] = h[smallest], h[i]
		i = smallest
	}
}

func TopKFullSort(items []Item, k int) []Item {
	cloned := make([]Item, len(items))
	copy(cloned, items)
	slices.SortFunc(cloned, func(a, b Item) int {
		return cmp.Compare(b.Score, a.Score)
	})
	if len(cloned) > k {
		return cloned[:k]
	}
	return cloned
}

func MaskPhoneDirect(p string) string {
	if len(p) != 11 {
		return p
	}
	return p[:3] + "****" + p[7:]
}

var phoneRegex = regexp.MustCompile(`^(\d{3})\d{4}(\d{4})$`)

func MaskPhone(phone string) string {
	return phoneRegex.ReplaceAllString(phone, "${1}****${2}")
}

func RenderSinglePass(tpl string, p map[string]string) string {
	var sb strings.Builder
	sb.Grow(len(tpl) + 64) // 预分配容量,避免底层切片扩容

	start := 0
	for {
		open := strings.Index(tpl[start:], "{{")
		if open < 0 {
			sb.WriteString(tpl[start:])
			break
		}
		open += start
		sb.WriteString(tpl[start:open])

		close := strings.Index(tpl[open+2:], "}}")
		if close < 0 {
			sb.WriteString(tpl[open:])
			break
		}
		close += open + 2
		key := tpl[open+2 : close]
		if val, ok := p[key]; ok {
			sb.WriteString(val)
		} else {
			sb.WriteString(tpl[open : close+2])
		}
		start = close + 2
	}
	return sb.String()
}

func Render(tpl string, p map[string]string) string {
	res := tpl
	for k, v := range p {
		res = strings.ReplaceAll(res, "{{"+k+"}}", v)
	}
	return res
}

func ValidateUUIDDirect(s string) bool {
	if len(s) != 36 {
		return false
	}
	if s[8] != '-' || s[13] != '-' || s[18] != '-' || s[23] != '-' {
		return false
	}
	for i := 0; i < 36; i++ {
		if i == 8 || i == 13 || i == 18 || i == 23 {
			continue
		}
		c := s[i]
		if !((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')) {
			return false
		}
	}
	return true
}

var uuidRegex = regexp.MustCompile(`^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$`)

func ValidateUUID(id string) bool {
	return uuidRegex.MatchString(id)
}

func WriteEventsBuffered(w *bufio.Writer, data []byte) error {
	_, err := w.Write(data)
	return err
}

func WriteEventsDirect(f *os.File, data []byte) error {
	_, err := f.Write(data)
	return err
}

func ScanFilesWalkDir(root string) int {
	count := 0
	_ = filepath.WalkDir(root, func(path string, d fs.DirEntry, err error) error {
		if err == nil && !d.IsDir() {
			count++
		}
		return nil
	})
	return count
}

func ScanFilesWalk(root string) int {
	count := 0
	_ = filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
		if err == nil && !info.IsDir() {
			count++
		}
		return nil
	})
	return count
}

type RouteTableCOW struct {
	ptr atomic.Pointer[map[string]string]
}

func (r *RouteTableCOW) Get(k string) string {
	m := r.ptr.Load()
	return (*m)[k]
}

type RouteTable struct {
	mu     sync.RWMutex
	routes map[string]string
}

func (t *RouteTable) Get(k string) string {
	t.mu.RLock()
	v := t.routes[k]
	t.mu.RUnlock()
	return v
}

type ShardedCache struct {
	shards [32]*shard
}

type shard struct {
	mu   sync.Mutex
	data map[string]string
}

func (c *ShardedCache) getShard(k string) *shard {
	h := fnv.New32a()
	_, _ = h.Write([]byte(k))
	return c.shards[h.Sum32()%32]
}

func (c *ShardedCache) Get(k string) string {
	s := c.getShard(k)
	s.mu.Lock()
	v := s.data[k]
	s.mu.Unlock()
	return v
}

type GlobalCache struct {
	mu   sync.Mutex
	data map[string]string
}

func (c *GlobalCache) Get(k string) string {
	c.mu.Lock()
	v := c.data[k]
	c.mu.Unlock()
	return v
}

func TrackSession(sessionID string, fullPacket []byte) {
	token := bytes.Clone(fullPacket[:32])
	sessions[sessionID] = token
}

func TrackSession(sessionID string, fullPacket []byte) {
	token := fullPacket[:32]
	sessions[sessionID] = token
}

type PacketBuffer struct {
	data [1024]byte
}

var structPtrPool = sync.Pool{
	New: func() any { return &PacketBuffer{} },
}

func Process() {
	buf := structPtrPool.Get().(*PacketBuffer)
	structPtrPool.Put(buf)
}

var slicePool = sync.Pool{
	New: func() any { return make([]byte, 1024) },
}

func Process() {
	buf := slicePool.Get().([]byte)
	slicePool.Put(buf)
}

type Aligned struct {
	B int64 // 8B
	D int64 // 8B
	A bool  // 1B
	C bool  // 1B
	// 6B 尾随填充
} // 总占用 24 字节

type Unaligned struct {
	A bool  // 1B + 7B 填充
	B int64 // 8B
	C bool  // 1B + 7B 填充
	D int64 // 8B
} // 总占用 32 字节