## Floating-point face-off, part 2: Comparing performance

I used to think that floating-point was not for Embedded Systems. Too slow, too much code overhead and rounding is always a problem.
It turns out that while scaled integers still have a performance benefit, floating-point computations can be done with a surprisingly high performance these days on modern Embedded CPUs. This is true not only for CPUs with floating-point unit (FPU), such as the Cortex-M4F, but also for CPUs which have to do this in software, such as a regular Cortex-M3 or M4 without FPU.

But first things first, let’s look at how things work:

## Basic floating-point operations

Let’s look at a function multiplying 2 integers:

```int Mul(int a, int b) {
return a * b;
}
```

The generated code (in Thumb-2 instructions) can be as simple as this:

```  FB01F000    mul r0, r1, r0
4770        bx lr
```

For the multiplication of two floats the code is quite similar when the FPU is used:

```float FMul(float a, float b) {
return a * b;
}
```
```  EE200A20    vmul.f32 s0, s0, s1
4770        bx lr
```

Also the speed is similar. mul and vmul.f32 take just a few cycles.

## What happens without FPU?

The good new is: Nothing changes from an application programmers perspective. The C-code does not need to be modified at all. We only tell the compiler that no FPU is available.

Let’s look at the output of FMul() again:

```  B508        push   {r3, lr}
F000FB20    bl     __aeabi_fmul
BD08        pop    {r3, pc}
```

Without an FPU, the compiler cannot use the floating-point multiplication instruction. Instead we can see that it now adds a call to a function __aeabi_fmul to do the work.

## Implicit floating-point functions

The ARM Run-time ABI defines implicit floating-point functions, 38 of which are in active use. The compiler can and typically will add calls to these functions whenever it is told to not use an FPU, i.e. the floating-point ABI type is set to “soft”, and the application program needs to perform floating-point operations, such as add, subtract, multiply, divide, or compare.

These functions perform the floating-point operation in software, using the available integer-only instructions. An implementation needs to be provided to the tool-chain, usually as part of the runtime library.

## Floating-point benchmark

We were curious to find out more about the performance of such software floating-point operations and compared some implementations:

• SEGGER RunTime Library, ASM-implementation
• Competitor A
• Competitor B, fast library
• Competitor B, small library (default)
• SEGGER RunTime Library, C-implementation
• GNU Arm Embedded, Libgcc

### How we test

We called all 38 implicit functions multiple times with different parameters, to execute most, if not all, paths of the implementations. We built an average over all calls of a function, and added the average execution time of all functions to summarize the performance with a single value. For the comparison, we have used the SEGGER RunTime Library ASM implementation as the 100% mark reference.

The code has been generated for Cortex-M4 (Arm architecture v7EM) and runs on an NXP Kinetis K66. All code is executed from RAM to eliminate degradation and variations in execution speed due to caching.

To accurately measure the execution time, the Cortex-M cycle counter, built into the CPU, has been used.

### Performance of the SEGGER ASM implementation

Function Average Cycles
Float, Math __aeabi_fadd 31.0
__aeabi_fsub 39.9
__aeabi_frsub 39.9
__aeabi_fmul 26.0
__aeabi_fdiv 53.0
Float, Compare __aeabi_fcmplt 13.0
__aeabi_fcmple 13.0
__aeabi_fcmpgt 13.0
__aeabi_fcmpge 13.0
__aeabi_fcmpeq 7.0
Double, Math __aeabi_dadd 54.5
__aeabi_dsub 71.2
__aeabi_drsub 71.2
__aeabi_dmul 56.4
__aeabi_ddiv 134.0
Double, Compare __aeabi_dcmplt 14.0
__aeabi_dcmple 14.0
__aeabi_dcmpgt 14.0
__aeabi_dcmpge 14.0
__aeabi_dcmpeq 14.0
Float, Conversion __aeabi_f2iz 9.0
__aeabi_f2uiz 6.0
__aeabi_f2lz 13.5
__aeabi_f2ulz 12.0
__aeabi_i2f 10.5
__aeabi_ui2f 7.5
__aeabi_l2f 19.0
__aeabi_ul2f 13.8
__aeabi_f2d 9.0
Double, Conversion __aeabi_d2iz 10.0
__aeabi_d2uiz 8.0
__aeabi_d2lz 16.5
__aeabi_d2ulz 13.5
__aeabi_i2d 12.0
__aeabi_ui2d 8.0
__aeabi_l2d 17.9
__aeabi_ul2d 12.9
__aeabi_d2f 11.0

### Comparison with other implementations

SEGGER RT Lib (ASM) Competitor A Competitor B (fast) Competitor B (small) GNU Arm libgcc SEGGER RT Lib (C)
Float, Math 100.0% 95.2% 95.2% 234.0% 179.9% 334.6%
Float, Compare 100.0% 144.1% 186.4% 81.4% 449.2% 142.4%
Double, Math 100.0% 95.6% 86.6% 375.5% 240.3% 410.7%
Double, Compare 100.0% 150.0% 157.1% 190.0% 394.3% 340.0%
Float, Conversion 100.0% 110.6% 121.1% 249.9% 688.2% 638.3%
Double, Conversion 100.0% 111.3% 137.0% 531.1% 714.3% 903.7%
Total 100.0% 106.3% 110.0% 318.0% 358.9% 456.2%

The SEGGER ASM library has been used as reference, making the values in the first column 100%.
Smaller values mean higher performance.

Detailed information on the results is available here: PDF.

### Conclusions

It is surprising to see that it is possible to perform IEEE 795 compliant floating point operations so efficiently in software. Only 26 cycles on average for a multiplication, 31 cycles for addition mean that a Cortex-M4 can execute a floating point computation in fractions of a μs (such as 0.13μs at 200MHz). Modern embedded CPUs are capable of performing millions of floating point operations per second, making floating point “affordable” even on hardware without FPU. This is true for pretty much any system except maybe those whose primary purpose is number crunching, such as digital filter applications.
However, there are differences in implementations.

All commercial toolchains (SEGGER Embedded Studio as well as competitors A and B) have put a lot of effort into their floating-point code. They all use highly optimized assembly code to perform these operations.
Competitor B also supplies a “code size optimized” library, which is actually default. Beware! While the code is somewhat more compact, the performance of the small library is surprisingly low. We might take a closer look at things in another part of this series.

Libgcc for GNU Arm Embedded is also written in assembler, but by far not as optimized. Actually, its performance (about 30% of the performance of the commercial implementations) is quite disappointing.

The only library written in pure C in this test is the SEGGER RunTime Library C variant. Not surprisingly, it is about 4 time slower than its brother written in ASM. However, it is almost as fast as the assembly coded Libgcc. That is quite impressive for a library that can be basically used on any CPU, not just ARM.
Good work, Mr. Curtis!

The SEGGER RunTime Library is the overall winner, but performance differences are not significant in most cases, simply because competitors A and B have also “done their homework” and produced good code as well.

### Benchmark program

Below for reference the code we have used to benchmark the different libraries.

