There is a nice discussion on StackOverflow regarding floating point vs integer operations. In short, the performance of the operations depends a lot on
- processor architecture
- how the data is stored in memory and in which order it is accessed
- if (and which) SSE/AVX/AVX2/etc instructions are used (and how efficiently)
This probably provides some insight into the questing #1 regarding the generality of integer-types being faster than floats.
However, FLOPS are well known for a good reason as it is a standard measure in the performance of the numerical software. In numerical computing, it is generally not easy to go from floating types to integer without
- changing the nature of mathematical operations (division, trigonometric functions, square roots, special functions, most of the linear algebra, etc)
- having to implement special (long) integer arithmetic to "emulate" those operations – which will definitely negate all the possible benefits of using integer types instead of floating types.
Of course, there are probably counter-examples, where the usage of integer types is natural (say, incidence matrices for graphs).
Now, regarding the performance metrics. A slightly simplified formula from Wiki:
Also, see the discussion in this question on CompSci and this question on SO.
Now, for judging integer operations, we can have IPS
Notice the difference:
For FLOPS, we use FLOPS/cycle, while for IPS, we use general instructions per cycle. Again, it will depend on the processor, if it can actually do more integer-arithmetic operations per cycle (compared to FLOPS). Notice, that there is some averaging done on many levels:
- average # instructions per cycle
- hidden dependence on the order of instructions
- ... and mainly on the data access pattern - which is the common bottleneck for the modern codes.
So, in short, I would answer one question #2 that floating-point calculations have been optimized a lot, so the unnatural use of integer types is very unlikely to bring you any dividends.
Small extra note:
I would also look into half-precision arithmetic. It may be helpful in your tasks provided that the architecture you are using can exploit it efficiently.