【协程级SLA保障指南】：如何为每个goroutine配置独立panic recovery策略与超时熔断阈值

第一章：goroutine崩溃的本质与SLA影响分析

goroutine崩溃并非传统进程级的“程序退出”，而是由未捕获的panic在协程内部触发的非正常终止。其本质是Go运行时检测到不可恢复的错误（如空指针解引用、切片越界、向已关闭channel发送数据等），并立即停止当前goroutine的执行栈，释放其栈内存，但不会中断其他goroutine或导致整个程序退出——这是Go并发模型的关键设计，也是其脆弱性被低估的根源。

崩溃的传播边界与静默失效风险

goroutine崩溃具有严格的隔离性：panic不会跨goroutine传播，主goroutine崩溃才会终止进程。然而，当关键后台任务（如健康检查上报、指标采集、定时清理）在独立goroutine中panic却未被recover时，服务功能看似正常，实则部分SLA保障能力已悄然退化。例如：

// 危险示例：无recover的监控上报goroutine
go func() {
    for range time.Tick(30 * time.Second) {
        // 若reportMetrics()内部panic（如网络超时+未处理error）
        // 此goroutine将静默死亡，监控数据断更，但HTTP服务仍响应
        reportMetrics()
    }
}()

SLA指标的隐性劣化路径

SLA维度	崩溃影响表现	检测难度
可用性（Uptime）	主HTTP handler未崩溃 → 表面99.9%可用	高
准确性（Accuracy）	metric上报goroutine崩溃 → 监控图表失真	中
一致性（Consistency）	数据同步goroutine崩溃 → DB与缓存长期不一致	极高

主动防御实践

1. 强制recover模式：所有go func()启动点必须包裹recover逻辑，并记录带堆栈的ERROR日志；
2. 上下文绑定生命周期：使用context.WithCancel控制goroutine启停，避免孤儿goroutine；
3. 崩溃熔断告警：通过runtime/debug.Stack()捕获panic堆栈，匹配关键词（如”panic: send on closed channel”）触发PagerDuty告警；
4. 测试验证：在单元测试中显式触发goroutine panic，验证recover逻辑是否生效：

func TestBackgroundTask_RecoverOnPanic(t *testing.T) {
    done := make(chan struct{})
    go func() {
        defer func() {
            if r := recover(); r != nil {
                close(done) // 确认recover执行
            }
        }()
        panic("simulated crash")
    }()
    select {
    case <-done:
    case <-time.After(1 * time.Second):
        t.Fatal("recover did not trigger")
    }
}

第二章：panic recovery策略的协程级精细化设计

2.1 panic捕获机制原理与runtime.Goexit的协同关系

Go 的 panic 并非传统意义上的“异常中断”，而是受控的 goroutine 终止流程，其传播路径由运行时栈展开（stack unwinding）驱动，并可被 recover 捕获。

panic 的捕获时机

• recover() 只在 defer 函数中且处于 panic 正在传播的 goroutine 内有效
• 若 panic 被 recover 拦截，栈展开终止，控制权交还至 defer 所在函数
• 否则，goroutine 以 runtime.Goexit() 方式静默退出（而非崩溃）

runtime.Goexit 的关键角色

func main() {
    go func() {
        defer func() {
            if r := recover(); r != nil {
                // panic 被捕获后，goroutine 不会崩溃，但需显式终止
                runtime.Goexit() // 确保当前 goroutine 安全退出，不干扰主 goroutine
            }
        }()
        panic("handled")
    }()
}

逻辑分析：runtime.Goexit() 主动触发当前 goroutine 的清理流程（执行所有 pending defer、释放资源），等价于自然函数返回，但不触发 panic 传播。它与 recover 协同构成“捕获→清理→退出”闭环，避免 goroutine 泄漏或状态污染。

场景	panic 是否传播	Goexit 是否必需	效果
未 recover	是	否	运行时终止 goroutine
recover 后继续执行	否	否	可能遗留非法状态
recover 后立即 Goexit	否	是	安全、干净退出

graph TD
    A[panic 调用] --> B{是否在 defer 中调用 recover？}
    B -->|是| C[停止栈展开，恢复执行]
    B -->|否| D[继续展开直至 goroutine 结束]
    C --> E[执行后续逻辑]
    E --> F[runtime.Goexit?]
    F -->|是| G[执行剩余 defer，退出]
    F -->|否| H[可能继续运行非法状态]

