Lua抢占式多任务与嵌套协程：实现透明调度器的问题

我正在为运行Lua的虚拟机编写一个对用户透明的调度器（无需用户手动调用coroutine.yield），同时允许用户自行创建协程。核心需求是让协程能yield到栈上非直接父级的协程，且只能使用纯Lua库（因为运行在虚拟机上）。

当前简化实现代码：

-- 仅系统函数可访问，用户函数加载时会被赋予独立环境
local proc = nil

function syscall()
  -- 期望始终yield到栈底的协程（proc）
  coroutine.yield("SYS")
end

function user_co()
  while true do
    syscall() -- 期望yield到proc而非my_co
    -- 期望yield到栈顶的协程（my_co）
    coroutine.yield("USR") -- 期望yield到my_co而非proc
  end
end

function user_process()
  local my_co = coroutine.create(user_co)
  while coroutine.status(my_co) ~= "dead" do
    local _,ret = coroutine.resume(my_co)
    print("user_process: " .. ret)
  end
end

proc = coroutine.create(user_process)

while coroutine.status(proc) ~= "dead" do
  local _,ret = coroutine.resume(proc)
  print("scheduler: " .. ret)
end

当前输出会重复打印user_process: SYS和user_process: USR，不符合预期——需要syscall()的yield直接到调度器（proc），而用户自己的coroutine.yield到直接父协程（my_co）。目前使用Lua 5.3，可切换到5.4。

目前想到的方案是包装协程函数，在yield/resume时插入标签参数，隐式跳转直到目标协程，但希望有更简洁的替代方案。

Lua原生协程仅支持yield到直接父级，因此必须通过包装协程的resume和yield，维护协程的层级关系，实现跨层级yield的转发。以下是可落地的实现方案：

核心实现代码 #

-- 协程管理模块，仅系统函数可访问
local CoroMgr = {
  root = nil, -- 栈底的调度器协程
  current = nil, -- 当前运行的协程
}

-- 包装coroutine.create，绑定父协程与标记
function CoroMgr.create(fn, is_user)
  local co = coroutine.create(function(...)
    CoroMgr.current = co
    local ret = {fn(...)}
    CoroMgr.current = co.parent
    return table.unpack(ret)
  end)
  co.parent = CoroMgr.current
  co.is_user = is_user ~= nil and is_user or false
  return co
end

-- 系统调用专用yield，直接跳转到root协程
function syscall()
  local current = CoroMgr.current
  local yield_val = "SYS"
  -- 逐层转发yield请求，直到到达root协程
  while current ~= CoroMgr.root do
    current = current.parent
    yield_val = {type = "forward", target = CoroMgr.root, val = yield_val}
  end
  return coroutine.yield(yield_val)
end

-- 包装coroutine.resume，处理转发标记
function CoroMgr.resume(co, ...)
  local prev = CoroMgr.current
  CoroMgr.current = co
  local ret = {coroutine.resume(co, ...)}
  CoroMgr.current = prev

  -- 处理跨层级转发请求
  if #ret > 1 and type(ret[2]) == "table" and ret[2].type == "forward" then
    if CoroMgr.current ~= ret[2].target then
      -- 未到达目标，继续向上转发
      return CoroMgr.resume(CoroMgr.current, table.unpack(ret))
    else
      -- 到达目标协程，返回实际yield值
      return ret[1], ret[2].val
    end
  end
  return table.unpack(ret)
end

-- 用户协程逻辑（无需修改）
function user_co()
  while true do
    syscall() -- 现在直接yield到proc
    coroutine.yield("USR") -- 仅yield到直接父协程my_co
  end
end

-- 用户进程逻辑（仅替换create/resume为包装后的方法）
function user_process()
  local my_co = CoroMgr.create(user_co, true)
  while coroutine.status(my_co) ~= "dead" do
    local _, ret = CoroMgr.resume(my_co)
    print("user_process: " .. ret)
  end
end

-- 初始化调度器根协程
CoroMgr.root = CoroMgr.create(user_process)

-- 调度主循环
while coroutine.status(CoroMgr.root) ~= "dead" do
  local _, ret = CoroMgr.resume(CoroMgr.root)
  print("scheduler: " .. ret)
end

效果说明 #

运行后会交替打印：

scheduler: SYS
user_process: USR

完全符合需求：syscall()的yield直接到达调度器，用户自定义的yield仅返回给直接父协程。

补充说明 #

1. 该方案本质是对标签转发机制的封装，对用户代码透明——用户只需使用包装后的create和resume，无需修改自身yield逻辑。
2. Lua 5.4新增的协程API（如coroutine.isyieldable()）不影响核心逻辑，方案在5.3和5.4版本均适用。
3. 若虚拟机限制修改原生coroutine库，可将包装后的函数作为用户环境的coroutine表，替换原生库即可。

内容的提问来源于stack exchange，提问作者RRKS101_1 TF2