Эффективное сравнение с плавающей запятой (Cortex-A8)

Если числа с плавающей запятой являются 32-битными IEEE-754, а целые числа тоже 32-битными, и если нет значений + infinity, -infinity и NaN, мы можем сравнить числа с плавающей запятой как целые числа с помощью небольшого трюка:

#include <stdio.h>
#include <limits.h>
#include <assert.h>

#define C_ASSERT(expr) extern char CAssertExtern[(expr)?1:-1]
C_ASSERT(sizeof(int) == sizeof(float));
C_ASSERT(sizeof(int) * CHAR_BIT == 32);

int isGreater(float* f1, float* f2)
{
  int i1, i2, t1, t2;

  i1 = *(int*)f1;
  i2 = *(int*)f2;

  t1 = i1 >> 31;
  i1 = (i1 ^ t1) + (t1 & 0x80000001);

  t2 = i2 >> 31;
  i2 = (i2 ^ t2) + (t2 & 0x80000001);

  return i1 > i2;
}

int main(void)
{
  float arr[9] = { -3, -2, -1.5, -1, 0, 1, 1.5, 2, 3 };
  float thr;
  int i;

  // Make sure floats are 32-bit IEE754 and
  // reinterpreted as integers as we want/expect
  {
    static const float testf = 8873283.0f;
    unsigned testi = *(unsigned*)&testf;
    assert(testi == 0x4B076543);
  }

  thr = -1.5;
  for (i = 0; i < 9; i++)
  {
    printf("%f %s %f\n", arr[i], "<=\0> " + 3*isGreater(&arr[i], &thr), thr);
  }

  thr = 1.5;
  for (i = 0; i < 9; i++)
  {
    printf("%f %s %f\n", arr[i], "<=\0> " + 3*isGreater(&arr[i], &thr), thr);
  }

  return 0;
}

Выход:

-3.000000 <= -1.500000
-2.000000 <= -1.500000
-1.500000 <= -1.500000
-1.000000 >  -1.500000
0.000000 >  -1.500000
1.000000 >  -1.500000
1.500000 >  -1.500000
2.000000 >  -1.500000
3.000000 >  -1.500000
-3.000000 <= 1.500000
-2.000000 <= 1.500000
-1.500000 <= 1.500000
-1.000000 <= 1.500000
0.000000 <= 1.500000
1.000000 <= 1.500000
1.500000 <= 1.500000
2.000000 >  1.500000
3.000000 >  1.500000

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

Если вы боитесь неопределенного поведения в C / C ++ в приведенном выше коде, вы можете переписать код на ассемблере.

Если ваши данные являются плавающими, вам следует провести сравнение с плавающими, например

float arr[10000];
float threshold;
....

float a = arr[20]; // e.g.
if (threshold > a) {....}

в противном случае у вас будут дорогостоящие преобразования типа float-int.

Ваш пример показывает, насколько плохими могут быть коды, сгенерированные компилятором:

Он загружает значение с помощью NEON, чтобы преобразовать его в int, затем выполняет передачу NEON-> ARM, которая вызывает очистку конвейера, что приводит к потере 11 ~ 14 циклов.

Лучшим решением было бы написать функцию полностью в ручной сборке.

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

Положительный порог (точно так же, как сравнение int):

void example(float * pSrc, float threshold, unsigned int count)
{
  typedef union {
    int ival,
    unsigned int uval,
    float fval
  } unitype;

  unitype v, t;
  if (count==0) return;
  t.fval = threshold;
  do {
    v.fval = *pSrc++;
    if (v.ival < t.ival) {
      // your code here
    }
    else {
      // your code here (optional)
    }
  } while (--count);
}

Порог отрицательный (на 1 цикл больше на значение, чем при сравнении int):

void example(float * pSrc, float threshold, unsigned int count)
{
  typedef union {
    int ival,
    unsigned int uval,
    float fval
  } unitype;

  unitype v, t, temp;
  if (count==0) return;
  t.fval = threshold;
  t.uval &= 0x7fffffff;
  do {
    v.fval = *pSrc++;
    temp.uval = v.uval ^ 0x80000000;
    if (temp.ival >= t.ival) {
      // your code here
    }
    else {
      // your code here (optional)
    }
  } while (--count);
}

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

Если ошибки округления не имеют значения, вам следует использовать std :: lrint.

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