```/*********************************************************************
*                   (c) SEGGER Microcontroller GmbH                  *
*                        The Embedded Experts                        *
*                           www.segger.com                           *
**********************************************************************

File        : bench.c
Purpose     : Benchmark Arm EABI implicit floating-point functions.

*/

/*********************************************************************
*
*       #include section
*
**********************************************************************
*/

/*********************************************************************
*
*       Defines, fixed
*
**********************************************************************
*/
#ifdef SEMIHOST
#include "SEGGER_SEMIHOST.h"
#endif
#if !defined (__clang__) || defined(__CC_ARM)
#include <string.h>
#include <stdio.h>
#endif
#include <stdarg.h>

/*********************************************************************
*
*       Defines, configurable
*
**********************************************************************
*/
#define SPECIAL(X)     // Set to X, if specials are required

/*********************************************************************
*
*       Defines, fixed
*
**********************************************************************
*/

#define COUNTOF(X) (sizeof(X) / sizeof(X[0]))

#define DWT_CYCCNT (*(volatile unsigned *)0xE0001004)

#if defined (__clang__) && !defined(__CC_ARM)
#define  memset _MEMSET
#endif

/*********************************************************************
*
*       Types, local
*
**********************************************************************
*/

typedef unsigned long long u64;
typedef unsigned long      u32;

typedef enum {
MODE_INT_RETURN_FLOAT,
MODE_INT_RETURN_DOUBLE,
MODE_LLONG_RETURN_FLOAT,
MODE_LLONG_RETURN_DOUBLE,
MODE_FLOAT_RETURN_INT,
MODE_FLOAT_RETURN_LLONG,
MODE_FLOAT_RETURN_FLOAT,
MODE_FLOAT_RETURN_DOUBLE,
MODE_DOUBLE_RETURN_INT,
MODE_DOUBLE_RETURN_LLONG,
MODE_DOUBLE_RETURN_FLOAT,
MODE_DOUBLE_RETURN_DOUBLE,
//
MODE_INT_INT_RETURN_INT,
MODE_LLONG_LLONG_RETURN_LLONG,
MODE_FLOAT_FLOAT_RETURN_INT,
MODE_FLOAT_FLOAT_RETURN_FLOAT,
MODE_DOUBLE_DOUBLE_RETURN_INT,
MODE_DOUBLE_DOUBLE_RETURN_DOUBLE,
MODE_MAX
} ExecMode;

typedef enum {
SEQUENCE_END,
SEQUENCE_SPECIAL_F32xF32,
SEQUENCE_TYPICAL_F32xF32,
SEQUENCE_SPECIAL_F64xF64,
SEQUENCE_TYPICAL_F64xF64,
SEQUENCE_31_INT,
SEQUENCE_31_FLOAT,
SEQUENCE_31_DOUBLE,
SEQUENCE_63_LLONG,
SEQUENCE_63_FLOAT,
SEQUENCE_63_DOUBLE,
SEQUENCE_SIGNED = 1<<8
} SEQUENCE;

typedef void (*VoidFunc)(void);

typedef struct {
unsigned index;
unsigned last;
int      sign;
SEQUENCE seq;
} ExecSequence;

typedef union {
float     f;
double    d;
int       i;
long long l;
} ExecValue;

typedef volatile union {
void               (*pfVoidReturnVoid)           (void);
float              (*pfIntReturnFloat)           (int);
double             (*pfIntReturnDouble)          (int);
float              (*pfLlongReturnFloat)         (long long);
double             (*pfLlongReturnDouble)        (long long);
float              (*pfUllongReturnFloat)        (unsigned long long);
double             (*pfUllongReturnDouble)       (unsigned long long);
int                (*pfIntIntReturnInt)          (int, int);
long long          (*pfLlongLlongReturnLlong)    (long long, long long);
//
float              (*pfFloatFloatReturnFloat)    (float, float);
int                (*pfFloatFloatReturnInt)      (float, float);
//
double             (*pfDoubleDoubleReturnDouble) (double, double);
int                (*pfDoubleDoubleReturnInt)    (double, double);
//
int                (*pfFloatReturnInt)           (float);
float              (*pfFloatReturnFloat)         (float);
long long          (*pfFloatReturnLlong)         (float);
double             (*pfFloatReturnDouble)        (float);
//
int                (*pfDoubleReturnInt)          (double);
long long          (*pfDoubleReturnLlong)        (double);
float              (*pfDoubleReturnFloat)        (double);
double             (*pfDoubleReturnDouble)       (double);
} ExecFunction;

typedef struct {
ExecMode     Mode;
ExecFunction Function;
ExecValue    v0;
ExecValue    v1;
int          i;
int          j;
} ExecContext;

/*********************************************************************
*
*       Prototypes (of benchmarked runtime functions)
*
**********************************************************************
*/

// ARM EAEBI

int                __aeabi_idiv    (int, int);
long long          __aeabi_ldivmod (long long, long long);
float              __aeabi_fadd    (float, float);
float              __aeabi_fsub    (float, float);
float              __aeabi_frsub   (float, float);
float              __aeabi_fmul    (float, float);
float              __aeabi_fdiv    (float, float);
int                __aeabi_fcmplt  (float, float);
int                __aeabi_fcmple  (float, float);
int                __aeabi_fcmpgt  (float, float);
int                __aeabi_fcmpge  (float, float);
int                __aeabi_fcmpeq  (float, float);
double             __aeabi_dadd    (double, double);
double             __aeabi_dsub    (double, double);
double             __aeabi_drsub   (double, double);
double             __aeabi_dmul    (double, double);
double             __aeabi_ddiv    (double, double);
int                __aeabi_dcmplt  (double, double);
int                __aeabi_dcmple  (double, double);
int                __aeabi_dcmpgt  (double, double);
int                __aeabi_dcmpge  (double, double);
int                __aeabi_dcmpeq  (double, double);
int                __aeabi_f2iz    (float);
unsigned           __aeabi_f2uiz   (float);
long long          __aeabi_f2lz    (float);
unsigned long long __aeabi_f2ulz   (float);
float              __aeabi_i2f     (int);
float              __aeabi_ui2f    (unsigned);
float              __aeabi_l2f     (long long);
float              __aeabi_ul2f    (unsigned long long);
int                __aeabi_d2iz    (double);
long long          __aeabi_d2lz    (double);
unsigned           __aeabi_d2uiz   (double);
unsigned long long __aeabi_d2ulz   (double);
double             __aeabi_i2d     (int);
double             __aeabi_ui2d    (unsigned);
double             __aeabi_l2d     (long long);
double             __aeabi_ul2d    (unsigned long long);
double             __aeabi_f2d     (float);
float              __aeabi_d2f     (double);

// GNU API
float              __addsf3        (float, float);
float              __subsf3        (float, float);
float              __mulsf3        (float, float);
float              __divsf3        (float, float);
float              __ltsf2         (float, float);
float              __lesf2         (float, float);
float              __gtsf2         (float, float);
float              __gesf2         (float, float);
float              __eqsf2         (float, float);
float              __nesf2         (float, float);
double             __adddf3        (double, double);
double             __subdf3        (double, double);
double             __muldf3        (double, double);
double             __divdf3        (double, double);
double             __ltdf2         (double, double);
double             __ledf2         (double, double);
double             __gtdf2         (double, double);
double             __gedf2         (double, double);
double             __eqdf2         (double, double);
double             __nedf2         (double, double);

/*********************************************************************
*
*       Static data, const
*
**********************************************************************
*/

// binary32 special values
static u32 _aFloatSpecials[] = {
0x00000000,  // +0
0x80000000,  // -0
0x7F800000,  // +Inf
0xFF800000,  // -Inf
0x7FC00000,  // NaN
0xFFC00000,  // NaN
};

// Random floats derived from quantum randomness (https://qrng.anu.edu.au)
static float _aFloatRandomUniformDistribution1[] = {
0.7885449723,
0.9998094715,
0.3876576724,
0.8356841958,
0.3148936939,
0.9970710786,
0.8235131486,
0.3335833366,
0.1948718644,
0.8166663091,
0.1650510733,
0.3968966721,
0.3638974189,
0.9667957495,
0.3121612214,
0.9223421130,
0.7188766282,
0.2825422601,
0.0383919030,
0.5764071341,
0.4114595256,
0.4700649972,
0.8002487955,
0.3655678094,
0.6008792749,
0.4053804503,
0.3819831959,
0.7347183835,
0.4479462250,
0.3401285649,
0.0707507148,
0.4984719161,
0.3409999091,
0.8548396639,
0.5045839402,
0.7739178709,
0.0983707712,
0.5618592840,
0.1426608492,
0.5289642164,
0.1578932915,
0.9081336126,
0.4058290755,
0.8012231669,
0.8389891772,
0.0952707962,
0.4920716871,
0.3719829386,
0.0144001994,
0.7667299990,
0.6203624231,
0.7813631283,
0.6673019642,
0.7618224988,
0.6041512158,
0.8233172946,
0.6591242263,
0.6219177115,
0.6990491696,
0.5953941475,
0.7233279722,
0.3609917109,
0.1769333638,
0.1089936333
};

// Random floats derived from quantum randomness (https://qrng.anu.edu.au)
static float _aFloatRandomUniformDistribution2[] = {
0.0422564714,
0.7728131769,
0.8620072105,
0.8170243470,
0.9945166426,
0.1984626113,
0.9276007395,
0.5248677401,
0.7048731442,
0.7535610915,
0.5463053182,
0.6054137050,
0.2593339109,
0.3244756924,
0.4028105685,
0.2196438660,
0.2756980496,
0.4626345033,
0.0841498048,
0.4801435920,
0.3151815446,
0.5968274530,
0.6534962360,
0.6365893527,
0.1284928145,
0.6721899283,
0.6016264597,
0.7256847994,
0.5143220404,
0.8687852838,
0.1344069993,
0.4294689739,
0.1108499650,
0.8959778614,
0.6813699648,
0.7632335353,
0.1046082104,
0.3226924169,
0.9592376359,
0.8123961553,
0.8210336750,
0.5806060940,
0.8104785465,
0.3776035579,
0.4898308927,
0.3280951809,
0.1899302640,
0.7083087792,
0.3979903829,
0.0754221734,
0.2727227594,
0.0049476867,
0.3373789961,
0.3441676357,
0.6555256263,
0.8512584435,
0.2644237446,
0.2510367962,
0.7095772772,
0.6422276897,
0.3595680716,
0.7666331518,
0.7823634977,
0.9986928948
};

// Random doubles derived from quantum randomness (https://qrng.anu.edu.au)
static double _aDoubleRandomUniformDistribution1[] = {
0.62598670877017040467,
0.49248291507389259323,
0.02726059443179837415,
0.52383376114815388239,
0.94881962108914826333,
0.23945969797938011460,
0.22132856465995987511,
0.40164002160057182308,
0.02558438713688386477,
0.12523811179432791317,
0.67056860624381301735,
0.05494466839729881311,
0.15128037511840960857,
0.93290446929135529390,
0.51819119451781587437,
0.56565829405943493592,
0.89639821540508221456,
0.48541199928732648388,
0.08836267574199602456,
0.24251967550090505148,
0.16586885359007352595,
0.48961907867477528217,
0.82618915609454883542,
0.73600718852549053876,
0.87066246033524769869,
0.86020591848752893062,
0.85699897202914135194,
0.11452935695167901460,
0.41303841463037521702,
0.80951287799563916322,
0.75378633773898919971,
0.49633766682999376297,
0.98545748812484449544,
0.34260954016749222648,
0.56915335626507813411,
0.85065987223630355238,
0.29075114535898746357,
0.24604485121860453263,
0.70681987573003776796,
0.23564755356683848740,
0.19445599747538142750,
0.26612471807353255859,
0.26043225424381303005,
0.00087537885780199165,
0.57611537016977388272,
0.21274132250868999946,
0.68576149410247520150,
0.53597164019987906463,
0.80723091306137133570,
0.48431508160461319525,
0.05117989159074980911,
0.22820212900191732869,
0.00323988328678565153,
0.28633918134445096158,
0.61724704767476312226,
0.86797895493611381017,
0.40851001880412455855,
0.04568938942160463537,
0.05128283614073092389,
0.45920412605629752877,
0.96756956301432592105,
0.91365827487144381776,
0.44010767338302752699,
0.08153736749748720152
};

// Random doubles derived from quantum randomness (https://qrng.anu.edu.au)
static double _aDoubleRandomUniformDistribution2[] = {
0.13791062199848394430,
0.30853562390856629686,
0.47255436807785749811,
0.76494137047912110909,
0.85737237712826384305,
0.50837580073361976443,
0.09879071225648270259,
0.37142974335787939576,
0.89382622662737115497,
0.11034956939165642209,
0.95260237469393842878,
0.32369926555136014278,
0.70240408851025394699,
0.95193126496005132973,
0.29833512067425684597,
0.86891023377616471572,
0.65753247170754614536,
0.15021233235108470092,
0.51993705151156395899,
0.95605688170461269955,
0.78399271749907696931,
0.35253001866313723186,
0.27301178262116164802,
0.96813863725529664873,
0.97590087719427336527,
0.12411551533291666025,
0.02730357846216959856,
0.21329428836053378704,
0.66554383622626407541,
0.76125224975509662526,
0.55864211173109079551,
0.67051126395572986824,
0.66246756407151419597,
0.97890897008569255528,
0.05455944378960619263,
0.86547464045876951401,
0.43622915074551305806,
0.98726021620151813075,
0.81792085362753240587,
0.31793107375168283805,
0.06057444961449573412,
0.03432623241446031505,
0.29130429676615284313,
0.91094642214997097136,
0.55970045530181872927,
0.12220353062299554107,
0.64201703938238601704,
0.75006836925733483649,
0.24034675143166997700,
0.17493414521907372445,
0.89125908767524068203,
0.57105276386594203357,
0.53693818935585752770,
0.43389582086499787074,
0.82302863999955747663,
0.08636985155486539717,
0.28425740151320795268,
0.78755776097024850001,
0.90255131206116015747,
0.13030404250052839406,
0.80136503668073546207,
0.80110538175970802405,
0.59736931252456376089,
0.28568214281583553721
};

// binary64 special values
static u64 _aDoubleSpecials[] = {
0x0000000000000000uLL,  // +0
0x8000000000000000uLL,  // -0
0x7FF0000000000000uLL,  // +Inf
0xFFF0000000000000uLL,  // -Inf
0x7FF8000000000000uLL,  // NaN
0xFFF8000000000000uLL,  // NaN
};

// Random floats with magnitudes [1..2^31]
static float _aFloat31[] = {
0.8620072105 * (1uLL<<1),
0.8170243470 * (1uLL<<2),
0.9945166426 * (1uLL<<3),
0.9276007395 * (1uLL<<4),
0.5248677401 * (1uLL<<5),
0.7048731442 * (1uLL<<6),
0.7535610915 * (1uLL<<7),
0.5463053182 * (1uLL<<8),
0.6054137050 * (1uLL<<9),
0.5968274530 * (1uLL<<10),
0.6534962360 * (1uLL<<11),
0.6365893527 * (1uLL<<12),
0.6721899283 * (1uLL<<13),
0.6016264597 * (1uLL<<14),
0.7256847994 * (1uLL<<15),
0.5143220404 * (1uLL<<16),
0.8687852838 * (1uLL<<17),
0.8959778614 * (1uLL<<18),
0.6813699648 * (1uLL<<19),
0.7632335353 * (1uLL<<20),
0.9592376359 * (1uLL<<21),
0.8123961553 * (1uLL<<22),
0.8210336750 * (1uLL<<23),
0.5806060940 * (1uLL<<24),
0.8104785465 * (1uLL<<25),
0.7083087792 * (1uLL<<26),
0.6555256263 * (1uLL<<27),
0.8512584435 * (1uLL<<28),
0.7095772772 * (1uLL<<29),
0.6422276897 * (1uLL<<30),
0.7666331518 * (1uLL<<31),
};

// Random floats with magnitudes [1..2^63]
static float _aFloat63[] = {
+0.8620072105 * (1uLL<<1),
+0.8170243470 * (1uLL<<2),
+0.9945166426 * (1uLL<<3),
+0.9276007395 * (1uLL<<4),
+0.5248677401 * (1uLL<<5),
+0.7048731442 * (1uLL<<6),
+0.7535610915 * (1uLL<<7),
+0.5463053182 * (1uLL<<8),
+0.6054137050 * (1uLL<<9),
+0.5968274530 * (1uLL<<10),
+0.6534962360 * (1uLL<<11),
+0.6365893527 * (1uLL<<12),
+0.6721899283 * (1uLL<<13),
+0.6016264597 * (1uLL<<14),
+0.7256847994 * (1uLL<<15),
+0.5143220404 * (1uLL<<16),
+0.8687852838 * (1uLL<<17),
+0.8959778614 * (1uLL<<18),
+0.6813699648 * (1uLL<<19),
+0.7632335353 * (1uLL<<20),
+0.9592376359 * (1uLL<<21),
+0.8123961553 * (1uLL<<22),
+0.8210336750 * (1uLL<<23),
+0.5806060940 * (1uLL<<24),
+0.8104785465 * (1uLL<<25),
+0.7083087792 * (1uLL<<26),
+0.6555256263 * (1uLL<<27),
+0.8512584435 * (1uLL<<28),
+0.7095772772 * (1uLL<<29),
+0.7728131769 * (1uLL<<30),
+0.8620072105 * (1uLL<<31),
+0.8170243470 * (1uLL<<32),
+0.9945166426 * (1uLL<<33),
+0.9276007395 * (1uLL<<34),
+0.5248677401 * (1uLL<<35),
+0.7048731442 * (1uLL<<36),
+0.7535610915 * (1uLL<<37),
+0.5463053182 * (1uLL<<38),
+0.6054137050 * (1uLL<<39),
+0.5968274530 * (1uLL<<40),
+0.6534962360 * (1uLL<<41),
+0.6365893527 * (1uLL<<42),
+0.6721899283 * (1uLL<<43),
+0.6016264597 * (1uLL<<44),
+0.7256847994 * (1uLL<<45),
+0.5143220404 * (1uLL<<46),
+0.8687852838 * (1uLL<<47),
+0.8959778614 * (1uLL<<48),
+0.6813699648 * (1uLL<<49),
+0.7632335353 * (1uLL<<50),
+0.9592376359 * (1uLL<<51),
+0.8123961553 * (1uLL<<52),
+0.8210336750 * (1uLL<<53),
+0.5806060940 * (1uLL<<54),
+0.8104785465 * (1uLL<<55),
+0.7083087792 * (1uLL<<56),
+0.6555256263 * (1uLL<<57),
+0.8512584435 * (1uLL<<58),
+0.7095772772 * (1uLL<<59),
+0.6422276897 * (1uLL<<60),
+0.7666331518 * (1uLL<<61),
+0.7728131769 * (1uLL<<62),
+0.8620072105 * (1uLL<<63),
};

// Random integers with magnitudes [1..2^31]
static int _aInt31[] = {
(int)(0.8620072105 * (1uLL<<1)),
(int)(0.8170243470 * (1uLL<<2)),
(int)(0.9945166426 * (1uLL<<3)),
(int)(0.9276007395 * (1uLL<<4)),
(int)(0.5248677401 * (1uLL<<5)),
(int)(0.7048731442 * (1uLL<<6)),
(int)(0.7535610915 * (1uLL<<7)),
(int)(0.5463053182 * (1uLL<<8)),
(int)(0.6054137050 * (1uLL<<9)),
(int)(0.5968274530 * (1uLL<<10)),
(int)(0.6534962360 * (1uLL<<11)),
(int)(0.6365893527 * (1uLL<<12)),
(int)(0.6721899283 * (1uLL<<13)),
(int)(0.6016264597 * (1uLL<<14)),
(int)(0.7256847994 * (1uLL<<15)),
(int)(0.5143220404 * (1uLL<<16)),
(int)(0.8687852838 * (1uLL<<17)),
(int)(0.8959778614 * (1uLL<<18)),
(int)(0.6813699648 * (1uLL<<19)),
(int)(0.7632335353 * (1uLL<<20)),
(int)(0.9592376359 * (1uLL<<21)),
(int)(0.8123961553 * (1uLL<<22)),
(int)(0.8210336750 * (1uLL<<23)),
(int)(0.5806060940 * (1uLL<<24)),
(int)(0.8104785465 * (1uLL<<25)),
(int)(0.7083087792 * (1uLL<<26)),
(int)(0.6555256263 * (1uLL<<27)),
(int)(0.8512584435 * (1uLL<<28)),
(int)(0.7095772772 * (1uLL<<29)),
(int)(0.6422276897 * (1uLL<<30)),
(int)(0.7666331518 * (1uLL<<31)),
};

// Random doubles derived from quantum randomness (https://qrng.anu.edu.au)
static double _aDouble31[] = {
0.62598670877017040467 * (1uLL<<1),
0.49248291507389259323 * (1uLL<<2),
0.02726059443179837415 * (1uLL<<3),
0.52383376114815388239 * (1uLL<<4),
0.94881962108914826333 * (1uLL<<5),
0.23945969797938011460 * (1uLL<<6),
0.22132856465995987511 * (1uLL<<7),
0.40164002160057182308 * (1uLL<<8),
0.02558438713688386477 * (1uLL<<9),
0.12523811179432791317 * (1uLL<<10),
0.67056860624381301735 * (1uLL<<11),
0.05494466839729881311 * (1uLL<<12),
0.15128037511840960857 * (1uLL<<13),
0.93290446929135529390 * (1uLL<<14),
0.51819119451781587437 * (1uLL<<15),
0.56565829405943493592 * (1uLL<<16),
0.89639821540508221456 * (1uLL<<17),
0.48541199928732648388 * (1uLL<<18),
0.08836267574199602456 * (1uLL<<19),
0.24251967550090505148 * (1uLL<<20),
0.16586885359007352595 * (1uLL<<21),
0.48961907867477528217 * (1uLL<<22),
0.82618915609454883542 * (1uLL<<23),
0.73600718852549053876 * (1uLL<<24),
0.87066246033524769869 * (1uLL<<25),
0.86020591848752893062 * (1uLL<<26),
0.85699897202914135194 * (1uLL<<27),
0.11452935695167901460 * (1uLL<<28),
0.41303841463037521702 * (1uLL<<29),
0.80951287799563916322 * (1uLL<<30),
0.75378633773898919971 * (1uLL<<31),
};

// Random doubles derived from quantum randomness (https://qrng.anu.edu.au)
static double _aDouble63[] = {
0.62598670877017040467 * (1uLL<<1),
0.49248291507389259323 * (1uLL<<2),
0.02726059443179837415 * (1uLL<<3),
0.52383376114815388239 * (1uLL<<4),
0.94881962108914826333 * (1uLL<<5),
0.23945969797938011460 * (1uLL<<6),
0.22132856465995987511 * (1uLL<<7),
0.40164002160057182308 * (1uLL<<8),
0.02558438713688386477 * (1uLL<<9),
0.12523811179432791317 * (1uLL<<10),
0.67056860624381301735 * (1uLL<<11),
0.05494466839729881311 * (1uLL<<12),
0.15128037511840960857 * (1uLL<<13),
0.93290446929135529390 * (1uLL<<14),
0.51819119451781587437 * (1uLL<<15),
0.56565829405943493592 * (1uLL<<16),
0.89639821540508221456 * (1uLL<<17),
0.48541199928732648388 * (1uLL<<18),
0.08836267574199602456 * (1uLL<<19),
0.24251967550090505148 * (1uLL<<20),
0.16586885359007352595 * (1uLL<<21),
0.48961907867477528217 * (1uLL<<22),
0.82618915609454883542 * (1uLL<<23),
0.73600718852549053876 * (1uLL<<24),
0.87066246033524769869 * (1uLL<<25),
0.86020591848752893062 * (1uLL<<26),
0.85699897202914135194 * (1uLL<<27),
0.11452935695167901460 * (1uLL<<28),
0.41303841463037521702 * (1uLL<<29),
0.80951287799563916322 * (1uLL<<30),
0.75378633773898919971 * (1uLL<<31),
0.49633766682999376297 * (1uLL<<32),
0.98545748812484449544 * (1uLL<<33),
0.34260954016749222648 * (1uLL<<34),
0.56915335626507813411 * (1uLL<<35),
0.85065987223630355238 * (1uLL<<36),
0.29075114535898746357 * (1uLL<<37),
0.24604485121860453263 * (1uLL<<38),
0.70681987573003776796 * (1uLL<<39),
0.23564755356683848740 * (1uLL<<40),
0.19445599747538142750 * (1uLL<<41),
0.26612471807353255859 * (1uLL<<42),
0.26043225424381303005 * (1uLL<<43),
0.00087537885780199165 * (1uLL<<44),
0.57611537016977388272 * (1uLL<<45),
0.21274132250868999946 * (1uLL<<46),
0.68576149410247520150 * (1uLL<<47),
0.53597164019987906463 * (1uLL<<48),
0.80723091306137133570 * (1uLL<<49),
0.48431508160461319525 * (1uLL<<50),
0.05117989159074980911 * (1uLL<<51),
0.22820212900191732869 * (1uLL<<52),
0.00323988328678565153 * (1uLL<<53),
0.28633918134445096158 * (1uLL<<54),
0.61724704767476312226 * (1uLL<<55),
0.86797895493611381017 * (1uLL<<56),
0.40851001880412455855 * (1uLL<<57),
0.04568938942160463537 * (1uLL<<58),
0.05128283614073092389 * (1uLL<<59),
0.45920412605629752877 * (1uLL<<60),
0.96756956301432592105 * (1uLL<<61),
0.91365827487144381776 * (1uLL<<62),
0.44010767338302752699 * (1uLL<<63),
};

static long long _aLlong63[] = {
(long long)(0.59248291507389259323 * (1uLL<<1)),
(long long)(0.72726059443179837415 * (1uLL<<2)),
(long long)(0.52383376114815388239 * (1uLL<<3)),
(long long)(0.94881962108914826333 * (1uLL<<4)),
(long long)(0.23945969797938011460 * (1uLL<<5)),
(long long)(0.22132856465995987511 * (1uLL<<6)),
(long long)(0.40164002160057182308 * (1uLL<<7)),
(long long)(0.02558438713688386477 * (1uLL<<8)),
(long long)(0.12523811179432791317 * (1uLL<<9)),
(long long)(0.67056860624381301735 * (1uLL<<10)),
(long long)(0.05494466839729881311 * (1uLL<<11)),
(long long)(0.15128037511840960857 * (1uLL<<12)),
(long long)(0.93290446929135529390 * (1uLL<<13)),
(long long)(0.51819119451781587437 * (1uLL<<14)),
(long long)(0.56565829405943493592 * (1uLL<<15)),
(long long)(0.89639821540508221456 * (1uLL<<16)),
(long long)(0.48541199928732648388 * (1uLL<<17)),
(long long)(0.08836267574199602456 * (1uLL<<18)),
(long long)(0.24251967550090505148 * (1uLL<<19)),
(long long)(0.16586885359007352595 * (1uLL<<20)),
(long long)(0.48961907867477528217 * (1uLL<<21)),
(long long)(0.82618915609454883542 * (1uLL<<22)),
(long long)(0.73600718852549053876 * (1uLL<<23)),
(long long)(0.87066246033524769869 * (1uLL<<24)),
(long long)(0.86020591848752893062 * (1uLL<<25)),
(long long)(0.85699897202914135194 * (1uLL<<26)),
(long long)(0.11452935695167901460 * (1uLL<<27)),
(long long)(0.41303841463037521702 * (1uLL<<28)),
(long long)(0.80951287799563916322 * (1uLL<<29)),
(long long)(0.75378633773898919971 * (1uLL<<30)),
(long long)(0.49633766682999376297 * (1uLL<<31)),
(long long)(0.98545748812484449544 * (1uLL<<32)),
(long long)(0.34260954016749222648 * (1uLL<<33)),
(long long)(0.56915335626507813411 * (1uLL<<34)),
(long long)(0.85065987223630355238 * (1uLL<<35)),
(long long)(0.29075114535898746357 * (1uLL<<36)),
(long long)(0.24604485121860453263 * (1uLL<<37)),
(long long)(0.70681987573003776796 * (1uLL<<38)),
(long long)(0.23564755356683848740 * (1uLL<<39)),
(long long)(0.19445599747538142750 * (1uLL<<40)),
(long long)(0.26612471807353255859 * (1uLL<<41)),
(long long)(0.26043225424381303005 * (1uLL<<42)),
(long long)(0.00087537885780199165 * (1uLL<<43)),
(long long)(0.57611537016977388272 * (1uLL<<44)),
(long long)(0.21274132250868999946 * (1uLL<<45)),
(long long)(0.68576149410247520150 * (1uLL<<46)),
(long long)(0.53597164019987906463 * (1uLL<<47)),
(long long)(0.80723091306137133570 * (1uLL<<48)),
(long long)(0.48431508160461319525 * (1uLL<<49)),
(long long)(0.05117989159074980911 * (1uLL<<50)),
(long long)(0.22820212900191732869 * (1uLL<<51)),
(long long)(0.00323988328678565153 * (1uLL<<52)),
(long long)(0.28633918134445096158 * (1uLL<<53)),
(long long)(0.61724704767476312226 * (1uLL<<54)),
(long long)(0.86797895493611381017 * (1uLL<<55)),
(long long)(0.40851001880412455855 * (1uLL<<56)),
(long long)(0.04568938942160463537 * (1uLL<<57)),
(long long)(0.05128283614073092389 * (1uLL<<58)),
(long long)(0.45920412605629752877 * (1uLL<<59)),
(long long)(0.96756956301432592105 * (1uLL<<60)),
(long long)(0.91365827487144381776 * (1uLL<<61)),
(long long)(0.44010767338302752699 * (1uLL<<62)),
(long long)(0.08153736749748720152 * (1uLL<<63)), };

/*********************************************************************
*
* Static data
*
**********************************************************************
*/
static u64 _aOverhead[MODE_MAX]; // Overhead of calling a function that simply returns, per mode.

/*********************************************************************
*
* Local functions
*
**********************************************************************
*/
#if defined (__clang__) && !defined(__CC_ARM)
static void* _MEMSET(void *str, int c, int n) {
unsigned char* p;
p = (unsigned char*)str;
while (n > 0) {
*p++ = (unsigned char)c;
n--;
}

return str;
}
#endif

/*********************************************************************
*
*       _Logf()
*
*  Function description
*    Log a formatted string via semihosting or toolchain internal loggin.
*/
static void _Logf(const char *sFormat, ...) {
va_list ap;
//
va_start(ap, sFormat);
#ifdef SEMIHOST
SEGGER_SEMIHOST_Writef(sFormat, &ap);
#else
vprintf(sFormat, ap);
#endif
}

/*********************************************************************
*
*       _GetTime()
*
*  Function description
*    Get the current time from a performance counter.
*/
static u32 _GetTime(void) {
return DWT_CYCCNT;
}

/*********************************************************************
*
*       NullVoidReturnVoid()
*
*  Function description
*    Naked function to measure function call overhead.
*/
#if defined(__CC_ARM)
__asm void __attribute__((noinline)) NullVoidReturnVoid(void) {
bx lr;
};
#elif defined (__ICCARM__) || defined (__SES_ARM) || defined(__GNUC__)
void __attribute__((naked, noinline, section(".fast"))) NullVoidReturnVoid(void) {
__asm("bx lr");
};
#endif

/*********************************************************************
*
*       _Time()
*
*  Function description
*    Get the time of executing a function.
*/
static u32 __attribute__((noinline, section(".fast"))) _Time(ExecContext *pContext) {
u32 t0;
u32 t1;
//
t0 = _GetTime();
switch (pContext->Mode) {
case MODE_INT_RETURN_FLOAT:            pContext->Function.pfIntReturnFloat          (pContext->v0.i);                 break;
case MODE_INT_RETURN_DOUBLE:           pContext->Function.pfIntReturnDouble         (pContext->v0.i);                 break;
case MODE_LLONG_RETURN_FLOAT:          pContext->Function.pfLlongReturnFloat        (pContext->v0.l);                 break;
case MODE_LLONG_RETURN_DOUBLE:         pContext->Function.pfLlongReturnDouble       (pContext->v0.l);                 break;
case MODE_FLOAT_RETURN_INT:            pContext->Function.pfFloatReturnInt          (pContext->v0.f);                 break;
case MODE_FLOAT_RETURN_LLONG:          pContext->Function.pfFloatReturnLlong        (pContext->v0.f);                 break;
case MODE_FLOAT_RETURN_FLOAT:          pContext->Function.pfFloatReturnFloat        (pContext->v0.f);                 break;
case MODE_FLOAT_RETURN_DOUBLE:         pContext->Function.pfFloatReturnDouble       (pContext->v0.f);                 break;
case MODE_DOUBLE_RETURN_INT:           pContext->Function.pfDoubleReturnInt         (pContext->v0.d);                 break;
case MODE_DOUBLE_RETURN_FLOAT:         pContext->Function.pfDoubleReturnFloat       (pContext->v0.d);                 break;
case MODE_DOUBLE_RETURN_DOUBLE:        pContext->Function.pfDoubleReturnDouble      (pContext->v0.d);                 break;
case MODE_DOUBLE_RETURN_LLONG:         pContext->Function.pfDoubleReturnLlong       (pContext->v0.d);                 break;
case MODE_INT_INT_RETURN_INT:          pContext->Function.pfIntIntReturnInt         (pContext->v0.i, pContext->v1.i); break;
case MODE_LLONG_LLONG_RETURN_LLONG:    pContext->Function.pfLlongLlongReturnLlong   (pContext->v0.l, pContext->v1.l); break;
case MODE_FLOAT_FLOAT_RETURN_INT:      pContext->Function.pfFloatFloatReturnInt     (pContext->v0.f, pContext->v1.f); break;
case MODE_FLOAT_FLOAT_RETURN_FLOAT:    pContext->Function.pfFloatFloatReturnFloat   (pContext->v0.f, pContext->v1.f); break;
case MODE_DOUBLE_DOUBLE_RETURN_INT:    pContext->Function.pfDoubleDoubleReturnInt   (pContext->v0.d, pContext->v1.d); break;
case MODE_DOUBLE_DOUBLE_RETURN_DOUBLE: pContext->Function.pfDoubleDoubleReturnDouble(pContext->v0.d, pContext->v1.d); break;
case MODE_MAX: break;
}
t1 = _GetTime();
return t1 - t0;
}

/*********************************************************************
*
*       _GetSeqName()
*
*  Function description
*    Get the name of a sequence by its id.
*/
static const char * _GetSeqName(unsigned Seq) {
switch (Seq) {
case SEQUENCE_SPECIAL_F32xF32:
case SEQUENCE_SPECIAL_F64xF64:
return "+-Inf, +-NaN, +-0";
case SEQUENCE_TYPICAL_F32xF32:
case SEQUENCE_TYPICAL_F64xF64:
return "Random distribution over (0, 1), operands differ";
case SEQUENCE_31_INT:
case SEQUENCE_31_FLOAT:
case SEQUENCE_31_DOUBLE:
return "Random distribution with magnitudes (1..2^31)";
case SEQUENCE_31_INT | SEQUENCE_SIGNED:
case SEQUENCE_31_FLOAT | SEQUENCE_SIGNED:
case SEQUENCE_31_DOUBLE | SEQUENCE_SIGNED:
return "Random distribution with magnitudes (1..2^31), signed";
case SEQUENCE_63_LLONG:
case SEQUENCE_63_FLOAT:
case SEQUENCE_63_DOUBLE:
return "Random distribution with magnitudes (1..2^63)";
case SEQUENCE_63_LLONG | SEQUENCE_SIGNED:
case SEQUENCE_63_FLOAT | SEQUENCE_SIGNED:
case SEQUENCE_63_DOUBLE | SEQUENCE_SIGNED:
return "Random distribution with magnitudes (1..2^63), signed";
default:
return "<unknown>";
}
}

/*********************************************************************
*
*       _InitSeq()
*
*  Function description
*    Initialize a sequence.
*/
static void _InitSeq(ExecSequence *pSeq, SEQUENCE seq) {
pSeq->seq = seq;
pSeq->index = 0;
pSeq->last  = 0;
pSeq->sign  = 1;
}

/*********************************************************************
*
*       _NextSeq()
*
*  Function description
*    Get and prepare the next sequence.
*/
static int _NextSeq(ExecSequence *pSeq, ExecContext *pCtx) {
//
if (pSeq->last) {
if (pSeq->seq & SEQUENCE_SIGNED) {
pSeq->sign = -pSeq->sign;
pSeq->index = 0;
pSeq->last  = 0;
if (pSeq->sign == 1) {
return 0;
}
} else {
return 0;
}
}
//
switch (pSeq->seq & 0x1f) {
case SEQUENCE_END:
pSeq->last = 1;
break;
//
case SEQUENCE_SPECIAL_F32xF32:
pCtx->v0.i = _aFloatSpecials[pSeq->index % COUNTOF(_aFloatSpecials)];
pCtx->v1.i = _aFloatSpecials[pSeq->index / COUNTOF(_aFloatSpecials)];
++pSeq->index;
pSeq->last = pSeq->index >= COUNTOF(_aFloatSpecials)*COUNTOF(_aFloatSpecials);
break;
//
case SEQUENCE_TYPICAL_F32xF32:
pCtx->v0.f = _aFloatRandomUniformDistribution1[pSeq->index % COUNTOF(_aFloatRandomUniformDistribution1)];
pCtx->v1.f = _aFloatRandomUniformDistribution2[pSeq->index / COUNTOF(_aFloatRandomUniformDistribution1)];
++pSeq->index;
pSeq->last = pSeq->index >= COUNTOF(_aFloatRandomUniformDistribution1)*COUNTOF(_aFloatRandomUniformDistribution2);
break;
//
case SEQUENCE_SPECIAL_F64xF64:
++pSeq->index;
break;
//
case SEQUENCE_TYPICAL_F64xF64:
++pSeq->index;
break;
//
case SEQUENCE_31_INT:
pCtx->v0.i = pSeq->sign * _aInt31[pSeq->index];
++pSeq->index;
pSeq->last = pSeq->index >= COUNTOF(_aInt31);
break;
//
case SEQUENCE_31_FLOAT:
pCtx->v0.f = pSeq->sign * _aFloat31[pSeq->index];
++pSeq->index;
pSeq->last = pSeq->index >= COUNTOF(_aFloat31);
break;
//
case SEQUENCE_31_DOUBLE:
pCtx->v0.d = pSeq->sign * _aDouble31[pSeq->index];
++pSeq->index;
pSeq->last = pSeq->index >= COUNTOF(_aLlong63);
break;
//
case SEQUENCE_63_LLONG:
pCtx->v0.l = pSeq->sign * _aLlong63[pSeq->index];
++pSeq->index;
pSeq->last = pSeq->index >= COUNTOF(_aLlong63);
break;
//
case SEQUENCE_63_FLOAT:
pCtx->v0.f = pSeq->sign * _aFloat63[pSeq->index];
++pSeq->index;
pSeq->last = pSeq->index >= COUNTOF(_aLlong63);
break;
//
case SEQUENCE_63_DOUBLE:
pCtx->v0.d = pSeq->sign * _aDouble63[pSeq->index];
++pSeq->index;
pSeq->last = pSeq->index >= COUNTOF(_aLlong63);
break;
//
default:
_Logf("Unknown sequence!\n");
pSeq->last = 1;
break;
}
//
return 1;
}

/*********************************************************************
*
*       _Benchmark()
*
*  Function description
*    Run a benchmark function.
*/
static void _Benchmark(void *pFn, ExecMode Mode, const char *sLabel, ...) {
va_list      ap;
u32          Min;
u32          Max;
u32          Cnt;
u32          Tot;
u32          t;
SEQUENCE     SelSeq;
ExecContext  Ctx;
ExecSequence Seq;
//
va_start(ap, sLabel);
//
Ctx.Function.pfVoidReturnVoid = (VoidFunc)pFn;
Ctx.Mode = Mode;
//
SelSeq = (SEQUENCE)va_arg(ap, unsigned);
while (SelSeq != SEQUENCE_END) {
_InitSeq(&Seq, SelSeq);
Min = ~0u;
Max = 0u;
Tot = 0;
Cnt = 0;
while (_NextSeq(&Seq, &Ctx)) {
t = _Time(&Ctx);
Cnt += 1;
Tot += t;
if (t < Min) { Min = t; } if (t > Max) {
Max = t;
}
if (t > 100) {
t = _Time(&Ctx);
}
}
_Logf("%-15s  %6u  %6u  %6.1f    %s\n", sLabel, Min, Max, (float)Tot / Cnt, _GetSeqName(SelSeq));
SelSeq = (SEQUENCE)va_arg(ap, unsigned);
}
}

/*********************************************************************
*
*
*  Function description
*    Get the overheads of calling functions.
*/
static void _CalculateOverheads(void) {
ExecContext Context;
//
memset(&Context, 0, sizeof(Context));
Context.Function.pfVoidReturnVoid = NullVoidReturnVoid;
//
Context.Mode = (ExecMode)0;
while (Context.Mode < MODE_MAX) {
Context.Mode = (ExecMode)(Context.Mode+1);
}
}

/*********************************************************************
*
*       Global functions
*
**********************************************************************
*/
/*********************************************************************
*
*       main()
*
*  Function description
*    Application entry point.
*/
int main(void) {
_Logf("IEEE-754 Floating-point Library Benchmarks\n");
_Logf("Copyright (c) 2018-2019 SEGGER Microcontroller GmbH.\n\n");
//
_Logf("Target: Cortex-M");
_Logf("\n\n");
//
_Logf("Function            Min     Max     Avg    Description\n");
_Logf("--------------   ------  ------  ------    -------------------------------\n");
//
//
_Benchmark((void *)__aeabi_fadd,   MODE_FLOAT_FLOAT_RETURN_FLOAT,    "__aeabi_fadd",   SPECIAL(SEQUENCE_SPECIAL_F32xF32) SEQUENCE_TYPICAL_F32xF32, SEQUENCE_END);
_Benchmark((void *)__aeabi_fsub,   MODE_FLOAT_FLOAT_RETURN_FLOAT,    "__aeabi_fsub",   SPECIAL(SEQUENCE_SPECIAL_F32xF32) SEQUENCE_TYPICAL_F32xF32, SEQUENCE_END);
_Benchmark((void *)__aeabi_frsub,  MODE_FLOAT_FLOAT_RETURN_FLOAT,    "__aeabi_frsub",  SPECIAL(SEQUENCE_SPECIAL_F32xF32) SEQUENCE_TYPICAL_F32xF32, SEQUENCE_END);
_Benchmark((void *)__aeabi_fmul,   MODE_FLOAT_FLOAT_RETURN_FLOAT,    "__aeabi_fmul",   SPECIAL(SEQUENCE_SPECIAL_F32xF32) SEQUENCE_TYPICAL_F32xF32, SEQUENCE_END);
_Benchmark((void *)__aeabi_fdiv,   MODE_FLOAT_FLOAT_RETURN_FLOAT,    "__aeabi_fdiv",   SPECIAL(SEQUENCE_SPECIAL_F32xF32) SEQUENCE_TYPICAL_F32xF32, SEQUENCE_END);
_Benchmark((void *)__aeabi_fcmplt, MODE_FLOAT_FLOAT_RETURN_INT,      "__aeabi_fcmplt", SPECIAL(SEQUENCE_SPECIAL_F32xF32) SEQUENCE_TYPICAL_F32xF32, SEQUENCE_END);
_Benchmark((void *)__aeabi_fcmple, MODE_FLOAT_FLOAT_RETURN_INT,      "__aeabi_fcmple", SPECIAL(SEQUENCE_SPECIAL_F32xF32) SEQUENCE_TYPICAL_F32xF32, SEQUENCE_END);
_Benchmark((void *)__aeabi_fcmpgt, MODE_FLOAT_FLOAT_RETURN_INT,      "__aeabi_fcmpgt", SPECIAL(SEQUENCE_SPECIAL_F32xF32) SEQUENCE_TYPICAL_F32xF32, SEQUENCE_END);
_Benchmark((void *)__aeabi_fcmpge, MODE_FLOAT_FLOAT_RETURN_INT,      "__aeabi_fcmpge", SPECIAL(SEQUENCE_SPECIAL_F32xF32) SEQUENCE_TYPICAL_F32xF32, SEQUENCE_END);
_Benchmark((void *)__aeabi_fcmpeq, MODE_FLOAT_FLOAT_RETURN_INT,      "__aeabi_fcmpeq", SPECIAL(SEQUENCE_SPECIAL_F32xF32) SEQUENCE_TYPICAL_F32xF32, SEQUENCE_END);
_Benchmark((void *)__aeabi_dadd,   MODE_DOUBLE_DOUBLE_RETURN_DOUBLE, "__aeabi_dadd",   SPECIAL(SEQUENCE_SPECIAL_F64xF64) SEQUENCE_TYPICAL_F64xF64, SEQUENCE_END);
_Benchmark((void *)__aeabi_dsub,   MODE_DOUBLE_DOUBLE_RETURN_DOUBLE, "__aeabi_dsub",   SPECIAL(SEQUENCE_SPECIAL_F64xF64) SEQUENCE_TYPICAL_F64xF64, SEQUENCE_END);
_Benchmark((void *)__aeabi_drsub,  MODE_DOUBLE_DOUBLE_RETURN_DOUBLE, "__aeabi_drsub",  SPECIAL(SEQUENCE_SPECIAL_F64xF64) SEQUENCE_TYPICAL_F64xF64, SEQUENCE_END);
_Benchmark((void *)__aeabi_dmul,   MODE_DOUBLE_DOUBLE_RETURN_DOUBLE, "__aeabi_dmul",   SPECIAL(SEQUENCE_SPECIAL_F64xF64) SEQUENCE_TYPICAL_F64xF64, SEQUENCE_END);
_Benchmark((void *)__aeabi_ddiv,   MODE_DOUBLE_DOUBLE_RETURN_DOUBLE, "__aeabi_ddiv",   SPECIAL(SEQUENCE_SPECIAL_F64xF64) SEQUENCE_TYPICAL_F64xF64, SEQUENCE_END);
_Benchmark((void *)__aeabi_dcmplt, MODE_DOUBLE_DOUBLE_RETURN_INT,    "__aeabi_dcmplt", SPECIAL(SEQUENCE_SPECIAL_F64xF64) SEQUENCE_TYPICAL_F64xF64, SEQUENCE_END);
_Benchmark((void *)__aeabi_dcmple, MODE_DOUBLE_DOUBLE_RETURN_INT,    "__aeabi_dcmple", SPECIAL(SEQUENCE_SPECIAL_F64xF64) SEQUENCE_TYPICAL_F64xF64, SEQUENCE_END);
_Benchmark((void *)__aeabi_dcmpgt, MODE_DOUBLE_DOUBLE_RETURN_INT,    "__aeabi_dcmpgt", SPECIAL(SEQUENCE_SPECIAL_F64xF64) SEQUENCE_TYPICAL_F64xF64, SEQUENCE_END);
_Benchmark((void *)__aeabi_dcmpge, MODE_DOUBLE_DOUBLE_RETURN_INT,    "__aeabi_dcmpge", SPECIAL(SEQUENCE_SPECIAL_F64xF64) SEQUENCE_TYPICAL_F64xF64, SEQUENCE_END);
_Benchmark((void *)__aeabi_dcmpeq, MODE_DOUBLE_DOUBLE_RETURN_INT,    "__aeabi_dcmpeq", SPECIAL(SEQUENCE_SPECIAL_F64xF64) SEQUENCE_TYPICAL_F64xF64, SEQUENCE_END);

_Benchmark((void *)__aeabi_f2iz,   MODE_FLOAT_RETURN_INT,            "__aeabi_f2iz",   SEQUENCE_31_FLOAT | SEQUENCE_SIGNED, SEQUENCE_END);
_Benchmark((void *)__aeabi_f2uiz,  MODE_FLOAT_RETURN_INT,            "__aeabi_f2uiz",  SEQUENCE_31_FLOAT, SEQUENCE_END);
_Benchmark((void *)__aeabi_f2lz,   MODE_FLOAT_RETURN_LLONG,          "__aeabi_f2lz",   SEQUENCE_63_FLOAT | SEQUENCE_SIGNED, SEQUENCE_END);
_Benchmark((void *)__aeabi_f2ulz,  MODE_FLOAT_RETURN_LLONG,          "__aeabi_f2ulz",  SEQUENCE_63_FLOAT, SEQUENCE_END);
_Benchmark((void *)__aeabi_i2f,    MODE_INT_RETURN_FLOAT,            "__aeabi_i2f",    SEQUENCE_31_INT | SEQUENCE_SIGNED, SEQUENCE_END);
_Benchmark((void *)__aeabi_ui2f,   MODE_INT_RETURN_FLOAT,            "__aeabi_ui2f",   SEQUENCE_31_INT, SEQUENCE_END);
_Benchmark((void *)__aeabi_l2f,    MODE_LLONG_RETURN_FLOAT,          "__aeabi_l2f",    SEQUENCE_63_LLONG | SEQUENCE_SIGNED, SEQUENCE_END);
_Benchmark((void *)__aeabi_ul2f,   MODE_LLONG_RETURN_FLOAT,          "__aeabi_ul2f",   SEQUENCE_63_LLONG, SEQUENCE_END);

_Benchmark((void *)__aeabi_d2iz,   MODE_DOUBLE_RETURN_INT,           "__aeabi_d2iz",   SEQUENCE_31_DOUBLE | SEQUENCE_SIGNED, SEQUENCE_END);
_Benchmark((void *)__aeabi_d2uiz,  MODE_DOUBLE_RETURN_INT,           "__aeabi_d2uiz",  SEQUENCE_31_DOUBLE, SEQUENCE_END);
_Benchmark((void *)__aeabi_d2lz,   MODE_DOUBLE_RETURN_LLONG,         "__aeabi_d2lz",   SEQUENCE_63_DOUBLE | SEQUENCE_SIGNED, SEQUENCE_END);
_Benchmark((void *)__aeabi_d2ulz,  MODE_DOUBLE_RETURN_LLONG,         "__aeabi_d2ulz",  SEQUENCE_63_DOUBLE, SEQUENCE_END);
_Benchmark((void *)__aeabi_i2d,    MODE_INT_RETURN_DOUBLE,           "__aeabi_i2d",    SEQUENCE_31_INT | SEQUENCE_SIGNED, SEQUENCE_END);
_Benchmark((void *)__aeabi_ui2d,   MODE_INT_RETURN_DOUBLE,           "__aeabi_ui2d",   SEQUENCE_31_INT, SEQUENCE_END);
_Benchmark((void *)__aeabi_l2d,    MODE_LLONG_RETURN_DOUBLE,         "__aeabi_l2d",    SEQUENCE_63_LLONG | SEQUENCE_SIGNED, SEQUENCE_END);
_Benchmark((void *)__aeabi_ul2d,   MODE_LLONG_RETURN_DOUBLE,         "__aeabi_ul2d",   SEQUENCE_63_LLONG, SEQUENCE_END);

_Benchmark((void *)__aeabi_f2d,    MODE_FLOAT_RETURN_DOUBLE,         "__aeabi_f2d",    SEQUENCE_63_FLOAT | SEQUENCE_SIGNED, SEQUENCE_END);
_Benchmark((void *)__aeabi_d2f,    MODE_DOUBLE_RETURN_FLOAT,         "__aeabi_d2f",    SEQUENCE_63_DOUBLE | SEQUENCE_SIGNED, SEQUENCE_END);
//
_Logf("\n");
_Logf("STOP.\n");
//
return 0;
}
```