将 goroutines 固定到操作系统线程可以显著减少基于 Go 的高频交易系统中的 NUMA 惩罚和锁争用。我们将探讨如何利用 runtime.LockOSThread()，管理线程亲和性，并优化您的 Go 代码以适应多插槽架构。

NUMA 噩梦

在我们深入探讨 goroutine 固定之前，让我们快速回顾一下为什么 NUMA（非统一内存访问）架构对高频交易系统来说可能是个麻烦：

  • 内存访问延迟取决于哪个 CPU 核心访问哪个内存库
  • Go 调度器默认情况下在调度 goroutines 时不考虑 NUMA 拓扑
  • 这可能导致频繁的跨插槽内存访问，从而导致性能下降

在高频交易的世界中，每一纳秒都很重要，这些 NUMA 惩罚可能是盈利和亏损之间的差异。但别担心，我们有工具来驯服这个野兽！

固定 Goroutines：秘密武器

在 Go 中缓解 NUMA 问题的关键是将 goroutines 固定到特定的操作系统线程，然后可以将其绑定到特定的 CPU 核心。这确保了我们的 goroutines 保持不动，不会在 NUMA 节点之间游荡。以下是我们如何实现这一目标：

1. 将当前 goroutine 锁定到其操作系统线程


func init() {
    runtime.LockOSThread()
}

此函数调用确保当前 goroutine 被锁定在其运行的操作系统线程上。必须在程序开始时或任何需要固定的 goroutine 中调用此函数。

2. 设置线程亲和性

现在我们已经将 goroutine 锁定到一个操作系统线程，我们需要告诉操作系统我们希望这个线程在哪个 CPU 核心上运行。不幸的是，Go 没有提供原生的方法来做到这一点，所以我们需要使用一些 cgo 技巧：


// #include <pthread.h>
// #include <stdlib.h>
import "C"
import "unsafe"

func setThreadAffinity(cpuID int) {
    runtime.LockOSThread()
    
    var cpuset C.cpu_set_t
    C.CPU_ZERO(&cpuset)
    C.CPU_SET(C.int(cpuID), &cpuset)
    
    thread := C.pthread_self()
    _, err := C.pthread_setaffinity_np(thread, C.size_t(unsafe.Sizeof(cpuset)), &cpuset)
    if err != nil {
        panic(err)
    }
}

此函数使用 POSIX 线程 API 将当前线程的亲和性设置为特定的 CPU 核心。您需要从每个需要固定到特定核心的 goroutine 中调用此函数。

整合：高性能市场数据管道

现在我们有了构建块，让我们看看如何将其应用于现实世界的高频交易场景。我们将创建一个简单的市场数据管道，处理传入的 tick 并计算一些基本统计数据。


package main

import (
    "fmt"
    "runtime"
    "sync"
    "time"
)

type MarketData struct {
    Symbol string
    Price  float64
}

func marketDataProcessor(id int, inputChan <-chan MarketData, wg *sync.WaitGroup) {
    defer wg.Done()
    
    // 将此 goroutine 固定到特定的 CPU 核心
    setThreadAffinity(id % runtime.NumCPU())
    
    var count int
    var sum float64
    
    start := time.Now()
    for data := range inputChan {
        count++
        sum += data.Price
        
        if count % 1000000 == 0 {
            avgPrice := sum / float64(count)
            elapsed := time.Since(start)
            fmt.Printf("处理器 %d: 处理了 %d 个 tick，平均价格: %.2f，时间: %v\n", id, count, avgPrice, elapsed)
            start = time.Now()
            count = 0
            sum = 0
        }
    }
}

func main() {
    runtime.GOMAXPROCS(runtime.NumCPU())
    
    numProcessors := 4
    inputChan := make(chan MarketData, 10000)
    var wg sync.WaitGroup
    
    // 启动市场数据处理器
    for i := 0; i < numProcessors; i++ {
        wg.Add(1)
        go marketDataProcessor(i, inputChan, &wg)
    }
    
    // 模拟传入的市场数据
    go func() {
        for i := 0; ; i++ {
            inputChan <- MarketData{
                Symbol: fmt.Sprintf("STOCK%d", i%100),
                Price:  float64(i % 10000) / 100,
            }
        }
    }()
    
    wg.Wait()
}

在此示例中，我们创建了多个市场数据处理器，每个处理器都固定在特定的 CPU 核心上。这种方法帮助我们最大限度地利用多核系统，同时最小化 NUMA 惩罚。

Goroutine 固定的优缺点

在您全力以赴地进行 goroutine 固定之前，了解权衡是很重要的：

优点：

  • 减少多插槽系统中的 NUMA 惩罚
  • 改善缓存局部性并减少缓存抖动
  • 更好地控制工作负载在 CPU 核心之间的分布
  • 在高频交易场景中可能显著提高性能

缺点：

  • 增加代码和系统设计的复杂性
  • 如果管理不当，可能导致负载分布不均
  • 失去 Go 内置调度的一些好处
  • 可能需要操作系统特定的代码来管理线程亲和性

衡量影响：前后对比

要真正欣赏 goroutine 固定的好处，关键是要在实施前后测量系统的性能。以下是一些关键指标：

  • 延迟百分位数（p50, p99, p99.9）
  • 吞吐量（每秒处理的消息数）
  • 各核心的 CPU 利用率
  • 内存访问模式（使用 Intel VTune 或 AMD uProf 等工具）

专业提示：使用 pprof 等工具在实现 goroutine 固定之前和之后生成应用程序的 CPU 和内存配置文件。这可以提供有关优化如何影响系统行为的宝贵见解。

超越固定：高频交易工作负载的额外优化

虽然 goroutine 固定是一种强大的技术，但在优化 Go 以适应高频交易工作负载时，它只是拼图的一部分。以下是一些额外的策略：

1. 内存分配优化

通过减少分配来最小化垃圾回收暂停：

  • 对频繁分配的对象使用 sync.Pool
  • 考虑对固定大小的数据使用数组而不是切片
  • 尽可能预分配缓冲区

2. 无锁数据结构

通过使用原子操作和无锁数据结构减少争用：


import "sync/atomic"

type AtomicFloat64 struct{ v uint64 }

func (f *AtomicFloat64) Store(val float64) {
    atomic.StoreUint64(&f.v, math.Float64bits(val))
}

func (f *AtomicFloat64) Load() float64 {
    return math.Float64frombits(atomic.LoadUint64(&f.v))
}

3. SIMD 指令

利用 SIMD（单指令多数据）指令进行市场数据的并行处理。虽然 Go 没有直接的 SIMD 支持，但您可以使用汇编或 cgo 来利用这些强大的指令。

总结：Go 在高频交易中的未来

正如我们所见，通过一些努力和像 goroutine 固定这样的高级技术，Go 可以成为高频交易领域的强大工具。但旅程并未就此结束。Go 团队正在不断改进运行时和调度器，这可能使这些手动优化在未来变得不必要。

记住，过早优化是万恶之源。始终首先分析您的应用程序以识别真正的瓶颈，然后再深入研究像 goroutine 固定这样的高级技术。而当您进行优化时，请测量、测量、再测量！

祝交易顺利，愿您的 goroutines 始终找到回到正确 CPU 核心的路！

“在高频交易的世界中，每一纳秒都很重要。但在软件工程的世界中，可读性和可维护性更为重要。找到平衡，您将会成功。” - 智慧的老 Gopher

进一步阅读

现在去征服那些 NUMA 节点吧！记住，能力越大，责任越大。明智地使用您新获得的 goroutine 固定技能！