flops — Как рассчитать GFLOP для функции в программе на c ++?
У меня есть код 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;
}
Теперь я хочу иметь mesure GFLOP для функции «добавить». Так что, пожалуйста, предложите, как я это сделаю. Так как я совершенно новичок в GFLOP, поэтому, пожалуйста, скажите мне, можно ли рассчитывать GFLOP для функций, имеющих только типы данных? а также значение GFLOP зависит от разных функций?
Решение
Если бы мне было интересно оценить время выполнения операции сложения, я мог бы начать со следующей программы. Тем не менее, я бы все же доверял только количеству, произведенному этой программой, в лучшем случае с коэффициентом от 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 цикл с реализацией макроса или убедитесь, что ваш компилятор расширяется для циклов inline. В противном случае вы также можете включить операцию измерения для индекса цикла в ваше измерение.
Я думаю, что вероятность того, что ошибка не будет масштабироваться линейно с размером проблемы. Например, если операция, которую вы пытались рассчитать, заняла от 1 до 9 раз больше, вы можете получить приличную оценку GFLOPS. Но, если вы точно не знаете, что ваш компилятор и архитектура делают с вашим кодом, я не чувствовал бы себя уверенно, пытаясь оценить GFLOPS на языке высокого уровня, таком как C ++, возможно, сборка могла бы работать лучше (просто догадка).
Я не говорю, что это невозможно сделать, но для точных оценок есть много вещей, которые вы, возможно, должны рассмотреть.
Другие решения