2.2 基于defer+recover的协程隔离恢复模板（含context传递实践）

协程崩溃不可控？panic 会直接终止 goroutine，但若未隔离，可能波及主流程。核心思路：每个 goroutine 自持 recover 机制 + 携带 context 实现超时与取消联动。

协程安全封装模板

func safeGo(ctx context.Context, f func(context.Context)) {
    go func() {
        defer func() {
            if r := recover(); r != nil {
                log.Printf("goroutine panicked: %v", r)
            }
        }()
        f(ctx) // 透传 context，支持 cancel/timeout
    }()
}

逻辑分析：defer+recover 构成兜底屏障；ctx 作为唯一上下文载体，确保子协程可响应父级取消信号。参数 f 必须主动监听 ctx.Done()，否则 cancel 不生效。

关键设计对比

特性	无 context 传递	含 context 传递
取消响应	❌ 不可中断	✅ select { case <-ctx.Done(): }
超时控制	需手动 timer	context.WithTimeout()
错误溯源	panic 信息孤立	可附加 ctx.Value() 元数据

执行流示意

graph TD
    A[启动 goroutine] --> B[defer recover 捕获 panic]
    B --> C[f(ctx) 执行业务逻辑]
    C --> D{是否 ctx.Done?}
    D -->|是| E[优雅退出]
    D -->|否| F{是否 panic?}
    F -->|是| G[log 并恢复]
    F -->|否| H[正常结束]

2.3 恢复后错误分类处理：可重试panic vs 不可恢复panic的判定逻辑

在 panic 恢复（recover()）后，关键在于语义化判别错误性质，而非简单忽略。

判定核心维度

• 错误来源（系统调用/业务逻辑/资源状态）
• 上下文可重入性（是否幂等、是否持有不可回滚锁）
• 错误码特征（如 syscall.EAGAIN 可重试，syscall.ENOMEM 通常不可恢复）

典型判定逻辑代码

func classifyPanic(err interface{}) PanicKind {
    if err == nil {
        return Unknown
    }
    switch e := err.(type) {
    case error:
        if errors.Is(e, context.DeadlineExceeded) || 
           strings.Contains(e.Error(), "i/o timeout") {
            return Retryable // 网络/超时类错误，上下文干净
        }
        if errors.Is(e, syscall.ENOMEM) || 
           strings.Contains(e.Error(), "runtime: out of memory") {
            return Fatal // 内存耗尽无法通过重试缓解
        }
    default:
        return Unknown
    }
    return Unknown
}

该函数基于错误类型与字符串特征双路匹配：context.DeadlineExceeded 显式标识临时性失败；ENOMEM 表明运行时已丧失基础执行能力。注意避免依赖 e.Error() 的模糊匹配，应优先使用 errors.Is() 做结构化判断。

判定决策表

错误类型	可重试	依据
context.Canceled	✅	控制流主动终止，无副作用
syscall.EAGAIN	✅	资源瞬时不可用
runtime: stack overflow	❌	goroutine 栈已崩溃

恢复路径流程

graph TD
    A[panic 发生] --> B{recover() 捕获}
    B --> C[提取 err 接口]
    C --> D[classifyPanic]
    D --> E{Retryable?}
    E -->|是| F[重置状态 → 重试]
    E -->|否| G[记录 fatal log → os.Exit]

2.4 恢复上下文快照：自动采集goroutine ID、启动栈、panic值与时间戳

当 panic 发生时，Go 运行时需在 defer 链中快速捕获完整上下文，而非仅记录错误类型。

核心采集字段

• goroutine ID：通过 runtime.Stack(buf, false) 解析首行数字提取
• 启动栈：调用 runtime.Callers(2, pcs[:]) 获取 panic 触发前的调用链
• panic 值：由 recover() 直接返回，支持任意接口类型
• 时间戳：time.Now().UnixNano() 纳秒级精度，避免时钟漂移

采集逻辑示例

func captureSnapshot() map[string]interface{} {
    panicVal := recover()
    var buf [2048]byte
    n := runtime.Stack(buf[:], false)
    goid := parseGoroutineID(string(buf[:n])) // 从 "goroutine 123 [" 提取 123
    var pcs [64]uintptr
    runtime.Callers(2, pcs[:])
    return map[string]interface{}{
        "goroutine_id": goid,
        "stack_trace":  pcs[:],
        "panic_value":  panicVal,
        "timestamp_ns": time.Now().UnixNano(),
    }
}

该函数在 defer 中执行，runtime.Callers(2, ...) 跳过 captureSnapshot 和 defer 包装层，精准定位 panic 起源。parseGoroutineID 为正则提取（如 regexp.MustCompile("goroutine (\\d+) ")），确保跨 Go 版本兼容。

字段	类型	说明
goroutine_id	int64	非唯一但可区分并发上下文
stack_trace	[]uintptr	可后续用 runtime.FuncForPC 符号化解析
panic_value	interface{}	支持 error、string、自定义结构体

graph TD
    A[panic 触发] --> B[进入 defer 链]
    B --> C[captureSnapshot 执行]
    C --> D[采集 goroutine ID + 栈 + panic 值 + 时间戳]
    D --> E[序列化为 JSON 存入环形缓冲区]

2.5 多级恢复兜底：嵌套goroutine中recover链式传播与抑制策略

recover 的作用边界

recover() 仅在直接 defer 的函数中有效，且仅对当前 goroutine 的 panic 生效。跨 goroutine 调用无法捕获——这是链式传播的前提约束。

链式传播的典型模式

func inner() {
    defer func() {
        if r := recover(); r != nil {
            log.Printf("inner recovered: %v", r)
            // 主动 re-panic 实现向上传播
            panic(r) // ← 关键：显式重抛以触发外层 recover
        }
    }()
    panic("from inner")
}

func outer() {
    defer func() {
        if r := recover(); r != nil {
            log.Printf("outer caught: %v", r) // ✅ 捕获 inner 的 re-panic
        }
    }()
    inner()
}

逻辑分析：inner 中 recover() 拦截 panic 后主动 panic(r)，使控制流返回 outer 的 defer 栈帧；outer 的 recover() 才能生效。若省略 panic(r)，panic 将被静默吞没，传播中断。

抑制策略对比

策略	行为	适用场景
recover() + return	终止传播，静默处理	业务可降级、无需上报
recover() + panic()	向上移交控制权	错误需外层统一日志/监控
recover() + send to channel	异步通知主 goroutine	跨协程错误聚合

流程示意

graph TD
    A[inner goroutine panic] --> B{inner defer recover?}
    B -->|Yes| C[log & re-panic]
    B -->|No| D[panic escapes]
    C --> E[outer goroutine defer]
    E --> F{outer recover?}
    F -->|Yes| G[统一处理]
    F -->|No| H[进程崩溃]

第三章：超时熔断阈值的动态绑定与生命周期管理

3.1 context.WithTimeout在goroutine启动阶段的精准注入时机分析

context.WithTimeout 的注入必须发生在 goroutine 启动之前，而非内部——否则超时控制将失效。

为何不能在 goroutine 内部调用？

// ❌ 错误：超时上下文在子协程内创建，父协程无法感知其生命周期
go func() {
    ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
    defer cancel()
    // ... 耗时操作
}()

该写法导致 ctx 与启动 goroutine 的调用方完全解耦，外部无法统一取消，违背 context 的传播契约。

✅ 正确注入模式

// ✅ 正确：超时上下文在 goroutine 启动前创建，并显式传入
ctx, cancel := context.WithTimeout(parentCtx, 800*time.Millisecond)
defer cancel() // 注意：cancel 应由启动方调用，非子协程
go worker(ctx) // ctx 作为参数传递，实现控制权上移

此处 ctx 继承自 parentCtx，超时计时器在 WithTimeout 返回瞬间启动，确保从goroutine 调度前即纳入上下文树管控。

关键时机对照表

注入位置	超时计时起点	外部可取消性	是否符合 context 设计原则
启动前（推荐）	✅ 精确到纳秒	✅ 可统一 cancel	✅
goroutine 内部	⚠️ 延迟启动	❌ 孤立上下文	❌

graph TD
    A[调用 WithTimeout] --> B[启动计时器]
    B --> C[goroutine 创建并传入 ctx]
    C --> D[worker 执行并监听 ctx.Done()]
    D --> E[超时或 cancel 触发 Done]

