Print indd

1
Introduction
Hardware platforms are rising in complexity and have an increasing amount
of configurable parts. For example, a developer must decide which processors
to integrate into the system. There are a lot of different architectures which
are available with different characteristics. ARM offers the Cortex-R series for
embedded devices which are more predictable but comparably slow and the
Cortex-A series for entertainment devices which achieve a much higher perfor-
mance but sacrifice the simplicity required for statically determining execution
time. Additionally, the single models of the series have different characteristics
like in-order (e.g. Cortex-A 53) or out-of-order execution (e.g. Cortex-A 57).
Apart from ARM there are also other instruction set architectures like MIPS or
PowerPC that might be suitable. Before manufacturing the hardware, the plat-
form architect will evaluate its algorithms on a simulation framework providing
certain parameters like performance and energy consumption which she can use
to decide which core and system layout to deploy.
Simulation can be done on different levels. The most accurate but also the
slowest method is to use tools for Application Specific Integrated Circuit (ASIC)
validation. For a brief evaluation, it is not necessary to have a completely exact
result on the electrical level. Thus, a simulation approach implementing the
c
 Springer International Publishing AG, part of Springer Nature 2018
M. Berekovic et al. (Eds.): ARCS 2018, LNCS 10793, pp. 85–96, 2018.
https://doi.org/10.1007/978-3-319-77610-1
_
7

---

86
S. Rachuj et al.
architectures in a high level language like SystemC is sensible since the exe-
cution speed of the target software is increased. The second level offers a cycle
accurate simulation of the hardware. Cycle accurate means that the pipeline and
superscalar architecture is modelled to behave like the real hardware regarding
the cycle count per instruction. In comparison to instruction accurate emulation
which just executes an instruction each cycle without considering the actual
hardware layout, this approach is still very slow. However, the instruction accu-
rate emulation misses the architectural characteristics. For simple deterministic
in-order architectures, this method might suffice. But complex out-of-order pro-
cessor designs are usually much faster as they can execute multiple instructions
per cycle which makes the results of an instruction accurate simulation insuffi-
cient for the assessment of the processor.
Combining these two kinds of CPU simulation can result in improved accu-
racy while avoiding an enormous rise in simulation time in comparison to only
using the instruction or cycle accurate model. For this paper such a methodology
was developed based on the observation that most programs mainly consist of
loops. Not each of the loops’ iteration must be simulated in great detail. After a
few runs of the loop body, the pipeline is filled with only the instruction stream of
the loop. Hence, not much deviation between further iterations is expected. This
allows to extrapolate the results of few exactly analyzed iterations to the many
inaccurately simulated ones. In this work, gem5 [
2
] is used as it already provides
a cycle accurate and an instruction accurate model which can be exchanged as
required.
While this method is capable of increasing the accuracy with only a mod-
erate growth of the simulation time, the real benefits depend on the software
that is analyzed. As example applications a radar processing algorithm often
used in the automotive industry and the High Efficiency Video Codec decoding
implementation known from entertainment products are assessed.
In the following section some related works are presented which try to solve
the same issue. Afterwards, the methodology is presented in detail. Subsequently,
an evaluation using the aforementioned algorithms is shown. For this, a custom
metric was created that uses the default gem5 models as a reference. Finally, a
conclusion is drawn.