标签: compiler-optimization

我正在研究一种以大端格式将64位值存储到内存中的函数.我希望我能编写可在小端和大端平台上运行的可移植C99代码,并让现代x86编译器bswap自动生成指令而不需要任何内置函数或内在函数.所以我开始使用以下功能:

#include <stdint.h>

void
encode_bigend_u64(uint64_t value, void *vdest) {
    uint64_t bigend;
    uint8_t *bytes = (uint8_t*)&bigend;
    bytes[0] = value >> 56;
    bytes[1] = value >> 48;
    bytes[2] = value >> 40;
    bytes[3] = value >> 32;
    bytes[4] = value >> 24;
    bytes[5] = value >> 16;
    bytes[6] = value >> 8;
    bytes[7] = value;
    uint64_t *dest = (uint64_t*)vdest;
    *dest = bigend;
}

这适用于clang,它将此函数编译为:

bswapq  %rdi
movq    %rdi, (%rsi)
retq

但是GCC 无法检测到字节交换 …

我们有一个用于错误检查的宏,如下所示:

#define CheckCondition( x ) \
    if( x ) { \
    //okay, do nothing \
    } else { \
       CallFunctionThatThrowsException(); \
    }

通常条件必须是true,我们希望CPU分支预测总是选择这条路径,如果碰巧是false我们真的不关心错误预测 - 抛出异常和大量堆栈展开将无论如何都要花费一大笔钱.

根据CPU硬核描述,分支预测将稍微不同地处理向前跳转和向后跳转(总是执行向后跳转并且从不执​​行向前跳转),并且编译器可以通过生成将给出正确提示的代码来改进分支预测. CPU分支预测器.

海湾合作委员会似乎也likely并unlikely暗示了这一点.在Visual C++中有类似的东西吗？可以使用__assume关键字吗？

我最近在这里阅读了这个问题为什么处理排序数组比未排序数组更快？并且发现答案绝对令人着迷,在处理基于Data的分支时,它完全改变了我对编程的看法.

我目前有一个用C编写的相当基本但功能完备的解释型Intel 8080仿真器,操作的核心是一个256长的交换机案例表,用于处理每个操作码.我最初的想法是,这显然是最快的工作方法,因为操作码编码在整个8080指令集中并不一致,并且解码会增加很多复杂性,不一致性和一次性情况.一个装有预处理器宏的开关盒表非常整洁,易于维护.

不幸的是,在阅读上述帖子之后,我发现我的电脑中的分支预测器绝对没有办法预测开关盒的跳跃.因此,每次切换案例时,必须完全擦除管道,导致几个周期延迟,否则应该是一个非常快速的程序(在我的代码中甚至没有多次乘法).

我相信大多数人都在想"哦,这里的解决方案很简单,转向动态重新编译".是的,这看起来似乎会削减大部分开关盒并大大提高速度.不幸的是,我的主要兴趣是模拟旧的8位和16位时代控制台(这里的英特尔8080只是一个例子,因为它是我最简单的模拟代码),其中保持精确指令的周期和时序对于视频和声音很重要必须根据这些确切的时间进行处理.

当处理这种级别的准确性时,性能成为一个问题,即使对于旧的控制台(例如,查看bSnes).在处理具有长管道的处理器时,是否有任何追索权或者这仅仅是事实？

我们都知道,根据JLS7第4.12.5节,每个实例变量都使用默认值进行初始化.例如(1):

public class Test {
    private Integer a;  // == null
    private int b;      // == 0
    private boolean c;  // == false
}

但我一直认为,这样的类实现(2):

public class Test {
    private Integer a = null;
    private int b = 0;
    private boolean c = false;
}

绝对等于例子(1).我预计,复杂的Java编译器会发现(2)中的所有这些初始化值都是冗余的并且省略了它们.

但突然之间,这两个类我们有两个不同的字节码.

例如(1):

   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   return

例如(2):

   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   aload_0
   5:   aconst_null
   6:   putfield    #2; //Field a:Ljava/lang/Integer;
   9:   aload_0
   10:  iconst_0 …

希望这对StackOverflow的问题不太专业:如果是,可以在其他地方迁移,请告诉我......

很久以前,我写了一篇本科毕业论文提出了C++和相关语言的各种devirtualization技术,一般是根据代码路径(有点像模板)预编译专业化的想法,但与检查,以选择正确的专长是在情况下,运行时选择它们不能在编译时选择(因为模板必须是).

(非常)基本的想法类似于以下内容...假设你有一个类C如下的类:

class C : public SomeInterface
{
public:
    C(Foo * f) : _f(f) { }

    virtual void quack()
    {
        _f->bark();
    }

    virtual void moo()
    {
        quack(); // a virtual call on this because quack() might be overloaded
    }

    // lots more virtual functions that call virtual functions on *_f or this

private:
    Foo * const _f; // technically doesn't have to be const explicitly
                    // as long as it can be proven not be modified
}; …

因为我可以看到它的出现:这是一个不同的问题,而GHC可以实现哪些优化可靠？因为我不是要求最可靠的优化,只是最聪明/最强大的优化.

我特别希望GHC能够对性能产生严重影响的非直观优化,并展示与惰性评估或纯度相关的编译器优化的强大功能.并直接解释如何实现它们.

最好的答案将是:

• 优化的解释以及为什么它如此聪明或强大
• 为何优化可以提高性能
• GHC如何识别何时可以使用此优化
• 优化实际上将代码转换为什么
• 为什么这种优化需要惰性评估或纯度

关于GCC手册,

-foptimize同胞通话

优化兄弟和尾部递归调用.

例如,我知道尾递归调用

int sum(int n){return n == 1？1:n + sum(n-1); }

然而,兄弟姐妹的意思是什么？

最近我遇到了一个关于字符串连接的问题。该基准对其进行了总结：

@OutputTimeUnit(TimeUnit.NANOSECONDS)
public class BrokenConcatenationBenchmark {

  @Benchmark
  public String slow(Data data) {
    final Class<? extends Data> clazz = data.clazz;
    return "class " + clazz.getName();
  }

  @Benchmark
  public String fast(Data data) {
    final Class<? extends Data> clazz = data.clazz;
    final String clazzName = clazz.getName();
    return "class " + clazzName;
  }

  @State(Scope.Thread)
  public static class Data {
    final Class<? extends Data> clazz = getClass();

    @Setup
    public void setup() {
      //explicitly load name via native method Class.getName0()
      clazz.getName();
    }
  }
}

在 JDK …

我决定要对特定函数进行基准测试,所以我天真地编写如下代码:

#include <ctime>
#include <iostream>

int SlowCalculation(int input) { ... }

int main() {
    std::cout << "Benchmark running..." << std::endl;
    std::clock_t start = std::clock();
    int answer = SlowCalculation(42);
    std::clock_t stop = std::clock();
    double delta = (stop - start) * 1.0 / CLOCKS_PER_SEC;
    std::cout << "Benchmark took " << delta << " seconds, and the answer was "
              << answer << '.' << std::endl;
    return 0;
}

一位同事指出,我应该声明start和stop变量volatile以避免代码重新排序.他建议优化器可以,例如,有效地重新排序代码,如下所示:

    std::clock_t start = std::clock();
    std::clock_t stop = …

处理器中的分区需要很长时间,所以我想问如何以最快的方式检查数字是否可以被其他数字整除,在我的情况下我需要检查数字是否可被15整除.

此外,我一直在浏览网页,并找到有趣的方法来检查数字是否可以被某些数字整除,但我正在寻找快速选项.

注意:由于分工需要很长时间,我正在寻找没有/和的答案%.