3.2 熔断阈值的配置驱动化：从环境变量/etcd到per-goroutine元数据绑定

传统熔断器依赖全局静态阈值（如 errorRate > 50%），难以适配高并发下不同业务路径的差异化容错需求。

配置源演进路径

• 环境变量：启动时注入，灵活但无法热更新
• etcd：支持动态监听，需引入 Watcher 和反序列化开销
• per-goroutine 元数据绑定：利用 context.WithValue() + runtime.SetFinalizer 实现请求粒度阈值隔离

关键实现片段

// 绑定请求级熔断策略
ctx = context.WithValue(ctx, keyCircuitBreakerConfig, &CBConfig{
    ErrorThreshold: 0.3, // 该goroutine专属阈值
    MinRequest:     20,
    Timeout:        30 * time.Second,
})

// 从ctx中提取配置（非全局单例）
cfg := ctx.Value(keyCircuitBreakerConfig).(*CBConfig)

此方式避免锁竞争，使 /payment 与 /notify 路径可独立配置 ErrorThreshold，提升弹性。

配置优先级对照表

来源	生效时机	动态性	作用域
环境变量	进程启动	❌	全局
etcd	Watch触发	✅	服务级
per-goroutine元数据	请求初始化	✅	单次调用链

graph TD
    A[HTTP Request] --> B[Parse Route & Auth]
    B --> C{Load CB Config}
    C -->|From context| D[Per-Goroutine Threshold]
    C -->|Fallback| E[etcd Default]

3.3 超时触发后的优雅终止：资源清理钩子与信号同步机制实现

当超时事件发生时，强制中断易导致文件句柄泄漏、连接未关闭或临时文件残留。优雅终止需兼顾确定性与可观测性。

资源清理钩子设计

通过 defer 链式注册与 sync.Once 保障幂等执行：

var cleanup sync.Once
func registerCleanup(f func()) {
    cleanup.Do(func() {
        // 执行所有注册的清理函数（逆序以满足依赖）
        for i := len(cleanupFuncs) - 1; i >= 0; i-- {
            cleanupFuncs[i]()
        }
    })
}

sync.Once 确保清理仅触发一次；逆序执行保证子资源先于父资源释放（如先关 socket 再释放 buffer）。

信号同步机制

使用 chan os.Signal 捕获 SIGTERM/SIGINT，并与上下文超时通道 select 同步：

信号类型	触发条件	清理优先级
SIGTERM	系统级优雅停机	高
SIGINT	用户 Ctrl+C	中
context.DeadlineExceeded	业务逻辑超时	高

graph TD
    A[Timeout or Signal] --> B{select on channels}
    B --> C[ctx.Done()]
    B --> D[signalChan]
    C & D --> E[trigger cleanup]
    E --> F[wait for in-flight ops]
    F --> G[exit 0]

关键参数：cleanupFuncs 为 []func() 类型切片，支持动态注入；signal.Notify 需显式传入 syscall.SIGTERM, syscall.SIGINT。

第四章：SLA保障体系的可观测性与自愈闭环构建

4.1 协程级指标埋点：panic频次、恢复成功率、平均超时偏差的Prometheus建模

协程（goroutine）是 Go 并发的核心单元，其生命周期短、数量大，需精细化观测。

核心指标语义定义

• goroutine_panic_total{func="xxx"}：按函数标签聚合 panic 次数（Counter）
• goroutine_recover_success_ratio：成功 recover / 总 panic 次数（Gauge，范围 [0,1]）
• goroutine_timeout_deviation_seconds：实际执行时长与预期 timeout 的偏差均值（Histogram）

Prometheus 指标建模示例

// 定义指标向量（需在协程启动前注册）
var (
    panicCounter = promauto.NewCounterVec(
        prometheus.CounterOpts{
            Name: "goroutine_panic_total",
            Help: "Total number of panics per goroutine function",
        },
        []string{"func"},
    )
    timeoutDeviation = promauto.NewHistogramVec(
        prometheus.HistogramOpts{
            Name:    "goroutine_timeout_deviation_seconds",
            Help:    "Deviation (actual - expected) of goroutine execution time",
            Buckets: prometheus.LinearBuckets(-5.0, 0.5, 20), // 支持负偏差（提前完成）
        },
        []string{"func"},
    )
)

