相关疑难解决方法(0)

这是一段看似非常特殊的C++代码.出于某种奇怪的原因,奇迹般地对数据进行排序使得代码几乎快了六倍.

#include <algorithm>
#include <ctime>
#include <iostream>

int main()
{
    // Generate data
    const unsigned arraySize = 32768;
    int data[arraySize];

    for (unsigned c = 0; c < arraySize; ++c)
        data[c] = std::rand() % 256;

    // !!! With this, the next loop runs faster.
    std::sort(data, data + arraySize);

    // Test
    clock_t start = clock();
    long long sum = 0;

    for (unsigned i = 0; i < 100000; ++i)
    {
        // Primary loop
        for (unsigned c = 0; c < arraySize; ++c) …

在C++中,？:运算符比if()... else语句更快？它们在编译代码中有什么区别吗？

我很困惑在何处使用cmov说明以及jump在汇编中使用说明的位置？

从性能的角度来看:

• 两者有什么不同？
• 哪一个更好？

如果可能,请通过示例解释他们的不同之处.

在GCC(版本4.8.2)手册中,陈述如下:

-ftree-loop-if-convert-stores:
尝试if-convert包含内存写入的条件跳转.这种转换对于多线程程序来说可能是不安全的,因为它将条件内存写入转换为无条件内存写入.例如,

   for (i = 0; i < N; i++)
      if (cond)
        A[i] = expr;

Run Code Online (Sandbox Code Playgroud)

变成了

   for (i = 0; i < N; i++)
       A[i] = cond ? expr : A[i];

Run Code Online (Sandbox Code Playgroud)

可能产生数据竞争.

但是,我想知道使用operator?与if语句相比是否有性能提升.

• 在第一段代码中,仅在满足条件时才A[i]设置为.如果不满足,则跳过语句中的代码.expr
• 在第二个,A[i]似乎写不管条件; 条件只影响它设置的值.

通过使用operator?,我们也在做检查; 但是,在不满足条件的情况下,我们会增加一些开销.我错过了什么吗？

我正在尝试尽快将十六进制转换char为整数.

这只是一行: int x = atoi(hex.c_str);

有更快的方法吗？

在这里,我尝试了一种更加动态的方法,而且速度稍快一些.

int hextoint(char number) {
    if (number == '0') {
        return 0;
    }
    if (number == '1') {
        return 1;
    }
    if (number == '2') {
        return 2;
    }
    /*
     *  3 through 8
     */
    if (number == '9') {
        return 9;
    }
    if (number == 'a') {
        return 10;
    }
    if (number == 'b') {
        return 11;
    }
    if (number == 'c') {
        return 12;
    }
    if (number == 'd') …

我正在写一些音频代码,基本上所有东西都是微小的循环.我理解它们的分支预测失败是一个足够大的性能问题,我很难保持代码分支免费.但是到目前为止,只有这一点可以带我,这让我想知道不同种类的分支.

在c ++中,条件分支到固定目标:

int cond_fixed(bool p) {
    if (p) return 10;
    return 20;
}

并且(如果我正确理解了这个问题),无条件分支到变量目标:

struct base {
    virtual int foo() = 0;
};

struct a : public base {
    int foo() { return 10; }
};

struct b : public base {
    int foo() { return 20; }
};

int uncond_var(base* p) {
    return p->foo();
}

是否存在性能差异？在我看来,如果两种方法中的一种明显比另一种方法快,编译器只会将代码转换为匹配.

对于分支预测非常重要的情况,有关性能的详细信息对于了解有用吗？

编辑:实际操作x : 10 ? 20只是一个占位符.分支之后的实际操作至少足够复杂,以至于两者都是低效的.此外,如果我有足够的信息可以合理使用__builtin_expect,在这种情况下,分支预测将不是问题.

我理解当分支很容易预测时,使用IF语句会更好,因为分支是完全免费的.我已经了解到,如果不容易预测分支,那么CMOV会更好.但是,我不太明白这是如何实现的？

当然问题域仍然是相同的 - 我们不知道下一条指令的执行地址？因此,我不明白管道的所有方式,当CMOV执行时,如何帮助指令获取器(过去10个CPU周期)选择正确的路径并防止管道停顿？

有人可以帮我理解CMOV如何改进分支？

这就是我想要实现的目标.这很简单:

unsigned int foo1(bool cond, unsigned int num)
{
    return cond ? num : 0;
}

Assmebly:

    test    dil, dil
    mov     eax, 0
    cmovne  eax, esi
    ret

我的问题是,有更快的方法吗？以下是我想到的一些方法:

使用乘法:

unsigned int foo2(bool cond, unsigned int num)
{
    return cond * num;
}

ASSMBLY:

    movzx   eax, dil
    imul    eax, esi
    ret

使用内存访问:

unsigned int foo3(bool cond, unsigned int num)
{
    static const unsigned int masks[2] = { 0x0, 0xFFFFFFFF };
    return masks[cond] & num;
}

部件:

    movzx   edi, dil
    mov     eax, …

例如，假设一个变量x可以 x是任何 include 0。
然后我们得到如下代码：

if(x==0) {
    y = 1;
}
else {
    y = x;
}

我可以在不使用 C/C++ 生成分支的情况下执行此操作吗？

我正在尝试优化一段代码。我想尽可能地去除树枝。还有类似的判断，所以我想把它们转换成没有分支的语句，让代码尽可能高效。

我想要一个功能

int rounded_division(const int a, const int b) { 
    return round(1.0 * a/b); 
}

所以我们有,例如,

rounded_division(3, 2) // = 2
rounded_division(2, 2) // = 1
rounded_division(1, 2) // = 1
rounded_division(0, 2) // = 0
rounded_division(-1, 2) // = -1
rounded_division(-2, 2) // = -1
rounded_division(-3, -2) // = 2

或者在代码中,其中a和b是32位有符号整数:

int rounded_division(const int a, const int b) {
    return ((a < 0) ^ (b < 0)) ? ((a - b / 2) / b) : …

有没有办法计算：

/** clipped(a - b) **/
unsigned char clipped_substract(unsigned char a, unsigned char b)
{
    return a > b ? a - b : 0;
}

使用一些二进制操作而不是测试？

在这段代码中，它被写成result += runs[i] > runs[i-1];一个隐式条件语句。在 C++ 中，分支预测器是否对该语句进行预测？或者我是否必须明确使用if关键字来进行分支预测？

using namespace std; 
int progressDays(vector<int> runs) {
    if (runs.size() < 2) {return 0;}
    int result = 0;
    for (int i = 1; i < runs.size(); i++) {result += runs[i] > runs[i-1];}
    return result;
}