Question

考虑下面的C ++代码：

class IFoo {
 public:
  virtual void Bar() const = 0;
};

template <typename Derived>
class AbstractFoo : public IFoo {
 public:
  void Bar() const override {
    int i = 0;
    auto derived = static_cast<const Derived *>(this);
    while (derived->ShouldBar(i++)) {
      derived->DoBar();
    }
  }
};

class FooImpl : public AbstractFoo<FooImpl> {
 private:
  bool ShouldBar(int i) const {
    return i < 10;
  }

  void DoBar() const {
    std::cout << "Bar!" << std::endl;
  }

  friend class AbstractFoo<FooImpl>;
};

int main() {
  std::unique_ptr<IFoo> foo(new FooImpl());
  foo->Bar();
}

这当然是curiously recurring template pattern稍微扭曲：虚拟方法Bar通过界面IFoo进行多态调度后，调用ShouldBar和DoBar保持静态，甚至可以内联。这是以另一种方式实现的，（AbstractFoo是非泛型的，ShouldBar和DoBar私有虚方法），每次迭代都会有两个虚函数调用

这种优化机会的情况很重要，包括迭代方案，例如巨大状态空间的depth-first search和saturation。在这些算法的某些方面，具体实现必须选择继续搜索的方向，是否将状态添加到结果集等。多态实现，这些可能导致对相对微小的函数的数百万次虚拟调用（其中一些甚至可能是空的！），其性能损失甚至可以通过分析来衡量。（请记住，这些迭代算法通常不会执行I / O，这与上面的玩具示例相反。）

在没有CRTP的语言中，唯一的替代解决方案是复制＆＃34;骨架＆＃34;迭代方案。例如，在C＃中，这并不太痛苦，因为我们有部分方法：

interface IFoo {
  void Bar();
}

// This is copy-pasted for every IFoo implementation.
partial class FooImpl : IFoo {
  void Bar() {
    int i = 0;
    bool shouldBar = false;
    ShouldBar(i++, out shouldBar);
    while (shouldBar) {
      DoBar();
      ShouldBar(i++, out shouldBar);
    }
  }

  partial void ShouldBar(int i, out bool result);

  partial void DoBar();
}

partial class FooImpl {
  partial void ShouldBar(int i, our bool result) {
    result = i < 10;
  }

  partial void DoBar() {
    Console.WriteLine("Bar!");
  }
}

正如您所看到的，仍然存在一些尴尬，因为部分方法必须返回void，以及抽象代码＃34;类需要重复。

是否有任何语言/运行时环境可以在简单的虚拟保护方法上执行此优化？

我认为问题归结为虚拟公共方法不应该为每个实现生成机器代码，而是为每个具体类< / em>的。考虑到一个简单的vtable，FooImpl的vtable中的插槽不应该在AbstractFoo#Bar的插槽中保留IFoo#Bar，而应该包含非虚拟/内联呼叫的专用FooImpl#Bar由JIT生成的ShouldBar和DoBar。

是否存在能够执行此优化的环境，或至少在此方向上的一些研究？

Answer 1

不要使用JIT，请使用CPU的分支预测器。任何体面的CPU都会尝试缓存每个间接分支指令的目标，因此正确预测的间接分支的成本与条件分支相同，通常为零。

优化此模式与通常的优化过程没有什么不同。您的探查器应将特定的间接分支指令标记为瓶颈。通过将每个慢速指令分成几个更易于预测的指令进行优化，例如

if ( likely_to_be_FooImpl ) {
    foo->Bar();
} else {
    foo->Bar();
}

防止编译器消除明显多余的分支留作练习;）。或者，理想情况下，一个分支根本不需要间接调度：

if ( certain_to_be_FooImpl ) {
    static_cast< FooImpl * >( foo )->fooImpl::Bar();
} else {
    foo->Bar();
}

在任何情况下，JIT都需要查找本地程序状态和分支目标之间的相关性。 JIT可能会注意到分支往往会转到某个特定目的地，但CPU已经在硬件中优化了这种情况。相反，只要分支数量不超过预测变量的内存限制，就会预测出虚假的间接分支。

内联私有和受保护的虚函数调用

1 个答案: