Simbench is a set of microbenchmarks designed to run on full system simulators,
in order to evaluate the performance of various features required for full
system simulation. 

1. Structure of Simbench

Simbench consists of two main components: a Simbench image, plus a host program 
to time the various benchmarks. Rather than time each benchmark using a timer
within the simulator (which may not be accurate or properly calibrated), timing
is performed by the host machine.

2. Compiling Simbench

The actual Simbench image must be compiled for a specific architecture and 
platform. These are specified via environment variables. For example, to compile
for the ARM Versatile platform:

$ export ARCH=arm
$ export PLATFORM=versatile
$ make

A cross compiler must be available for the target architecture, specified in

3. Running Simbench

To run Simbench for the ARM Versatile platform using QEMU:

$ stdbuf -o0 qemu-system-arm -machine versatileab -kernel out/arm/versatile/simbench -nographic -m 512 | host/host

The stdbuf program is used to disable output buffering so that the timing 
information produced by Simbench is delivered to the host application in a 
timely fashion.

Note that some platforms require more than the default amount of memory
provided by QEMU (e.g., the versatileab platform, as seen above):

versatileab:   512
vexpress-a15: 2048
vexpress-a9:  1024

4. Debugging Simbench

Simbench has built in lightweight logging. To enable the debugging logs, define
the environment variable SIMBENCH_DEBUG=1.

5. Supported environments

Simbench should be executable on a variety of architectures and platforms. The
requirements placed on the platform are quite small, so porting to a new 
platform should be quite straightforward. Porting to a new architecture is a 
little more involved (and requires booting from reset, setting up page tables,
etc) but should not be too much work.

So far, the following architectures and platforms are supported:

	Versatile Application Baseboard
	Realview Platform Baseboard (A8)
	Arndale Board

	Native -- works in QEMU too