异步工作流无法实现连续顺序渲染：Core ML异步推理结合MTKView渲染的时序异常排查

看起来你在120FPS高刷场景下遇到的异步渲染时序乱序问题确实挺头疼的——毕竟高帧率下对线程同步、缓冲区管理的精度要求比60FPS高太多了。我仔细啃了你的代码和几轮更新的排查记录，咱们一步步拆解问题出在哪，以及该怎么修复：

一、核心问题拆解 #

1. 环形缓冲区的读写逻辑存在漏洞，无法严格保证FIFO顺序 #

你的RenderSemaphore里的缓冲区管理逻辑有个关键缺陷：当前writeBufferIndex是循环覆盖缓冲区位置，但getAvailableBuffer只是简单读取currentBufferIndex的内容，没有确保读写指针的环形依赖关系。举个例子：

• 假设缓冲区有3个位置，writeBufferIndex刚写完位置2，接着循环到位置0覆盖旧数据；
• 此时currentBufferIndex还在读取位置0的旧帧，这时候getAvailableBuffer拿到的就会是刚写入的新帧（timestamp更大），直接跳过了位置1的帧，导致时序断裂。

另外，你没有判断缓冲区是否已满——当writeBufferIndex追上currentBufferIndex时，新帧会直接覆盖未读取的旧帧，这也是导致重复/旧帧出现的原因。

2. draw()中无限制创建Task，导致渲染请求堆积乱序 #

MTKView在120FPS下每秒会调用draw()120次，而你每次都启动一个新Task执行renderAsync。即使有isRendering的互斥，大量Task的调度顺序也不一定和draw()的调用顺序一致（系统Task调度会有延迟），这会导致后续的渲染请求先于前面的请求执行，出现时序颠倒。

3. 全局lastTimeStamp存在线程安全问题 #

你在renderAsync里用的lastTimeStamp是一个全局变量，不在RenderSemaphore Actor的控制范围内。多个并发的Task可能同时读取/修改这个变量，导致时序判断逻辑失效——比如两个Task同时拿到不同timestamp的帧，其中一个先更新了lastTimeStamp，另一个就会错误地跳过本该渲染的帧。

4. 可能的FrameData引用类型陷阱 #

你没贴FrameData的定义，如果它是class（引用类型），那后续的setBuffers操作会覆盖缓冲区中对应位置的FrameData引用，导致之前已经被getAvailableBuffer返回的帧的内容被修改——这就是你看到lastTimeStamp和frame.texture.label!不匹配的直接原因：你拿到的帧的timestamp是旧的，但texture已经被新帧覆盖了。

二、针对性修复方案 #

1. 重构环形缓冲区的读写逻辑，严格保证FIFO #

修改RenderSemaphore的缓冲区管理，用标准的环形读写指针逻辑，确保读写操作的安全：

actor RenderSemaphore {
    private var readIndex = 0
    private var writeIndex = 0
    private var frameBuffers: [FrameData?]
    private let bufferCount: Int
    private var lastReadTimeStamp: Double = 0.0
    private var lastWriteTimeStamp: Double = 0.0
    private var isRendering = false
    // 把lastTimeStamp移到Actor内部，确保线程安全
    private var lastRenderedTimeStamp: Double = 0.0

    private var activeTaskCount = 0
    private let maxTasks = 3
    
    init(count: Int = 3) {
        bufferCount = count
        frameBuffers = Array(repeating: nil, count: count)
    }
    
    func setBuffers(surface: IOSurface, texture: MTLTexture, depth: MTLBuffer, timeStamp: Double) -> Bool {
        guard timeStamp > lastWriteTimeStamp else { return false }
        // 计算下一个写入位置，判断是否会覆盖未读取的帧
        let nextWriteIndex = (writeIndex + 1) % bufferCount
        guard nextWriteIndex != readIndex else {
            print("缓冲区已满，丢弃当前帧")
            return false
        }
        
        let frameData = FrameData(
            surface: surface,
            texture: texture,
            depthBuffer: depth,
            timeStamp: timeStamp
        )
        frameBuffers[writeIndex] = frameData
        lastWriteTimeStamp = timeStamp
        writeIndex = nextWriteIndex
        return true
    }

    func getAvailableBuffer() -> FrameData? {
        guard readIndex != writeIndex else { return nil } // 无可用帧
        guard let frame = frameBuffers[readIndex] else { return nil }
        
        // 确保帧的时序递增
        guard frame.timeStamp > lastReadTimeStamp else {
            // 跳过旧帧，移动读指针
            readIndex = (readIndex + 1) % bufferCount
            return getAvailableBuffer()
        }
        
        lastReadTimeStamp = frame.timeStamp
        let resultFrame = frame
        // 移动读指针，释放缓冲区位置
        readIndex = (readIndex + 1) % bufferCount
        return resultFrame
    }

    // 其他方法保持不变，注意把所有时序相关变量都放在Actor内部
}

2. 限制draw()中的Task创建，避免渲染请求堆积 #

不要在draw()里每次都启动新Task，而是让RenderSemaphore统一管理渲染请求的串行执行：

func draw(in view: MTKView) {
    // 只提交渲染请求，不直接启动Task
    Task {
        await renderSemaphore.processRenderRequest(view: view)
    }
}

// 在RenderSemaphore中新增方法
func processRenderRequest(view: MTKView) async {
    guard await beginRender(timeStamp: view.currentRenderPassDescriptor?.timestamp ?? 0) else {
        return
    }
    
    guard let frame = getAvailableBuffer() else {
        await endRender()
        return
    }
    
    // 确保渲染时序严格递增
    guard frame.timeStamp > lastRenderedTimeStamp else {
        print("跳过时序异常的帧: \(frame.timeStamp) <= \(lastRenderedTimeStamp)")
        await endRender()
        return
    }
    lastRenderedTimeStamp = frame.timeStamp
    
    // 执行渲染逻辑（把原renderAsync的核心代码移到这里）
    guard let commandBuffer = _commandQueue.makeCommandBuffer(),
          let renderPassDescriptor = view.currentRenderPassDescriptor,
          let renderEncoder = commandBuffer.makeRenderCommandEncoder(descriptor: renderPassDescriptor) else {
        await endRender()
        return
    }
    
    // 你的渲染编码逻辑...
    
    let success = await commitFrame(
        timeStamp: frame.timeStamp,
        commandBuffer: commandBuffer,
        drawable: view.currentDrawable!
    )
    
    await endRender()
}

3. 确保FrameData是值类型 #

把FrameData定义为struct，这样每个帧都是独立的值拷贝，后续的缓冲区覆盖不会影响已经取出的帧内容：

struct FrameData {
    let surface: IOSurface
    let texture: MTLTexture
    let depthBuffer: MTLBuffer
    let timeStamp: Double
}

4. 严格控制Core ML推理的并发数 #

在启动Core ML异步推理之前，必须通过tryEnterTask判断是否允许新任务，避免推理结果堆积：

// 启动Core ML推理的代码示例
guard await renderSemaphore.tryEnterTask() else {
    print("推理任务已满，丢弃当前帧")
    return
}

Task {
    defer {
        await renderSemaphore.exitTask()
    }
    // 执行Core ML异步推理
    let inferenceResult = try await model.predictionAsync(input: input)
    // 调用setRenderData更新缓冲区
    await setRenderData(...)
}

三、验证建议 #

修复后可以在120FPS下做两个验证：

• 打印每个渲染帧的timeStamp，确认是严格递增的；
• 观察MTKView的渲染效果，检查是否还有时序断裂、重复帧的情况。

备注：内容来源于stack exchange，提问作者timyau