Этот апноут (перевод AN4044 [1]) показывает, как использовать блоки плавающей точки (floating-point unit, сокращенно FPU), которые есть у микроконтроллеров семейств STM32 Cortex^®-M4 и STM32 Cortex^®-M7. Также дан краткий обзор арифметики с плавающей точкой.

Разработано демонстрационное приложение (firmware) X-CUBE-FPUDEMO, где представлена работа FPU с вычислениями плавающей точки с двойной точностью (double precision), и демонстрируются улучшения от использования аппаратной обработки плавающей точки (в конце статьи приведены два примера использования FPU).

[Арифметика с плавающей точкой]

Числа с плавающей точкой используются для представления не целых чисел. Они состоят из 3 полей:

• Знак числа.
• Экспонента (степень основания числа, порядок).
• Мантисса (дробный множитель, на который умножается степень основания числа).

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

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

Таблица 1. Динамический диапазон целых чисел.

Язык C предоставляет типы float и double для операций плавающей точки. Инструменты моделирования верхнего уровня, такие как MATLAB или Scilab, обычно генерирует C-код, использующий float или double. Отсутствие поддержки плавающей точки означает модификацию сгенерированного кода, чтобы адаптировать его к фиксированной точке. И все операции с фиксированной точкой должны быть жестко закодированы разработчиком.

Таблица 2. Динамический диапазон чисел с плавающей точкой.

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

FPU. Вычисления с плавающей точкой требуют некоторых ресурсов для любых операций между двумя числами. Например, нам нужно:

• Выравнивание двух чисел (они должны иметь одинаковую экспоненту).
• Выполнение операции.
• Округление результата.
• Кодирование результата.

На процессоре без блока FPU все эти операции реализуются программно через библиотеку компилятора C, и они невидимы для программиста; однако производительность получается очень низкой.

На процессорах, у которых на борту есть FPU, все операции полностью выполняются аппаратно, для большинства инструкций за 1 такт ядра. Компилятор C не использует свою собственную библиотеку плавающий точки, напрямую генерируя вместо этого инструкции FPU.

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

[IEEE 754 - стандарт для арифметики с плавающей точкой]

Использование арифметики плавающей точки всегда было востребовано в области компьютерных вычислений, даже на самых ранних этапах развития вычислительной техники. В конце 30-х годов, когда Konrad Zuse в Германии разработал Z-серию вычислителей, в них уже была реализована плавающая точка. Однако сложность внедрения аппаратной поддержки арифметики с плавающей точкой заставляла отказываться от её использования на протяжении десятилетий.

В середине 50-х годов фирма IBM с компьютером 704 показала FPU в мэйнфреймах; и в 70-х появились различные платформы, где поддерживались операции с плавающей точкой, однако в них использовались индивидуальные техники кодирования чисел.

Унификация произошла в 1985 году, когда IEEE опубликовала стандарт 754, где определила общие методы поддержки вычислений с плавающей точкой.

Различные типы реализаций плавающей точки, разработанные за все годы, заставили IEEE стандартизировать следующие элементы:

• Форматы чисел.
• Арифметические операции.
• Преобразования чисел.
• Кодирование специальных значений.
• Четыре режима округления.
• 5 исключений и их обработка.

Форматы чисел. Все значения построены из трех битовых полей:

• Знак числа: s.

• Смещенная экспонента:
   – сумма экспоненты = e.
   – значение константы = bias, смещение разрядов экспоненты.

• Дробная часть, фракция (или мантисса): f.

Значения могут кодироваться следующими длинами бит:

• 16 бит: формат половинной точности (half precision).
• 32 бита: формат обычной, или одинарной точности (single precision).
• 64 бита: формат двойной точности (double precision).

Рис. 1. Кодирование чисел плавающей точки одинарной и двойной точности по стандарту IEEE.754.

Также IEEE определила 5 классов чисел:

• Нормализованные числа.
• Денормализованные числа.
• Нули.
• Бесконечности.
• NaN (Not-a-Number, не число).

Различные классы чисел идентифицируются специальными значениями в этих полях.

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

Для "базового" использования поддержка плавающей точки прозрачна для пользователя, как при использовании типа float в коде языка C. Для более продвинутых приложений могут обрабатываться исключения через ловушки или прерывания.

