相关疑难解决方法(0)

有没有办法使用C或汇编程序甚至C#来准确衡量执行ADD指令所需的时间？

从我迄今为止所做的研究中我了解到,MIPS高度依赖于正在运行的应用程序或语言.

但是,任何人都可以给我一个MIPS中2.5 Ghz计算机的最佳猜测吗？或任何其他数量的Ghz？

C++,如果这有帮助.

我没有老师,我可以提出有关效率的问题,所以我会在这里问一下.

如果我只想要快速工作代码,不注意ram使用,只有cpu:

我假设检查'if'一次比写一次变量更快.但比例是多少？什么时候值得总是检查变量是否已经是我要设置的值？

例如:

//ex. 1
int a = 5;
while (true) {
    a = 5;
}

//ex. 2
int a = 5;
while (true) {
    if (a != 5) a = 5;
}

//ex. 3
int a = 6;
while (true) {
    if (a != 5) a = 5;
    a = 6;
}

我想是前.2将比ex更快地工作.1因为'a'始终保持在'5'.在这种情况下,"if"通过不每次都向'a'写入新值来加速该过程.但是,如果'a'经常变化,就像在ex.3,然后检查是否(a!= 5)是不必要的并且减慢过程.因此,如果变量在大多数时间保持不变,那么这种检查是值得的; 如果变量大部分时间都在变化,那就不值得了.但这个比例在哪里？也许写一个变量需要花费1000倍于检查它的时间？或者写作几乎与检查时间相同？我不是要求一个确切的答案,我总是想知道什么是我的代码最好的.

我正在C中实现一个数学库，该数学库大量使用乘法。最初，我所有的乘法都是使用进行的uint16_t。最近，我将其中的许多更改为，uint32_t然后发现我的代码运行时间几乎翻了一番。正如我在Intel x64处理器中所认为的那样，我感到困惑，32位和16位乘法需要相同的时钟周期。我写了诊断代码，请在下面找到

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <time.h>
#include "cpucycles.c"

#define REPEAT 10000
#define OUT_REPEAT 100000

