协程与 async 降级

async fn fetch_and_sum(id: u64) -> u64 {
    let a = fetch(id).await;          // 挂起点 1
    let b = fetch(a).await;           // 挂起点 2
    a + b
}

// 有栈协程的上下文切换 (示意, x86-64)
typedef struct { void *rsp, *rbp, *rip; } context_t;

void switch_context(context_t *from, context_t *to) {
    __asm__ volatile(
        "movq %%rsp, %0\n"      // 保存当前栈指针
        "movq %%rbp, %1\n"
        "movq %2, %%rsp\n"      // 切换到目标栈
        "movq %3, %%rbp\n"
        : "=m"(from->rsp), "=m"(from->rbp)
        : "m"(to->rsp), "m"(to->rbp));
}

// 变换前
async fn fetch_and_sum(id: u64) -> u64 {
    let a = fetch(id).await;          // 挂起点 1
    let b = fetch(a).await;           // 挂起点 2
    a + b
}

// 变换后 (概念示意)
enum State { Start, AfterFirst, Done }

struct FetchFrame {
    state: State,
    id: u64,          // 参数: 整个生命周期都要用
    a: u64,           // 跨挂起点 1 活跃
    b: u64,           // 跨挂起点 2 活跃
}

impl FetchFrame {
    fn resume(&mut self, waker: &Waker) -> Poll<u64> {
        loop {
            match self.state {
                State::Start => {
                    match fetch(self.id).poll(waker) {
                        Poll::Pending => return Poll::Pending,
                        Poll::Ready(v) => { self.a = v; self.state = State::AfterFirst; }
                    }
                }
                State::AfterFirst => {
                    match fetch(self.a).poll(waker) {
                        Poll::Pending => return Poll::Pending,
                        Poll::Ready(v) => { self.b = v; self.state = State::Done; }
                    }
                }
                State::Done => return Poll::Ready(self.a + self.b),
            }
        }
    }
}

def lower_to_state_machine(func, suspend_points):
    """按挂起点切分函数体，生成状态列表"""
    states = []
    segment = []
    for stmt in func.body:
        segment.append(stmt)
        if stmt in suspend_points:
            states.append(segment)
            segment = []
    if segment:
        states.append(segment)

    # 跨段活跃的变量必须提升到帧
    frame_vars = set()
    for i, seg in enumerate(states[:-1]):
        live_across = liveness_at_exit(seg) & used_in_later(states[i + 1:])
        frame_vars |= live_across
    return states, frame_vars

def compute_frame_layout(cfg, suspend_points):
    """逐挂起点计算跨点活跃变量，求并集得到帧布局"""
    frame = {}
    offset = 0
    for sp in suspend_points:
        live_in = set()
        live_out = set()
        for var in cfg.variables:
            def_sites = cfg.defs[var]
            use_sites = cfg.uses[var]
            if any(d < sp for d in def_sites) and any(u > sp for u in use_sites):
                live_in.add(var)          # 在 sp 之前定义、之后使用
            if any(d > sp for d in def_sites) and any(u > sp for u in use_sites):
                live_out.add(var)
        for var in live_in | live_out:
            if var not in frame:
                size = cfg.type_size(var)
                frame[var] = (offset, size)
                offset += size
    return frame, offset

// Rust: Future 是惰性的, 调用 async fn 不执行任何代码, 只构造帧
let fut = fetch_and_sum(42);      // 此时没有分配, 帧在栈上
fut.await;                        // 首次 poll 才开始执行

// 需要把 Future 放进堆 (如 spawn 到执行器) 时显式 Box::pin
let handle = tokio::spawn(async move { fetch_and_sum(42).await });
// spawn 内部做 Box::pin, 帧被移到堆上, 地址固定

// 自引用帧: 指针指向帧内字段, 帧移动则悬空
struct SelfRefFrame {
    buf: [u8; 64],
    cursor: *const u8,      // 可能指向 buf
}
// 所以需要 Pin<&mut SelfRefFrame> 来禁止移动

// C++20: 为协程类重载 operator new, 用内存池避免每次堆分配
struct Task {
    struct promise_type {
        void* operator new(std::size_t sz) { return frame_pool.allocate(sz); }
        void operator delete(void* p, std::size_t sz) { frame_pool.deallocate(p, sz); }
        Task get_return_object() { return {}; }
        std::suspend_never initial_suspend() noexcept { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() {}
    };
};

def scan_coroutine_stack(g, stack_map):
    """有栈协程: 按栈映射精确扫描栈上的引用"""
    refs = []
    for frame in g.stack_frames:
        slots = stack_map[frame.pc]        # 该 PC 处的栈映射
        for offset in slots.pointer_offsets:
            addr = frame.sp + offset
            refs.append(read_pointer(addr))  # 精确取引用, 不误判整数
    return refs

// 坑 1: 递归 async -> 无限大的类型, 编译报错
async fn recurse(n: u32) -> u32 {
    if n == 0 { 0 } else { recurse(n - 1).await + 1 }
}
// error: recursive async fn ... recursive type has infinite size
// 解决: 用 Box::pin 把帧变成间接的堆指针
fn recurse(n: u32) -> Pin<Box<dyn Future<Output = u32> + Send>> {
    Box::pin(async move {
        if n == 0 { 0 } else { recurse(n - 1).await + 1 }
    })
}

// 坑 4: 跨 await 持有非 Send 值, 导致整个 Future 不 Send
async fn bad() {
    let rc = std::rc::Rc::new(1);
    something().await;      // rc 跨过 await, Future 不再是 Send
    println!("{}", rc);
}
// 解决: 缩小 rc 的作用域, 让它在 await 之前 drop