[STM32 Cortex^®-M floating-point unit (FPU)]

В таблице 6 показаны варианты реализации FPU для STM32 Cortex^®-M4 и Cortex^®-M7.

Таблица 6. Реализация FPU в STM32 Cortex^®-M4/-M7.

Cortex^® M4 FPU. Реализация Cortex^® M4 FPU содержит ARM^® FPv4-SP (блок плавающей запятой одинарной точности). Здесь имеется собственный набор из 32-битных single precision регистров (S0-S31) для обработки операций и хранения результатов. Эти регистры можно рассматривать как 16 регистров двойных слов (D0-15) для операций загрузки/сохранения (load/store).

Регистр состояния и конфигурации (Status & Configuration Register) хранит настройки FPU (режим округления и специальные настройки), биты описания результата операции (negative, zero, carry и overflow) и флаги исключений (exception flags).

Некоторые операции стандарта IEEE.754 не поддерживаются аппаратно, и реализуются программно:

• Remainder.
• Округление плавающей точки к целому значению с плавающей точкой.
• Преобразование двоичное в десятичное и обратно.
• Прямое сравнение значений одиночной точности и двойной точности.

Исключения обрабатываются через прерывания (ловушки не поддерживаются).

Cortex^® M7 FPU. Блок плавающей точки Cortex^®-M7 это реализация ARM^® FPv5. Здесь полностью поддерживаются вычисления одинарной и двойной точности, а также преобразования между формами плавающей точки и фиксированной точки, и есть инструкции констант с плавающей точкой.

FPU поддерживает IEEE754-совместимые 32-битные операции одинарной точности (single-precision) и 64-битные значения двойной точности (double-precision). Имеется расширенный файл регистров, содержащий 32 регистра одинарной точности. Они могут рассматриваться следующим образом:

• Шестнадцать 64-битных регистров двойного слова (D0-D15), которые такие же, как в версии FPv4 без дополнительных регистров.
• Тридцать два 32-битных регистров одного слова (S0-S31), для которых инструкции load/store идентичны поддерживаемым инструкциям FPv4, и уже поддерживают 64-битные типы данных.

FPv5 предоставляет аппаратную поддержку для денормализованных чисел и все режимы округления стандарта IEEE 754-2008.

Специальные рабочие режимы. Cortex^®M4 FPU полностью совместим со спецификациями IEEE.754. Однако могут быть активированы некоторые нестандартные режимы:

• Альтернативный формат половинной точности (Alternative Half-precision, включается битом управления AHP). Это специальный 16-битный режим без значения экспоненты и без поддержки денормализованных чисел.

• Режим Flush-to-zero (бит управления FZ). Все денормализованные числа обрабатываются как нули. Имеется флаг, связанный со сбросом (flush) входа и выхода.

• Режим NaN по умолчанию (бит управления DN). Любая операция с NaN на входе, или которая генерирует NaN, вернет default NaN (Quiet NaN).

Floating-point status and control register (FPSCR). Регистр FPSCR хранит состояние FPU - биты условия (condition bits) и флаги исключения (exception flags), а также его конфигурацию (режимы округления и альтернативные режимы). Как следствие этот регистр можно сохранять в стек, когда меняется контекст выполнения кода.

К FPSCR осуществляется доступ специальными инструкциями:

• Чтение (Read):  VMRS Rx, FPSCR
• Запись (Write): VMSR FPSCR, Rx

Регистр FPSCR и его биты:

N, Z, C, V. Это биты условия (condition bits), они устанавливаются после операции сравнения.

AHP, DN, FZ, RM. Это биты режима, они конфигурируют альтернативные режимы (AHP, DN, FZ) и режим округления (RM).

Флаги исключения (exception flags). Они устанавливаются при возникновении исключения (exception) в случае:

• Flush to zero, сброс к нулю (IDC).
• Inexact result, неточный результат (IXC).
• Underflow, недогрузка (UFC).
• Overflow, переполнение (OFC).
• Division by zero, деление на ноль (DZC).
• Invalid operation, недопустимая операция (IOC).

Примечание: флаги исключения не сбрасываются следующей инструкцией.

