3

我有一个 C++ 代码，它计算 int 数据类型的阶乘、浮点数据类型的添加和每个函数的执行时间，如下所示：

long Sample_C:: factorial(int n)
{
    int counter;
    long fact = 1;
    for (int counter = 1; counter <= n; counter++)
    {
        fact = fact * counter;
    }
    Sleep(100);
    return fact;
}

float Sample_C::add(float a, float b)
{

    return a+b;
}

int main(){
    Sample_C object;
    clock_t start = clock();
    object.factorial(6);
    clock_t end = clock();
    double time =(double)(end - start);// finding execution time of factorial()
    cout<< time;
    clock_t starts = clock();
    object.add(1.1,5.5);
    clock_t ends = clock();
    double total_time = (double)(ends -starts);// finding execution time of add()
    cout<< total_time;
    return 0;
}

现在，我想为“添加”功能测量 GFLOP。所以，请建议我将如何计算它。因为，我对 GFLOP 完全陌生，所以请告诉我我们是否可以为只有 foat 数据类型的函数计算 GFLOP？并且 GFLOPs 值也随着不同的功能而变化？

4

1 回答 1

0

如果我有兴趣估计加法操作的执行时间，我可能会从以下程序开始。但是，我仍然只相信这个程序产生的数字最多在 10 到 100 之间（即我并不真正相信这个程序的输出）。

#include <iostream>
#include <ctime>

int main (int argc, char** argv)
{
  // Declare these as volatile so the compiler (hopefully) doesn't
  // optimise them away.
  volatile float a = 1.0;
  volatile float b = 2.0;
  volatile float c;

  // Preform the calculation multiple times to account for a clock()
  // implementation that doesn't have a sufficient timing resolution to
  // measure the execution time of a single addition.
  const int iter = 1000;

  // Estimate the execution time of adding a and b and storing the
  // result in the variable c.
  // Depending on the compiler we might need to count this as 2 additions
  // if we count the loop variable.
  clock_t start = clock();
  for (unsigned i = 0; i < iter; ++i)
  {
    c = a + b;
  }
  clock_t end = clock();

  // Write the time for the user
  std::cout << (end - start) / ((double) CLOCKS_PER_SEC * iter)
      << " seconds" << std::endl;

  return 0;
}

如果您知道您的特定架构是如何执行此代码的，那么您可以尝试从执行时间估计 FLOPS，但 FLOPS 的估计（在这种类型的操作上）可能不会很准确。

对这个程序的改进可能是for用宏实现替换循环或确保您的编译器内联扩展循环。否则，您可能还会在测量中包含循环索引的加法操作。

我认为错误很可能不会随着问题的大小线性扩展。例如，如果您尝试计时的操作花费了 1e9 到 1e15 倍的时间，您可能能够对 GFLOPS 进行一个不错的估计。但是，除非你确切地知道你的编译器和架构对你的代码做了什么，否则我不会有信心用像 C++ 这样的高级语言来估计 GFLOPS，也许汇编可能会更好（只是一种预感）。

我并不是说它不能完成，但为了准确估计，您可能需要考虑很多事情。

于 2015-06-18T13:59:30.177 回答