void main(){

    uint16_t a_16[REPEAT], b_16[REPEAT], c_16[REPEAT];
    uint32_t a_32[REPEAT], b_32[REPEAT], c_32[REPEAT];
    int32_t i,j;
    uint64_t clock1, clock2, CLOCK16, CLOCK32;
    uint64_t acc=0;
    time_t t;

    srand((unsigned) time(&t));

    clock1=clock2=CLOCK16=CLOCK32=0;

    for(j=0;j<OUT_REPEAT;j++){


        for(i=0;i<REPEAT;i++){

            a_16[i]=rand()& ( (1<<13) -1); //need 13-bit integers only
            b_16[i]=rand()& ( (1<<13) -1);

            a_32[i]=rand()&( (1<<19) -1);
            b_32[i]=rand()&( (1<<19) -1); //need 19-bit integers only
        }

        clock1=cpucycles();
        for(i=0;i<REPEAT;i++){
            c_16[i]=a_16[i]*b_16[i];
        }
        clock2=cpucycles();
        CLOCK16=CLOCK16+(clock2-clock1);    

        clock1=cpucycles();
        for(i=0;i<REPEAT;i++){
            c_32[i]=a_32[i]*b_32[i]; …

我编写了一个计时函数，记录了函数的运行时间，并计算了多次运行的均值和标准差。我惊讶地发现即使是看似简单的任务（例如加两个双打）也有很高的标准偏差。我分析了python中的数据（请参见图）。C ++输出是19.6171 ns +/- 21.9653ns (82799807 runs)使用以下命令编译的：

gcc version 8.3.0 (Debian 8.3.0-19)
/usr/bin/c++ -O3 -DNDEBUG -std=gnu++17

整个测试是在我的个人计算机上完成的，该计算机不是空闲的而是运行DE，浏览器，IDE和其他进程。测试期间有可用的RAM。我的带有HT的双核CPU空闲率低于10％。
在这种情况下，是否会出现从20 ns的平均值到50 µs的峰值？

运行时间图
这是的内容std::vector<double> run_times。我没有看到任何图案。

运行时间的直方图
注意log y轴（此bin中的样本数）。

定时

gcc version 8.3.0 (Debian 8.3.0-19)
/usr/bin/c++ -O3 -DNDEBUG -std=gnu++17

计时文件

#include <cstdint>
#include <ostream>
#include <cmath>
#include <algorithm>
#include <vector>
#include <chrono>
#include <numeric>
#include <fstream>


struct TimingResults{
    // all time results are in nanoseconds
    double mean;
    double standard_deviation;
    uint64_t number_of_runs;
};


std::ostream& operator<<(std::ostream& os, const TimingResults& results);


template …

当 8 位指令和 64 位 x64/Amd64 处理器上的 64 位指令除了位宽之外相似/相同时，这些指令之间是否存在执行时序差异？有没有办法找到执行这两个微小汇编函数的真实处理器时序？

-谢谢。

; 64 bit instructions
add64:
     mov  $0x1, %rax
     add  $0x2, %rax
     ret

; 8 bit instructions
add8:
     mov  $0x1, %al
     add  $0x2, %al
     ret

我正在发现 numba 的 cuda 扩展，并查看了 CUDA 上矩阵乘法的示例实现。代码位于numba 的网站上。

然后我用我认为不太理想的实现对其进行了基准测试：numpy 的点函数，用于将两个 1024x1024 矩阵相乘（使用 生成randn(1024,1024)）

结果：

\n
• CUDA 每次乘法 40 毫秒，
\n
• numpy 每次乘法 5 毫秒。
\n

如果 numpy 的算法是朴素矩阵乘法，那么它应该需要 1024^3 ~ 1e9 乘法和加法。这是每 5ms/1e9 = 5 皮秒一次操作的平均吞吐量。我的 CPU 运行频率约为 3.4 GHz，因此每个周期需要 300 皮秒。

所以我的问题是：numpy 的矩阵乘法如何比普通矩阵乘法快 60 倍？

我听说过 Strassen 的算法，其复杂度约为 N^2.8，因此每次乘法和加法需要 20 皮秒。仍然比 CPU 快 30 倍。

编辑：

\n
1. cuda方法的定义
\n

from numba import cuda, float32\n\nTPB = 16\n\n@cuda.jit()\ndef …

英特尔内在函数指南列出的吞吐量是每个线程还是每个核心？

我的教科书（计算机系统：程序员的观点）指出，当一系列操作必须严格按顺序执行时，就会遇到延迟界限，而吞吐量界限则表征​​处理器功能单元的原始计算能力。

课本5.5、5.6题介绍了这两种可能的多项式计算循环结构

double result = a[0];
double xpwr = x;
for (int i = 1; i <= degree; i++) {
    result += a[i] * xpwr;
    xpwr = x * xpwr;
}

和

double result = a[degree];
double xpwr = x;
for (int i = degree - 1; i >= 0; i--) {
    result = a[i] + x * result;
}

假设循环在具有以下执行单元的微体系结构上执行：

• 一个浮点加法器。它的延迟为 3 个周期，并且是完全流水线化的。
• 两个浮点乘法器。每个的延迟是 5 个周期，并且都是完全流水线化的。
• 四个整数 ALU，每个都有一个周期的延迟。

为这个问题给出的浮点乘法和加法的延迟界限分别是 5.0 和 3.0。根据答案键，第一个循环的总循环延迟是每个元素 5.0 个周期，第二个是每个元素 8.0 个周期。我不明白为什么第一个循环不是 8.0。

似乎 a[i] …

抱歉，我一直不明白这里的规则。我已经删除了所有重复的帖子。这是第一个相关问题。\n请不要将此帖子标记为我另一篇帖子的重复（执行次数减少 3 倍，但执行效率几乎不变。在 C 中），即使代码有些相似，他们提出了截然不同的问题。这也是我同一天发现的两个问题。类似的帖子因“误判”而被重复，然后被关闭。可能是我没有把这个问题说清楚。我真的很希望得到答案，所以我重新发布了它。希望大家能够看清问题，非常感谢！

在下面的C代码中，我在第一次测试时间的循环中添加了一个“if”语句，执行时间完全相同。从理论上讲，它应该更慢。尽管分支预测可以使它们的性能几乎相同，但它实际上变得更快。这是什么原理呢？我尝试使用clang和gcc编译器分别在Mac和Linux环境中运行，并尝试了各种优化级别。为了防止缓存受到影响，我让速度较快的先执行，但有冗余代码的循环执行得更快。

如果您认为我的描述不可信，请将以下代码编译到您的计算机中并运行。希望有人能为我回答这个问题\xef\xbc\x8c谢谢。

C代码：

#include <stdio.h>\n#include <time.h>\n#include <stdlib.h>\n#include <string.h>\n\n#define TLen 300000000\n#define SLen 10\n\nint main(int argc, const char * argv[]) {\n    srandom((unsigned)time(NULL));\n    \n    // An array to increase the index,\n    // the range of its elements is 1-256\n    int rand_arr[128];\n    for (int i = 0; i < 128; ++i)\n        rand_arr[i] = random()%256+1;\n    \n    // A random text(very long), the range of its elements is 0-127\n    char *tex = malloc((sizeof *tex) * …