Исключения не могут быть перехвачены ловушкой (trap). Они обслуживаются контроллером прерывания. Сигнал от 5 флагов исключений (IDC, UFC, OFC, DZC, IOC) объединяется по ИЛИ и поступает на контроллер прерываний. Нет никакой индивидуальной маски и разрешения/запрета прерывания FPU на уровне контроллера прерываний.

Флаг IXC не соединен с контроллером прерывания, и не может генерировать прерывание, так как частота его появления очень велика. Если необходимо, он может обслуживаться путем опроса программой.

Когда FPU разрешен, его контекст может быть сохранен в стеке CPU с использованием одного из трех методов:

• Регистры плавающей точки не сохраняются.
• Ленивое сохранение и восстановление (только лишь выделяется место в стеке).
• Автоматическое сохранение и восстановление регистров плавающей точки.

Фрейм стека состоит из 17 элементов:

• FPSCR
• S0 .. S15

[Модель программирования]

Когда MCU выходит из сброса, блок FPU должен быть разрешен указанием уровня доступа кода, использующего FPU (запрещено, привилегированный или полный доступ) в регистре Coprocessor Access Control Register (CPACR). FPSCR может быть сконфигурирован для определения альтернативных режимов или для режима округления.

У FPU имеется 5 системных регистров:

• FPCCR (FP Context Control Register), показывающий контекст, когда выделен фрейм стека FP, вместе с настройкой сохранения контекста.
• FPCAR (FP Context Address Register), который указывает на место в стеке, зарезервированное для S0.
• FPDSCR (FP Default Status Control Register), здесь сохраняются значения по умолчанию альтернативного режима половинчатой точности, (Alternative half-precision mode), Default NaN mode, Flush-to-zero mode и Rounding mode.
• MVFR0 & MVFR1 (Media and VFP Feature Registers 0 and 1), где детализируются поддерживаемые функции FPU.

[Инструкции FPU]

Поддерживаются инструкции арифметических операций, сравнения, преобразования и загрузки/сохранения.

Арифметические инструкции. FPU предоставляет арифметические инструкции для:

• Получение абсолютного значения (Absolute value), выполняется за 1 такт.
• Инверсия знака (Negate) для числа float или нескольких чисел float, выполняется за 1 такт.
• Сложение (Addition), выполняется за 1 такт.
• Вычитание (Subtraction), выполняется за 1 такт.
• Умножение (Multiply), умножение с накоплением и вычитанием (multiply accumulate/subtract, MAC), умножение с накоплением и вычитанием и последующей инверсией (multiply accumulate/subtract, then negate), выполняется за 3 такта.
• Деление (Divide), выполняется за 14 тактов.
• Взятие квадратного корня (Square root), выполняется за 14 тактов.

Таблица 8 показывает некоторые инструкции обработки данных плавающей точки одинарной точности.

Таблица 8. Инструкции обработки данных floating-point, single-precision.

Таблица 9 показывает некоторые инструкции обработки данных плавающей точки двойной точности.

Таблица 9. Инструкции обработки данных floating-point, double-precision.

Все MAC-операции могут быть стандартные или типа fused (округление делается по окончании MAC для повышенной точности).

Инструкции сравнения и преобразования. Имеются инструкции сравнения (выполняются за 1 такт) и преобразования (также выполняются за 1 такт). Преобразование может быть между целым числом, числом с фиксированной точкой, числом half precision и числом float.

Инструкции load/store. FPU следует стандартной архитектуре загрузки/сохранения:

• Загрузка (load) и сохранение (store) нескольких значений double, нескольких float, одиночных double или одиночных float.
• Перемещение из регистра ядра / в регистр ядра, для float или double.
• Перемещение из регистра управления/статуса или в него.
• Извлечение из стека (pop) и проталкивание в стек (push) значения double или float.

[Примеры приложений]

Следующие два примера показывают выгоду от использования STM32 FPU. В первом примере вычисляется множество Жюлиа (Julia set), где сравнивается производительность аппаратного FPU и традиционных вычислений.

Второй пример вычисляет множество Мандельброта (Mandelbrot set), где показаны различия в производительности аппаратных вычислений double precision FPU и аппаратных вычислений single precision FPU.

