Что быстрее на esp8266: 64-битная математика или математика с плавающей запятой?

Вычисление относительной производительности 64-битного целого числа по сравнению с умножением с плавающей запятой немного сложнее, чем может показаться.

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

Чтобы сделать код как можно более простым и не вводить в цикл ничего, что заняло бы больше времени, вам необходимо отключить или обойти оптимизацию компилятора. Самый простой способ сделать это - использовать модификатор volatile для переменных. volatile сообщает компилятору, что он не может предположить, что переменная не изменилась, поэтому компилятор отключит оптимизацию, такую как кэширование переменной в регистре или заметив, что одно и то же вычисление выполняется снова и снова, и просто делает это один раз.

Используя этот метод, с помощью нескольких тестов, чтобы убедиться, что компилятор будет выполнять оптимизации, которые влияют на синхронизацию, я получаю следующие результаты:

non-volatile uint32_t microseconds 1
constants uint32_t microseconds 5
uint16_t microseconds 162513
uint32_t microseconds 137513
uint64_t microseconds 1287533
int16_t microseconds 337513
int32_t microseconds 300023
int64_t microseconds 1287513
float  microseconds 912529

64-разрядное умножение без знака или знака занимает примерно в 1,4 раза больше времени, чем умножение с плавающей запятой.

Первый тест подтвердил, что энергонезависимые переменные оптимизированы. Второй тест подтвердил, что умножение констант также оптимизировано.

Отключение Wi-Fi также помогает сохранить результаты тестирования неизменными.

#include <Arduino.h>

#ifdef ESP32
#include <WiFi.h>
#else
#include <ESP8266WiFi.h>
#endif

#define TIMES_TO_LOOP 1000000

volatile uint16_t ux16, uy16, uresult16;
volatile uint32_t ux32, uy32, uresult32;
volatile uint64_t ux64, uy64, uresult64;

volatile int16_t x16, y16, result16;
volatile int32_t x32, y32, result32;
volatile int64_t x64, y64, result64;

volatile float xf, yf, resultf;

uint32_t x32n, y32n, result32n;

uint16_t seed16() {
  return random(0, 0xffff);
}

uint32_t seed32() {
  return random(0, 0xffffffff);
}

uint64_t seed64() {
  return seed32();
}

float seedfloat() {
  float x, y;

  x = seed32();
  y = seed32();

  return x / y;
}

void setup() {
  uint32_t i;
  uint64_t micros_start, micros_end;

  Serial.begin(115200);
  Serial.println("hello world");

  WiFi.mode( WIFI_OFF );

  delay(1000);

  x32n = seed32();
  y32n = seed32();

  micros_start = micros();
  for(i = 0; i < TIMES_TO_LOOP; i++)
    result32n = x32n * y32n;
  micros_end = micros();

  Serial.print("non-volatile uint32_t microseconds ");
  Serial.println(micros_end - micros_start);

  micros_start = micros();
  for(i = 0; i < TIMES_TO_LOOP; i++)
    result32n = 540000 * 15;
  micros_end = micros();

  Serial.print("constants uint32_t microseconds ");
  Serial.println(micros_end - micros_start);


  ux16 = seed16();
  uy16 = seed16();
  x16 = ux16;
  y16 = uy16;

  micros_start = micros();
  for(i = 0; i < TIMES_TO_LOOP; i++)
    uresult16 = ux16 * uy16;
  micros_end = micros();

  Serial.print("uint16_t microseconds ");
  Serial.println(micros_end - micros_start);
    
  ux32 = seed32();
  uy32 = seed32();
  x32 = ux32;
  y32 = uy32;

  micros_start = micros();
  for(i = 0; i < TIMES_TO_LOOP; i++)
    uresult32 = ux32 * uy32;
  micros_end = micros();

  Serial.print("uint32_t microseconds ");
  Serial.println(micros_end - micros_start);

  ux64 = seed64();
  uy64 = seed64();
  x64 = ux64;
  y64 = uy64;

  micros_start = micros();
  for(i = 0; i < TIMES_TO_LOOP; i++)
    uresult64 = ux64 * uy64;
  micros_end = micros();

  Serial.print("uint64_t microseconds ");
  Serial.println(micros_end - micros_start);

  micros_start = micros();
  for(i = 0; i < TIMES_TO_LOOP; i++)
    result16 = x16 * y16;
  micros_end = micros();

  Serial.print("int16_t microseconds ");
  Serial.println(micros_end - micros_start);
    
  micros_start = micros();
  for(i = 0; i < TIMES_TO_LOOP; i++)
    result32 = x32 * y32;
  micros_end = micros();

  Serial.print("int32_t microseconds ");
  Serial.println(micros_end - micros_start);

  micros_start = micros();
  for(i = 0; i < TIMES_TO_LOOP; i++)
    result64 = x64 * y64;
  micros_end = micros();

  Serial.print("int64_t microseconds ");
  Serial.println(micros_end - micros_start);

  xf = seedfloat();
  yf = seedfloat();

  micros_start = micros();
  for(i = 0; i < TIMES_TO_LOOP; i++)
    resultf = xf * yf;
  micros_end = micros();

  Serial.print("float  microseconds ");
  Serial.println(micros_end - micros_start);
}

void loop() {
}

Хорошо, я взял на себя труд закодировать процедуры с фиксированной запятой и протестировать их. Вот этот код ...

// процедуры с фиксированной запятой для 20-битного целого числа / 12-битной дроби
// формат 0xfffff.fff, максимальное значение равно +-524288.9998

#define FP_I 20     // целых битов, например, 0xfffff.0
#define FP_F 12     // бит дроби, например, 0x0.fff
#define fpMul(_x,_y) ( (i32)( ((i64) _x * _y) >> FP_F) )
#define fpDiv(_x,_y) ( (i32)(  (((i64) _x) <<   32)      \
                             / (((i64) _y) >> FP_I) ) )
#define decToFp(_dec) ((i32) (_dec * 4096))   // например, decToFp(-1.2)    
#define fpToI32(_fp)  ((i32) (_fp  / 4096))

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

Результаты были шокирующими. Умножение с фиксированной запятой заняло почти столько же времени, сколько и умножение с плавающей запятой. Разделение с фиксированной запятой заняло на 60% больше времени, чем разделение с плавающей запятой. Я просмотрел свой код и перепробовал все, что смог придумать. Я построил его в режиме отладки и выпуска. Я пробовал 80 МГц и 160 МГц. Я нашел скорости с плавающей запятой в Интернете, и мои тесты с плавающей запятой точно соответствовали им.

Я в недоумении относительно того, как 64-битная математика может быть медленнее, чем с плавающей запятой. И то, и другое реализовано в программном обеспечении. Я уверен, что число с плавающей запятой сильно оптимизировано с помощью некоторых хитростей и закодировано на машинном языке. Но мой код с фиксированной запятой - это просто сдвиги и 64-битное умножение / деление. Я не думаю, что есть какие-то уловки, которые можно было бы использовать для этого.

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

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