Files
go-sms-V2/internal/service/send/pacer.go
T

256 lines
6.1 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// 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
}