I am currently testing some new (embedded) processors for their double-precision numeric performance.
The FPU capabilities vary wildly between platforms; For example, the ARM Cortex-A8 has a double precision FPU, takes 9 cycles per operation. The Cortex-A9 also takes 9 cycles, but is able to be fully pipelined, whereas the Cortex-A15 apparently (finally!) has a single cycle double.
Up until now, I have just used linear algebra (e.g. Eigen or ATLAS) for benchmarking, which represents a good subset of our own computational demands, but is deficient as a benchmark for well-documented reasons.
So, what numerical benchmarks, if any, meet the following criteria?
- Which other benchmarks (even if flawed/limited) are generally accepted? A good example for "general acceptance" would be the ability to find results for common (commodity) processors without much time investment using google.
- As I am generally interested in embedded systems, I much prefer applications that can cleanly be cross-compiled - Self-tuning packages are a pain on embedded systems (e.g. ATLAS is a good example)
- Even better, packages that only minimally depend on operating system services (or better yet, just libc or similar) allows for testing on a much wider range of systems.
Update: Some context
Linear algebra does indeed cover a large subset of our computational demands (which was listed in the OP). It does, however, benefit greatly where the operations can be pipelined. This isn't universally true for all our computational demands - there are multiple smaller solvers and algorithms of various types scattered throughout our code base. I doubt I am aware of all of them. Plus, since we typically maintain an embedded system for 5 years (or more!) after release, our current suite of applications may not represent future demands, the nature of which I cannot entirely predict (Note 1).
The second reasons is than I cannot purchase development kits, port code, build a cross-compiler, run benchmarks, etc for the literally hundreds of different SoCs that exist on the market. If there are few, well-known benchmarks that become ubiquitous (Coremark is an example, but it is not numeric-specific), then it makes the job of processor selection that much easier.
Note 1: A good example is half-way through the life of a product, a floating point application that had significant amounts of branching was developed (by an ex-HPC guy, so I hope he know what he was doing!). Had we selected a processor that was very heavily pipelined, we may have been caught out.