逻辑说明：LinearBuckets(-5.0, 0.5, 20) 覆盖 [-5s, +4.5s] 偏差区间，适配“超时前优雅退出”场景；func 标签确保按业务入口函数维度下钻。

恢复成功率计算逻辑

指标名	类型	计算方式
goroutine_recover_success_ratio	Gauge	sum(rate(goroutine_recover_success_total[1m])) / sum(rate(goroutine_panic_total[1m]))

数据同步机制

graph TD
    A[goroutine 启动] --> B[defer recover() 捕获]
    B --> C{panic 发生？}
    C -->|是| D[inc goroutine_panic_total]
    C -->|否| E[记录正常耗时]
    D --> F[尝试 recover → 成功则 inc recover_success_total]
    E & F --> G[Observe timeoutDeviation]

4.2 实时告警联动：基于Grafana Alerting触发goroutine行为画像分析

当Grafana Alerting发出HighGoroutineCount告警时，Webhook将事件推送到轻量级HTTP服务，触发实时goroutine快照采集与画像建模。

告警事件接收与路由

func handleAlert(w http.ResponseWriter, r *http.Request) {
    var alertData AlertPayload
    json.NewDecoder(r.Body).Decode(&alertData)
    if alertData.Status == "firing" && alertData.Labels["job"] == "app-server" {
        go analyzeGoroutines(alertData.Annotations["instance"]) // 异步启动画像分析
    }
}

逻辑说明：仅对firing状态且标签匹配app-server的告警启动goroutine分析；Annotations["instance"]提供目标实例地址，避免全量扫描。

行为画像关键维度

• 阻塞类型分布：channel send/receive、mutex lock、syscall
• 栈深度热力：>15层调用占比（反映递归或过度封装）
• 生命周期聚类：瞬时（5s）、僵尸（无GC回收）

分析结果关联表

维度	正常阈值	当前值	风险等级
平均栈深	≤8	13.2	⚠️ 高
channel阻塞率		27.6%	🔴 紧急

graph TD
    A[Grafana Alert] --> B{Webhook接收}
    B --> C[解析Labels/Annotations]
    C --> D[启动goroutine快照采集]
    D --> E[pprof/goroutine?debug=2解析]
    E --> F[生成行为画像JSON]
    F --> G[推送至异常根因知识库]

4.3 自动降级执行：熔断触发后fallback goroutine的动态加载与沙箱隔离

当熔断器进入 OPEN 状态，主调用链立即终止，控制权交由 fallback 调度器接管：

func loadFallbackSandbox(name string) (*sandbox.Instance, error) {
    // 动态加载预编译的 fallback .so 模块（非反射，避免 runtime.Load）
    mod, err := sandbox.LoadModule(fmt.Sprintf("./fallbacks/%s.so", name))
    if err != nil {
        return nil, err
    }
    // 限制资源：CPU 时间片 ≤5ms，内存上限 16MB，无网络/文件系统权限
    inst, _ := mod.NewInstance(sandbox.WithLimits(5*time.Millisecond, 16<<20))
    return inst, nil
}

该函数通过 sandbox.LoadModule 加载隔离模块，WithLimits 强制约束执行边界，确保 fallback 不引发级联雪崩。

沙箱能力矩阵

能力	允许	说明
系统调用	否	仅支持 read/write 到 pipe
网络访问	否	socket 相关 syscall 被拦截
内存分配	是	受硬上限 16MB 限制
Goroutine 创建	是	最大并发数 ≤3

执行流程

graph TD
    A[熔断触发] --> B{fallback 模块是否存在？}
    B -->|是| C[加载沙箱实例]
    B -->|否| D[启用内置轻量 fallback]
    C --> E[注入上下文参数]
    E --> F[超时保护下执行]
    F --> G[返回降级结果]

fallback 实例在独立地址空间中启动，与主进程零共享，杜绝状态污染。

4.4 恢复策略AB测试：通过pprof+trace标签对比不同recover策略的SLA达标率

为量化不同panic恢复策略对服务可用性的影响，我们在Go服务中注入带trace_id和recover_type标签的分布式追踪，并结合runtime/pprof采集goroutine阻塞与GC暂停数据。

策略埋点示例

