Go 插件系统设计：mmap Ring Buffer vs PureGo FFI

基于 gogpu/ui 项目背景下，讨论两种替代 Go 原生 plugin 包的插件机制设计方案。

方案 1: iouring-style Ring Buffer + mmap

核心思想：借鉴 iouring 的设计，用 mmap 创建共享内存 ring buffer，实现零拷贝 IPC

架构设计

┌─────────────────┐         ┌─────────────────┐
│   主进程 (Host) │  mmap    │   插件进程      │
│                 │◄────────►│   (Plugin)      │
│  ┌───────────┐  │ 共享内存 │  ┌───────────┐  │
│  │ Ring Head │  │          │  │ Ring Tail │  │
│  │   (写入)   │  │          │  │   (读取)   │  │
│  └───────────┘  │          │  └───────────┘  │
│         │       │          │         │       │
│  ┌──────▼──────┐│          │  ┌──────▼──────┐│
│  │  Data Region││          │  │  Data Region││
│  │  (4096 bytes)│           │  │  (4096 bytes)│
│  └─────────────┘│          │  └─────────────┘│
└─────────────────┘          └─────────────────┘

核心实现

// 共享内存结构
 type SharedRing struct {
    // 头部元数据 (原子操作)
    Head   uint64  // 写入位置
    Tail   uint64  // 读取位置
    Mutex  uint32  // 简单自旋锁
    
    // 数据区
    Data   [4096]byte  // 实际数据
}

// 主进程创建共享内存
shm, _ := unix.Mmap(
    -1, 0, size,
    unix.PROT_READ|unix.PROT_WRITE,
    unix.MAP_SHARED|unix.MAP_ANONYMOUS,
)

// 启动子进程时继承这段内存
cmd := exec.Command("./plugin")
cmd.ExtraFiles = []*os.File{shmFile}  // 通过文件描述符传递

优缺点

方案 2: PureGo FFI (推荐 ✅)

核心思想：用 ebitengine/purego 在运行时动态加载共享库，无需 CGO

架构设计

┌──────────────────────────────────────────────────────────┐
│                     主进程 (Host)                         │
│  ┌────────────────────────────────────────────────────┐  │
│  │  purego.Dlopen("./plugin.so")                      │  │
│  │           ↓                                        │  │
│  │  purego.RegisterLibFunc(&func, "SymbolName")      │  │
│  │           ↓                                        │  │
│  │  func(data) -> result  // 直接调用！              │  │
│  └────────────────────────────────────────────────────┘  │
└──────────────────────────────────────────────────────────┘
                              │
                              │ 加载
                              ↓
┌──────────────────────────────────────────────────────────┐
│                   plugin.so (C ABI)                      │
│  ┌────────────────────────────────────────────────────┐  │
│  │  //export ProcessData                              │  │
│  │  func ProcessData(data *C.char) *C.char {          │  │
│  │      // Go 实现的插件逻辑                           │  │
│  │  }                                                 │  │
│  └────────────────────────────────────────────────────┘  │
└──────────────────────────────────────────────────────────┘

核心实现

主程序：

package main

import "github.com/ebitengine/purego"

func main() {
    // 1. 加载插件动态库 (纯 Go，无 CGO！)
    plugin, err := purego.Dlopen("./plugin.so", purego.RTLD_NOW)
    if err != nil {
        panic(err)
    }
    defer purego.Dlclose(plugin)

    // 2. 查找插件函数
    var processData func([]byte) []byte
    purego.RegisterLibFunc(&processData, plugin, "ProcessData")

    // 3. 直接调用！
    result := processData([]byte("hello"))
}

插件代码（用 Go 编译为 C 共享库）：

// plugin.go
package main

import "C"
import "unsafe"

//export ProcessData
func ProcessData(data *C.char, length C.int) *C.char {
    input := C.GoBytes(unsafe.Pointer(data), length)
    
    // 处理数据...
    result := string(input) + " processed"
    
    // 返回结果（注意：需要主进程释放）
    return C.CString(result)
}

func main() {}

编译：

go build -buildmode=c-shared -o plugin.so plugin.go

优缺点

对比总结

推荐方案：PureGo FFI

对于 gogpu/ui 这种 GUI 框架的插件系统，PureGo FFI 更合适：

1. API 简单：直接调用函数，无需设计复杂的 IPC 协议
2. 类型清晰：Go 插件编译为 C 库，主程序用 PureGo 调用
3. 跨平台：Windows/macOS/Linux 都支持
4. 生态兼容：可以复用现有的 C 库

gogpu/ui 插件接口设计示例

// plugin/ui_plugin.go
package main

import "C"
import "github.com/gogpu/ui/widget"

//export CreateWidget
func CreateWidget(name *C.char) unsafe.Pointer {
    w := mywidgets.New(C.GoString(name))
    return unsafe.Pointer(w)
}

//export DestroyWidget  
func DestroyWidget(ptr unsafe.Pointer) {
    widget := (*widget.Widget)(ptr)
    widget.Destroy()
}

// 主程序加载插件
type UIPlugin struct {
    lib      uintptr
    Create   func(name string) widget.Widget
    Destroy  func(w widget.Widget)
}

func LoadUIPlugin(path string) (*UIPlugin, error) {
    lib, _ := purego.Dlopen(path, purego.RTLD_NOW)
    
    var p UIPlugin
    p.lib = lib
    
    purego.RegisterLibFunc(&p.Create, lib, "CreateWidget")
    purego.RegisterLibFunc(&p.Destroy, lib, "DestroyWidget")
    
    return &p, nil
}

何时选 mmap Ring Buffer？

只有在你需要极高性能且处理大量数据流时才考虑：

• 视频/音频流处理
• 高频交易数据
• 游戏引擎的渲染管线

参考链接

• https://github.com/ebitengine/purego - 纯 Go FFI 库
• https://github.com/JupiterRider/ffi - libffi 的 PureGo 绑定
• iouring 设计文档: https://kernel.dk/iouring.pdf

讨论时间: 2026-03-07
标签: #Go #plugin #FFI #purego #mmap #IPC #gogpu