Как рассчитать GFLOP для funtion в C++-программе?

Question

У меня есть C++ код, который вычисляет факториал типа ИНТ данных, добавление типа поплавка данных и времени выполнения каждой функции следующим образом:

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; 
} 

Теперь я хочу, чтобы иметь MESURE GFlops для функции «добавить» , Итак, любезно предложите, как я его окуриваю. Как, я совершенно новый для GFLOPs, любезно скажите мне, что мы можем иметь GFLOP, рассчитанные для функций, имеющих только типы данных foat? а также значение GFLOPs зависит от разных функций?

Answer 1

Если мне было интересно оценить время выполнения операции добавления, я могу начать со следующей программы. Тем не менее, я по-прежнему буду только доверять номер этой программы, произведенной в лучшем случае от 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 реализацией макроса или обеспечения того, чтобы ваш компилятор расширялся для встроенных контуров. В противном случае вы можете также включить операцию добавления индекса цикла в измерение.

Я думаю, что вероятность того, что ошибка не будет масштабироваться линейно с размером проблемы. Например, если операция, которую вы пытались выполнить, занимает от 1 до 9 раз больше, вы можете получить достойную оценку для GFLOPS. Но, если вы точно не знаете, что ваш компилятор и архитектура делают с вашим кодом, я бы не стал уверенно пытаться оценить GFLOPS на языке высокого уровня, таком как C++, возможно, сборка может работать лучше (просто догадка).

Я не говорю, что это невозможно, но для точных оценок есть много вещей, которые вам, возможно, придется рассмотреть.