void GenerateJulia_fpu (uint16_t size_x,
                        uint16_t size_y,
                        uint16_t offset_x,
                        uint16_t offset_y,
                        uint16_t zoom,
                        uint8_t * buffer)
{
   float tmp1, tmp2;
   float num_real, num_img;
   float radius;
   uint8_t i;
   uint16_t x,y;

   for (y=0; y < size_y; y++)
   {
      for (x=0; x < size_x; x++)
      {
         num_real = y - offset_y;
         num_real = num_real / zoom;
         num_img = x - offset_x;
         num_img = num_img / zoom;
         i=0;
         radius = 0;
         while ((i < ITERATION-1) && (radius < 4))
         {
            tmp1 = num_real * num_real;
            tmp2 = num_img * num_img;
            num_img = 2*num_real*num_img + IMG_CONSTANT;
            num_real = tmp1 - tmp2 + REAL_CONSTANT;
            radius = tmp1 + tmp2;
            i++;
         }
         /* Сохранение значения в буфер: */
         buffer[x+y*size_x] = i;
      }
   }
}

void GenerateJulia_fpu (uint16_t size_x,
                        uint16_t size_y,
                        uint16_t offset_x,
                        uint16_t offset_y,
                        uint16_t zoom,
                        uint8_t * buffer)
{
   double tmp1, tmp2;
   double num_real, num_img;
   double radius;
   uint8_t i;
   uint16_t x,y;

   for (y=0; y < size_y; y++)
   {
      for (x=0; x < size_x; x++)
      {
         num_real = y - offset_y;
         num_real = num_real / zoom;
         num_img = x - offset_x;
         num_img = num_img / zoom;
         i=0;
         radius = 0;
         while ((i < ITERATION-1) && (radius < 4))
         {
            tmp1 = num_real * num_real;
            tmp2 = num_img * num_img;
            num_img = 2*num_real*num_img + IMG_CONSTANT;
            num_real = tmp1 - tmp2 + REAL_CONSTANT;
            radius = tmp1 + tmp2;
            i++;
         }
         /* Сохранение значения в буфер: */
         buffer[x+y*size_x] = i;
      }
   }
}

void drawMandelbrot_Double (float centre_X,
                            float centre_Y,
                            float Zoom,
                            uint16_t IterationMax)
{
   double X_Min = centre_X - 1.0/Zoom;
   double X_Max = centre_X + 1.0/Zoom;
   double Y_Min = centre_Y - (YSIZE_PHYS-CONTROL_SIZE_Y) / (XSIZE_PHYS * Zoom);
   double Y_Max = centre_Y + (YSIZE_PHYS-CONTROL_SIZE_Y) / (XSIZE_PHYS * Zoom);
   double dx = (X_Max - X_Min) / XSIZE_PHYS;
   double dy = (Y_Max - Y_Min) / (YSIZE_PHYS-CONTROL_SIZE_Y) ;
   double y = Y_Min;
   double c;

   for (uint16_t j = 0; j < (YSIZE_PHYS-CONTROL_SIZE_Y); j++)
   {
      double x = X_Min;
      for (uint16_t i = 0; i < XSIZE_PHYS; i++)
      {
         double Zx = x;
         double Zy = y;
         int n = 0;
         while (n < IterationMax)
         {
            double Zx2 = Zx * Zx;
            double Zy2 = Zy * Zy;
            double Zxy = 2.0 * Zx * Zy;
            Zx = Zx2 - Zy2 + x;
            Zy = Zxy + y;
            if(Zx2 + Zy2 > 16.0)
               break;
            n++;
         }
         x += dx;
      }
      y += dy;
   }
}

Аппаратные вычисления FPU ускоряют алгоритм множества Жюлиа в 12.5 раз при использовании float, и в 7.2 раза при использовании double. Не требуется никакой модификации кода, FPU активируется опциями компилятора. Также FPU позволяет расширить диапазон точности. Таким образом, STM32 FPU реализует очень быстрые вычисления для чисел float и double, что очень важно для точных систем регулирования, обработки звука, декодирования звука или цифровой фильтрации. Разработка приложений ускоряется и результат становится безопаснее, потому что проще применять высокоуровневые средства генерации кода.

[Ссылки]

1. AN4044 Floating point unit demonstration on STM32 microcontrollers site:st.com.
2. PM0214 STM32 Cortex^®-M4 MCUs and MPUs programming manual site:st.com.