256 lines
6.1 KiB
Go
256 lines
6.1 KiB
Go
// pacer.go Day 48(开发计划 Day47④⑤ 挪入):下发侧限速三件套——
|
||
// - TokenBucket:单通道纯内存令牌桶(rate=channel.speed,默认 3000);
|
||
// - ChannelPacer:per-channel 令牌桶 + 在途窗口(256=16 连接×16,Day39 实测背书)
|
||
// - p50>50ms 持续 30s 自动降速 10%(单向,Reset 手动恢复);
|
||
// - PaceBudget:群发匀速投放预算——每轮 min(剩余, Σ通道speed − 在途余量),
|
||
// 防瞬时打满下游队列(技术方案 10.4.1)。
|
||
package send
|
||
|
||
import (
|
||
"context"
|
||
"sort"
|
||
"sync"
|
||
"time"
|
||
)
|
||
|
||
// PacerDefaults 与技术方案/开发计划对齐。
|
||
const (
|
||
DefaultChannelSpeed = 3000
|
||
PacerWindow = 256 // 在途窗口:16 连接 × 16
|
||
PacerSlowMs = 50.0 // p50 慢阈值(ms)
|
||
PacerSlowHold = 30 * time.Second
|
||
PacerSamples = 128 // p50 观测样本环
|
||
)
|
||
|
||
// TokenBucket 纯内存令牌桶(时间补充,无需 ticker)。
|
||
type TokenBucket struct {
|
||
mu sync.Mutex
|
||
tokens float64
|
||
rate float64 // 个/秒
|
||
cap float64
|
||
last time.Time
|
||
}
|
||
|
||
// NewTokenBucket 构造(cap=rate 起步满桶;rate<=0 用默认)。
|
||
func NewTokenBucket(rate float64) *TokenBucket {
|
||
if rate <= 0 {
|
||
rate = DefaultChannelSpeed
|
||
}
|
||
return &TokenBucket{tokens: rate, rate: rate, cap: rate, last: time.Now()}
|
||
}
|
||
|
||
// refill 时间补充(elapsed × rate,上限 cap;调用方持锁)。
|
||
func (b *TokenBucket) refill(now time.Time) {
|
||
if now.After(b.last) {
|
||
b.tokens += now.Sub(b.last).Seconds() * b.rate
|
||
if b.tokens > b.cap {
|
||
b.tokens = b.cap
|
||
}
|
||
b.last = now
|
||
}
|
||
}
|
||
|
||
// Acquire 阻塞取 n 个令牌(ctx 取消即失败)。
|
||
func (b *TokenBucket) Acquire(ctx context.Context, n int) error {
|
||
if n <= 0 {
|
||
return nil
|
||
}
|
||
for {
|
||
b.mu.Lock()
|
||
b.refill(time.Now())
|
||
if b.tokens >= float64(n) {
|
||
b.tokens -= float64(n)
|
||
b.mu.Unlock()
|
||
return nil
|
||
}
|
||
need := (float64(n) - b.tokens) / b.rate
|
||
b.mu.Unlock()
|
||
select {
|
||
case <-ctx.Done():
|
||
return ctx.Err()
|
||
case <-time.After(time.Duration(need * float64(time.Second))):
|
||
}
|
||
}
|
||
}
|
||
|
||
// SetRate 调整速率(降速用;同步收缩容量)。
|
||
func (b *TokenBucket) SetRate(rate float64) {
|
||
if rate <= 0 {
|
||
return
|
||
}
|
||
b.mu.Lock()
|
||
b.rate = rate
|
||
if b.cap > rate {
|
||
b.cap = rate
|
||
if b.tokens > b.cap {
|
||
b.tokens = b.cap
|
||
}
|
||
}
|
||
b.mu.Unlock()
|
||
}
|
||
|
||
// Rate 当前速率。
|
||
func (b *TokenBucket) Rate() float64 {
|
||
b.mu.Lock()
|
||
defer b.mu.Unlock()
|
||
return b.rate
|
||
}
|
||
|
||
// chanPace 单通道状态。
|
||
type chanPace struct {
|
||
bucket *TokenBucket
|
||
window chan struct{} // 在途窗口(容量 PacerWindow)
|
||
samples []float64 // 延迟样本环
|
||
slowAt time.Time // p50 首次超阈值时刻(持续 30s 判定起点;零值=未超)
|
||
}
|
||
|
||
// ChannelPacer per-channel 下发调度器(令牌桶+在途窗口+自动降速)。
|
||
type ChannelPacer struct {
|
||
mu sync.Mutex
|
||
ch map[int64]*chanPace
|
||
open bool // true=启用(测试/装配开关;关闭时 Acquire 直通,兼容旧链路)
|
||
}
|
||
|
||
// NewChannelPacer 构造(open=false 直通——既有 timer 链路行为不变)。
|
||
func NewChannelPacer(open bool) *ChannelPacer {
|
||
return &ChannelPacer{ch: map[int64]*chanPace{}, open: open}
|
||
}
|
||
|
||
// Open 是否启用。
|
||
func (p *ChannelPacer) Open() bool { return p.open }
|
||
|
||
// SetSpeed 通道速率装载(<=0 用默认;首次调用建窗口)。
|
||
func (p *ChannelPacer) SetSpeed(channelID int64, rate float64) {
|
||
p.mu.Lock()
|
||
defer p.mu.Unlock()
|
||
st, ok := p.ch[channelID]
|
||
if !ok {
|
||
st = &chanPace{bucket: NewTokenBucket(rate), window: make(chan struct{}, PacerWindow)}
|
||
p.ch[channelID] = st
|
||
return
|
||
}
|
||
st.bucket.SetRate(rate)
|
||
}
|
||
|
||
// state 取通道状态(懒建,默认速率)。
|
||
func (p *ChannelPacer) state(channelID int64) *chanPace {
|
||
p.mu.Lock()
|
||
defer p.mu.Unlock()
|
||
if st, ok := p.ch[channelID]; ok {
|
||
return st
|
||
}
|
||
st := &chanPace{bucket: NewTokenBucket(0), window: make(chan struct{}, PacerWindow)}
|
||
p.ch[channelID] = st
|
||
return st
|
||
}
|
||
|
||
// Acquire 预占 n 条额度(令牌+在途窗口;批量提交前调用)。
|
||
// 未启用时直通 nil(默认装配在消费链路启用,timer 旧链路不启用)。
|
||
func (p *ChannelPacer) Acquire(ctx context.Context, channelID int64, n int) error {
|
||
if !p.open || n <= 0 {
|
||
return nil
|
||
}
|
||
st := p.state(channelID)
|
||
if err := st.bucket.Acquire(ctx, n); err != nil {
|
||
return err
|
||
}
|
||
for i := 0; i < n; i++ { // 在途窗口逐槽占位
|
||
select {
|
||
case st.window <- struct{}{}:
|
||
case <-ctx.Done():
|
||
for j := 0; j < i; j++ { // 回退已占槽
|
||
<-st.window
|
||
}
|
||
return ctx.Err()
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// Release 释放在途占用(提交返回后调用,含失败路径)。
|
||
func (p *ChannelPacer) Release(channelID int64, n int) {
|
||
if !p.open || n <= 0 {
|
||
return
|
||
}
|
||
p.mu.Lock()
|
||
st, ok := p.ch[channelID]
|
||
p.mu.Unlock()
|
||
if !ok {
|
||
return
|
||
}
|
||
for i := 0; i < n; i++ {
|
||
select {
|
||
case <-st.window:
|
||
default: // 防御:超释放直接忽略
|
||
return
|
||
}
|
||
}
|
||
}
|
||
|
||
// Observe 提交延迟采样(ms):p50>50ms 持续 30s → 速率×0.9(下限默认 10%)。
|
||
func (p *ChannelPacer) Observe(channelID int64, ms float64) {
|
||
if !p.open {
|
||
return
|
||
}
|
||
p.mu.Lock()
|
||
defer p.mu.Unlock()
|
||
st, ok := p.ch[channelID]
|
||
if !ok {
|
||
return
|
||
}
|
||
st.samples = append(st.samples, ms)
|
||
if len(st.samples) > PacerSamples {
|
||
st.samples = st.samples[len(st.samples)-PacerSamples:]
|
||
}
|
||
if p50(st.samples) <= PacerSlowMs {
|
||
st.slowAt = time.Time{}
|
||
return
|
||
}
|
||
now := time.Now()
|
||
if st.slowAt.IsZero() {
|
||
st.slowAt = now
|
||
return
|
||
}
|
||
if now.Sub(st.slowAt) >= PacerSlowHold {
|
||
newRate := st.bucket.Rate() * 0.9
|
||
if minRate := float64(DefaultChannelSpeed) * 0.1; newRate < minRate {
|
||
newRate = minRate
|
||
}
|
||
st.bucket.SetRate(newRate)
|
||
st.slowAt = now // 滚动继续判定(可再降)
|
||
}
|
||
}
|
||
|
||
// Rate 当前生效速率(测试/观测)。
|
||
func (p *ChannelPacer) Rate(channelID int64) float64 {
|
||
p.mu.Lock()
|
||
st, ok := p.ch[channelID]
|
||
p.mu.Unlock()
|
||
if !ok {
|
||
return 0
|
||
}
|
||
return st.bucket.Rate()
|
||
}
|
||
|
||
// p50 中位数(拷贝排序,不改原片)。
|
||
func p50(xs []float64) float64 {
|
||
if len(xs) == 0 {
|
||
return 0
|
||
}
|
||
cp := append([]float64(nil), xs...)
|
||
sort.Float64s(cp)
|
||
return cp[len(cp)/2]
|
||
}
|
||
|
||
// PaceBudget 匀速投放预算(⑤):本轮可投 = min(pending, Σspeed − inflight),下限 0。
|
||
func PaceBudget(pending, sumSpeed, inflight int) int {
|
||
b := sumSpeed - inflight
|
||
if b < 0 {
|
||
b = 0
|
||
}
|
||
if pending < b {
|
||
return pending
|
||
}
|
||
return b
|
||
}
|