每微秒1000000000次计算

好吧，我一直在和一个朋友谈论编译器和程序优化，他建议n * 0.5比n / 2快。我说过编译器会自动进行这种优化，所以我写了一个小程序来看看n / 2和n * 0.5之间是否有区别：

部门：

#include <stdio.h>
#include <time.h>
int main(int argc, const char * argv[]) {
    int i, m;
    float n, s;
    clock_t t;
    m = 1000000000;
    t = clock();
    for(i = 0; i < m; i++) {
        n = i / 2;
    }
    s = (float)(clock() - t) / CLOCKS_PER_SEC;
    printf("n = i / 2: %d calculations took %f seconds (last calculation = %f)n", m, s, n);
    return 0;
}

乘法：

#include <stdio.h>
#include <time.h>
int main(int argc, const char * argv[]) {
    int i, m;
    float n, s;
    clock_t t;
    m = 1000000000;
    t = clock();
    for(i = 0; i < m; i++) {
        n = i * 0.5;
    }
    s = (float)(clock() - t) / CLOCKS_PER_SEC;
    printf("n = i * 0.5: %d calculations took %f seconds (last calculation = %f)n", m, s, n);
    return 0;
}

对于这两个版本，当使用clang main.c -O1编译时，我得到了0.000002s的平均值。他说时间测量肯定有问题。于是他写了一个程序：

#include <cstdio>
#include <iostream>
#include <ctime>
using namespace std;
int main()
{
    clock_t ts, te;
    double  dT;
    int i, m;
    double n, o, p, q, r, s;
    m = 1000000000;
    cout << "Independent calculations:n";
    ts = clock();
    for (i = 0; i < m; i++)
    {
        //  make it a trivial pure float calculation with no int casting to float
        n = 11.1 / 2.3;
        o = 22.2 / 2.3;
        p = 33.3 / 2.3;
        q = 44.4 / 2.3;
        r = 55.5 / 2.3;
        s = 66.6 / 2.3;
    }
    te = clock();
    dT = ((float)(te - ts)) / CLOCKS_PER_SEC;   //  make initial call to get the elapsed time to run the loop
    ts = clock();
    printf("Division: %d calculations took %f secondsn", m, dT);
    for (i = 0; i < m; i++)
    {
        //  make it a trivial pure float calculation with no int casting to float
        n = 11.1 * 0.53;
        o = 22.2 * 0.53;
        p = 33.3 * 0.53;
        q = 44.4 * 0.53;
        r = 55.5 * 0.53;
        s = 66.6 * 0.53;
    }
    te = clock();
    dT = ((float)(te - ts)) / CLOCKS_PER_SEC;   //  make initial call to get the elapsed time to run the loop
    ts = clock();
    printf("Multiplication: %d calculations took %f secondsn", m, dT);
    cout << "nDependent calculations:n";
    for (i = 0; i < m; i++)
    {
        //  make it a trivial pure float calculation with no int casting to float
        n = 11.1 / 2.3;
        o = n / 2.3;
        p = o / 2.3;
        q = p / 2.3;
        r = q / 2.3;
        s = r / 2.3;
    }

    te = clock();
    dT = ((float)(te - ts)) / CLOCKS_PER_SEC;   //  make initial call to get the elapsed time to run the loop
    ts = clock();
    printf("Division: %d calculations took %f secondsn", m, dT);
    for (i = 0; i < m; i++)
    {
        //  make it a trivial pure float calculation with no int casting to float
        n = 11.1 * 0.53;
        o = n * 0.53;
        p = o * 0.53;
        q = p * 0.53;
        r = q * 0.53;
        s = r * 0.53;
    }

    te = clock();
    dT = ((float)(te - ts)) / CLOCKS_PER_SEC;   //  make initial call to get the elapsed time to run the loop
    ts = clock();
    printf("Multiplication: %d calculations took %f secondsn", m, dT);
    return 0;
}

为此，他得到了。。。

1.869570s
1.868254s
25.674016s
3.497555s

按照这个顺序。

所以我在用clang++ main.cpp -O1编译的机器上运行了这个程序，得到了和以前类似的结果：0.000002 to 0.000011。

然而，当我在没有优化的情况下编译程序时，我在他的第一次测试中得到了与他相似的结果。所以我的问题是，任何数量的优化如何使的程序更快？