// 在recover逻辑中注入trace标签
func recoverWithTrace() {
    defer func() {
        if r := recover(); r != nil {
            trace.SpanFromContext(ctx).AddEvent("panic_recovered", 
                trace.WithAttributes(attribute.String("recover_type", "defer_panic")))
            metrics.RecoverCounter.WithLabelValues("defer_panic").Inc()
        }
    }()
}

该代码确保每次recover事件携带可聚合的recover_type属性（如defer_panic/sigusr1_restart），供后端按标签切片分析SLA（99% P99延迟 ≤ 200ms）。

SLA达标率对比（72h观测）

recover_type	请求量	SLA达标率	平均P99(ms)
defer_panic	12.4M	92.3%	241
sigusr1_restart	8.7M	98.1%	167

性能归因路径

graph TD
A[panic触发] --> B{recover_type}
B -->|defer_panic| C[同步recover+日志序列化]
B -->|sigusr1_restart| D[异步信号处理+goroutine清理]
C --> E[goroutine堆积→pprof显示block 120ms]
D --> F[trace显示span延迟<5ms]

核心发现：sigusr1_restart虽引入进程级开销，但避免了goroutine泄漏，P99降低31%，SLA提升5.8个百分点。

第五章：生产环境协程韧性演进路线图

协程失败模式的可观测性基建重构

在某电商大促系统中，团队发现大量 CoroutineScope.launch { ... } 无异常捕获导致的静默崩溃。通过接入 OpenTelemetry + Jaeger，为每个协程注入唯一 trace ID，并在 CoroutineExceptionHandler 中自动上报堆栈、父协程 ID 及启动上下文。关键改造包括：在 GlobalScope 全局禁用；所有 viewModelScope 和 lifecycleScope 统一注册自定义异常处理器；日志格式统一为 coroutine_id=0x7f8a2b1c, parent_id=0x3e4d5f6a, cause=TimeoutCancellationException。上线后，协程异常定位耗时从平均 47 分钟降至 90 秒。

超时熔断与退避策略分级落地

针对支付网关调用，实施三级超时控制：	场景	基础超时	熔断窗口	退避算法	触发条件
支付创建（核心链路）	800ms	60s	指数退避+随机抖动	连续3次失败
订单查询（降级链路）	2s	300s	固定间隔2s	错误率>40%持续10秒
用户画像（异步链路）	5s	不熔断	无	仅记录告警

代码实现采用 kotlinx.coroutines.Timeout + resilience4j-coroutines，避免手动 delay() 导致协程泄漏。

结构化取消传播的强制契约

在物流调度服务中，发现子协程未响应父协程取消信号，导致内存泄漏。强制推行以下契约：

• 所有 async 必须使用 CoroutineStart.LAZY 或显式 start()；
• 数据库查询封装层注入 withContext(Dispatchers.IO + job)，确保取消信号穿透 JDBC 连接池；
• 自定义 CancellableChannel 替代 Channel()，在 close() 时触发下游 cancelChildren()；
• 使用 ensureActive() 在循环体首行校验状态，而非依赖 isActive 条件判断。

// 正确示例：结构化取消保障
fun processBatch(batch: List<Item>): Job = launch {
    val subJob = async(start = CoroutineStart.LAZY) {
        batch.map { 
            withContext(Dispatchers.IO + coroutineContext.job) {
                // 数据库操作自动响应取消
                db.insert(it).await()
            }
        }
    }
    subJob.start() // 显式启动，避免隐式延迟
    subJob.await()
}

生产灰度验证机制设计

在金融风控系统升级 Kotlin 1.9 协程库时，采用双通道灰度：

• 流量路由：Nginx 根据用户设备指纹哈希，将 5% 流量导向新协程调度器；
• 行为埋点：对比两组 CoroutineDispatcher 的线程池队列长度、GC pause 时间、Job.isActive false 率；
• 自动回滚：当新通道错误率超过基线 0.3% 或 P99 延迟增长 >150ms，自动切换 Dispatcher 实现类。

flowchart LR
    A[HTTP Request] --> B{Hash Device ID}
    B -->|Mod 20 == 0| C[New Dispatcher]
    B -->|Else| D[Legacy Dispatcher]
    C --> E[Metrics Collector]
    D --> E
    E --> F{Error Rate > 0.3%?}
    F -->|Yes| G[Auto Rollback]
    F -->|No| H[Promote to 100%]