• Snapper System Modules
• Data Storage Solutions
• Electronic Design
• ARM Development Tools
• Tools Information
• ARM RealView
• RVDS
• Compilation
• Debugging
• Simulator
• Multi-core and DSP
• XScale
• RVCT for Brew
• RealView ICE
• RealView Trace
• Integrator
• Versatile
• Multi-ICE
• MultiTrace
• Tools
• Terms & Conditions
• Contact
• Testimonials
• ARM Tools Market
• About Us
• Blog
• Home

RealView Instruction Set Simulator (ISS)

Evaluate performance on various hardware options

The RealView Instruction Set Simulator (ISS) product is a software simulator all available ARM cores. It requires the RealView Debugger to control it. It includes the following:

• Simulation of all available ARM cores on supported platforms
• High performance - typically 20 MHz on modern host hardware (dependent on configuration)
• Supports floating point hardware, ARM and Thumb and some support for simulating real development boards
• Real time simulation allows an accurate run-time calculation to be made using either the standard C clock() function, or the debugger
• Supports any processor clock speed as well as memory speed, width and type for any area of address space
• Allows user-supplied peripherals and memory models to be added for complete customisation
• ISS is just another target in RVD, so is provides the same GUI environment, with full source-level debugging, etc.

RVISS supports Windows and Unix (Linux / Solaris) host platforms, and requires RealView Debugger.

When is a simulator useful?

For some people simulators are indispensible. For others they are a curiosity. For those still in the dark, here's a brief overview of what a simulator can do for you:

• Execution of ARM code on non-ARM hardware, such as an x86 or Sun Solaris box
• Simulation of all ARM cores including things like various types of floating point hardware
• Simulation of cache and MMU hardware where the core supports it. In the simple case you can just specify that you want the cache and MMU 'on' and it will pretend that you have specified standard 'flat' page tables.

If you want to know how long a program or function would take to execute, you can find out:

• Specify the processor type
• Specify each region of memory and its type and size (optional)
• Call clock() at the start of the program/function, and again at the end. The difference is the time taken in 1/100ths of a second. You can also use the debugger GUI to see this information by setting breakpoints at the beginning and end, and checking the change in the internal clock.
• You can see the number of processor cycles of each type which have occured, and even the number of read and write accesses to each area of memory.

Using the simulation results:

• You can quickly identify bottlenecks which hold your system up.
• You can see how well your code runs with different processor cache sizes
• You can decide whether 16-bit or 32-bit memory is required to hit performance targets
• You can compare your planned hardware with the 'ideal' (zero wait-state 32-bit memory)

ARM has an application note which explains 'how to benchmark with ARMulator'. ARMulator is the old name of the simulator.