相关疑难解决方法(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) …

我正在用Java编写一些代码,在某些时候,程序的流程是由两个int变量"a"和"b"是否为非零来确定的(注意:a和b从不是负数,并且从不在整数溢出范围内).

我可以评估它

if (a != 0 && b != 0) { /* Some code */ }

或者

if (a*b != 0) { /* Some code */ }

因为我希望每段代码运行数百万次,所以我想知道哪一段会更快.我通过在一个巨大的随机生成的数组上进行比较来做实验,我也很想知道数组的稀疏性(数据的分数= 0)会如何影响结果:

long time;
final int len = 50000000;
int arbitrary = 0;
int[][] nums = new int[2][len];

for (double fraction = 0 ; fraction <= 0.9 ; fraction += 0.0078125) {
    for(int i = 0 ; i < 2 ; i++) {
        for(int j = 0 ; j < len ; j++) …

我正在读Fedor Pikus 的这本书，他有一些非常非常有趣的例子，对我来说是一个惊喜。
特别是这个基准测试吸引了我，唯一的区别是在其中一个我们使用 || 在 if 和另一个中我们使用 |。

void BM_misspredict(benchmark::State& state)
{

    std::srand(1);
    const unsigned int N = 10000;;
    std::vector<unsigned long> v1(N), v2(N);
    std::vector<int> c1(N), c2(N);

    for (int i = 0; i < N; ++i) 
    {
        v1[i] = rand();
        v2[i] = rand();
        c1[i] = rand() & 0x1;
        c2[i] = !c1[i];
    }

    unsigned long* p1 = v1.data();
    unsigned long* p2 = v2.data();
    int* b1 = c1.data();
    int* b2 = c2.data();

    for (auto _ : state)
    {
        unsigned long a1 …

Java有两种检查两个布尔值是否不同的方法。您可以将它们与!=或与^（xor）进行比较。当然，这两个运算符在所有情况下都会产生相同的结果。尽管如此，将两者都包括在内还是很有道理的，例如，在“异或”与“不相等”之间有什么区别？。对于开发人员而言，根据上下文选择一个相对于另一个更有意义-有时“恰好是这些布尔值之一”读起来更好，而有时“这两个布尔值不同”则更好地传达了意图。因此，也许使用哪个应该是口味和风格的问题。

令我惊讶的是javac并没有完全一样对待它们！考虑此类：

class Test {
  public boolean xor(boolean p, boolean q) {
    return p ^ q;
  }
  public boolean inequal(boolean p, boolean q) {
    return p != q;
  }
}

显然，这两种方法具有相同的可见行为。但是它们具有不同的字节码：

$ javap -c Test
Compiled from "Test.java"
class Test {
  Test();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public boolean xor(boolean, boolean);
    Code:
       0: iload_1
       1: iload_2
       2: ixor
       3: ireturn

  public boolean inequal(boolean, boolean);
    Code:
       0: iload_1
       1: …

我们都知道逻辑表达式中的短路,即何时

if ( False AND myFunc(a) ) then
...

不打扰执行myFunc()因为if条件不可能是真的.

我很好奇是否有相应的日常代数方程式,比如说

result = C*x/y + z

如果C=0评估第一学期没有意义.它将没有多大关系的表现,明智的,如果x和y是标量,但如果我们假装自己是大矩阵和操作是昂贵的(并且适用于矩阵),那么这无疑会有所作为.当然,你可以通过if C!=0发表声明来避免这种极端情况.

所以我的问题是这个功能是否存在以及它是否有用.我不是一个程序员,所以它可能以某种名义,我没有遇到过; 如果是这样请赐教:)

为了在运行 Windows 7 pro 的英特尔核心 2 上执行一些 cmov 指令，我编写了下面的代码。它所做的只是从控制台获取一个字符串作为输入，应用一些移位操作来生成一个随机种子，然后将该种子传递给 srand，以生成一个小的伪随机数数组。然后评估伪随机数是否满足谓词函数（更任意的 bitshuffling ），并输出“*”或“_”。实验的目的是生成 cmov 指令，但是正如您在下面的反汇编中看到的那样，没有。

关于如何更改代码或 cflags 以便生成它们的任何提示？

#include <iostream>
#include <algorithm>
#include <string>
#include <cstdlib>

bool blackBoxPredicate( const unsigned int& ubref ) {
   return ((ubref << 6) ^ (ubref >> 2) ^ (~ubref << 2)) % 15 == 0;
}

int main() {
   const unsigned int NUM_RINTS = 32;
   unsigned int randomSeed = 1;
   unsigned int popCount = 0;
   unsigned int * rintArray = new unsigned int[NUM_RINTS];
   std::string userString;

   std::cout …

考虑一种情况，其中方法的主要逻辑仅应在特定条件下实际运行。据我所知，有两种基本方法可以实现此目的：

如果逆条件为真，则只需返回：

public void aMethod(){
    if(!aBoolean) return;
    // rest of method code goes here
}

要么

如果原始条件为真，则继续执行：

public void aMethod(){
    if(aBoolean){
        // rest of method code goes here
    }
}

现在，我猜想这些实现中哪个更有效取决于其编写的语言和/或由编译器/解释器/ VM（取决于语言）实现if语句和return语句以及可能的方法调用的方式。所以我的问题的第一部分是，这是真的吗？

我的问题的第二部分是，如果第一部分的答案是“是”，那么上述哪种代码流模式在C＃/。NET 4.6.x中更有效？

编辑： 参考Dark Falcon的评论：这个问题的目的并不是要解决性能问题或优化我编写的任何实际代码，我只是对编译器如何实现每个模式的每个部分感到好奇，例如参数的缘故，如果它是在没有编译器优化的情况下逐字编译的，那会更有效吗？