能否在Rust中实现GOTO式直接跳转以优化HVM运行时？

我正在优化用Rust编写的并行函数运行时HVM，它通过多线程实现，每个线程都会在主工作循环中持续取出并执行任务。最初的实现用枚举来控制循环内的分支逻辑：

// 模式枚举
enum Mode {
  Visiting, // 遍历节点
  Reducing, // 应用重写规则
  Fetching, // 取出本地任务
  Stealing, // 窃取全局任务
}

// 主循环
loop {
  match mode {
    Mode::Visiting => { ... 执行对应逻辑 ... }
    Mode::Reducing => { ... 执行对应逻辑 ... }
    Mode::Fetching => { ... 执行对应逻辑 ... }
    Mode::Stealing => { ... 执行对应逻辑 ... }
  }
}

// 切换模式的方式：
mode = Mode::Visiting;
continue 'main;

我原本以为Rust编译器会把这段代码优化成goto跳转，但实际并没有。后来我把枚举换成了两个布尔变量，调整后的循环如下：

// 用两个布尔变量表示模式
let mut a: bool;
let mut b: bool;

// 主循环
loop {
  if a {
    if b {
      ... 执行对应逻辑 ...
    } else {
      ... 执行对应逻辑 ...
    }
  } else {
    if b {
      ... 执行对应逻辑 ...
    } else {
      ... 执行对应逻辑 ...
    }
  }
}

// 切换模式的方式：
a = true;
b = true;
continue 'main;

没想到这个小改动让HVM的整体性能提升了约15%，但这还达不到我的预期。在C语言里，我可以直接用标签和GOTO跳转，所以我想知道：能不能修改Rust代码，让编译器优化出预期的跳转代码？比如类似下面的实现：

// 主循环:
loop {
  'visiting { ... 执行对应逻辑 ... }
  'reducing { ... 执行对应逻辑 ... }
  'fetching { ... 执行对应逻辑 ... }
  'stealing { ... 执行对应逻辑 ... }
}

// 切换模式的方式:
goto 'visiting

可行的实现方案 #

Rust虽然没有原生的goto关键字，但可以通过带标签的代码块+break语句模拟等价的跳转逻辑，同时能引导编译器生成高效的直接跳转指令，避免分支判断的开销。具体写法如下：

// 主循环
loop {
    'visiting: {
        // ... 执行Visiting阶段的逻辑 ...
        // 直接跳转到reducing阶段
        break 'reducing;
    }
    'reducing: {
        // ... 执行Reducing阶段的逻辑 ...
        // 直接跳转到fetching阶段
        break 'fetching;
    }
    'fetching: {
        // ... 执行Fetching阶段的逻辑 ...
        // 直接跳转到stealing阶段
        break 'stealing;
    }
    'stealing: {
        // ... 执行Stealing阶段的逻辑 ...
        // 跳回visiting阶段
        break 'visiting;
    }
}

原理说明 #

这种写法利用了Rust的标签块特性：每个阶段逻辑被包裹在带标签的代码块中，通过break '标签名可以直接跳出当前代码块并跳转到对应标签块的起始位置。相比枚举匹配或布尔嵌套判断，这种结构的跳转意图更明确，编译器能更容易识别并生成类似C语言goto的直接跳转机器码，减少分支预测失败带来的性能损耗。

另外，也可以尝试用函数指针来实现跳转，但标签块的方式更直观，符合Rust的安全规范，且性能表现更接近原生goto的效果。

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