Что считается флопом?

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

Если «x» и «a» являются числами с плавающей запятой, вы делаете хорошую попытку подсчитать количество операций в своем коде, но вам нужно проверить код объекта, чтобы убедиться, какое количество инструкций с плавающей запятой фактически используются. Например, если "a" впоследствии не используется, оптимизирующий компилятор может не утруждаться его вычислением.

Кроме того, некоторые операции с плавающей запятой (например, сложение) могут быть намного быстрее, чем другие (например, умножение), поэтому цикл только сложения с плавающей запятой может выполняться на гораздо большем количестве FLOPS, чем цикл только умножения с плавающей запятой на той же машине.

FLOP (строчные s указывает на множественное число FLOP, согласно комментарию Мартиньо Фернандеса) относятся к инструкциям с плавающей запятой на машинном языке, поэтому это зависит от того, сколько инструкций компилируется в вашем коде.

Во-первых, если все эти переменные являются целыми числами, то в этом коде нет FLOP. Предположим, однако, что ваш язык распознает все эти константы и переменные как переменные одинарной точности с плавающей запятой (использование одинарной точности упрощает загрузку констант).

Этот код может быть скомпилирован (на MIPS):

Assignment of variables: x is in $f1, a is in $f2, i is in $f3.
All other floating point registers are compiler-generated temporaries.
$f4 stores the loop exit condition of 10.0
$f5 stores the floating point constant 1.0
$f6 stores the floating point constant 2.0
$t1 is an integer register used for loading constants
    into the floating point coprocessor.

     lui $t1, *upper half of 0.0*
     ori $t1, $t1,  *lower half of 0.0*
     lwc1 $f3, $t1
     lui $t1, *upper half of 10.0*
     ori $t1, $t1,  *lower half of 10.0*
     lwc1 $f4, $t1
     lui $t1, *upper half of 1.0*
     ori $t1, $t1,  *lower half of 1.0*
     lwc1 $f5, $t1
     lui $t1, *upper half of 2.0*
     ori $t1, $t1,  *lower half of 2.0*
     lwc1 $f6, $t1
st:  c.gt.s $f3, $f4
     bc1t end
     add.s $f1, $f1, $f5
     lui $t1, *upper half of 5.0*
     ori $t1, $t1,  *lower half of 5.0*         
     lwc1 $f2, $t1
     mul.s $f2, $f2, $f1
     add.s $f2, $f2, $f6
     add.s $f3, $f3, $f5
     j st
end: # first statement after the loop

Таким образом, согласно определению Гейба, внутри цикла есть 4 FLOP (3x add.s и 1x mul.s). Есть 5 FLOP, если вы также считаете сравнение циклов c.gt.s. Умножьте это на 10, чтобы получить 40 (или 50) FLOP, используемых программой.

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

     lui $t1, *upper half of 0.0*
     ori $t1, $t1,  *lower half of 0.0*
     lwc1 $f3, $t1
     lui $t1, *upper half of 10.0*
     ori $t1, $t1,  *lower half of 10.0*
     lwc1 $f4, $t1
     lui $t1, *upper half of 1.0*
     ori $t1, $t1,  *lower half of 1.0*
     lwc1 $f5, $t1
     lui $t1, *upper half of 2.0*
     ori $t1, $t1,  *lower half of 2.0*
     lwc1 $f6, $t1
st:  c.gt.s $f3, $f4
     bc1t end
     add.s $f1, $f1, $f5
     add.s $f3, $f3, $f5
     j st
end: lui $t1, *upper half of 5.0*
     ori $t1, $t1,  *lower half of 5.0*         
     lwc1 $f2, $t1
     mul.s $f2, $f2, $f1
     add.s $f2, $f2, $f6

В этом случае у вас есть 2 сложения и 1 сравнение внутри цикла (умножение на 10 дает вам 20 или 30 FLOP), плюс 1 умножение и 1 сложение вне цикла. Таким образом, ваша программа теперь занимает 22 или 32 FLOP в зависимости от того, считаем ли мы сравнения.

FLOPS означает плавающие операции в секунду. Если вы имеете дело с целыми числами, то в вашем коде нет операций с плавающей запятой.

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