High Performance Erlang -- Introduction
Software for control systems have applications in cars, trains,
telecom networks, factories, powerplants. Demands on such software
are increasing: greater functionality, higher reliability, less
maintenance, shorter development times. To address these demands,
Ericsson has developed the concurrent functional language Erlang. The
goal is shorter time-to-market (increased revenue) and lower
maintenance costs (reduced expenses).
Performance of both sequential and concurrent code is an important
issue in control system software. High-level languages, such as
Erlang, do not yet reach the performance levels of established
languages such as C. The are several reasons for this. First, the
data and control abstractions of C is closer to the hardware than
those of high-level languages. Second, many years of academic research and
industrial R&D have been directed towards optimizing C. The resulting
techniques are only to some degree applicable to high-level
languages. New research is needed that address the new compilation and
optimization problems raised by new languages.
A computer system consists of both hardware (e.g. processor and memory
system) and software (e.g. compiler and operating system). Computer
system design should be guided by the static and dynamic
characteristic of real applications, not artificial benchmarks. This
was one of the fundamental insights of the hardware community in the
early 1980s. Today, operating system and compiler researchers are
also adopting this methodology.
Here a lies a fundamental problem in finding new, efficient
compilation technniques for new programming languages: we know
virtually nothing about the static and dynamic characteristics of
large applications written in such languages. The existence of large
Erlang applications at Ericsson provides a unique opportunity for
academic compiler researchers to adapt a sound methodology, based on
measurements of real applications, when trying to meet the compilation
challenges raised by high-level languages such as Erlang.
An important practical problem facing the compiler researcher is this:
you cannot make measurements on real application unless you have a
stable and complete language implementation; moreover, this should be
your own implementation, since otherwise you cannot evaluate the
optimizations you design. Our approach to this problem is to
collaborate with Ericsson: we base our implementation of Erlang on
theirs, reusing those parts of their implementation that have no
research value for us. In this way we can reduce, but certainly not
eliminate, the effort needed for providing the infrastructure required
by our research methodology.
Extend and rewrite our current Erlang implementation so that it is
stable enough to run very large programs.
Further develop our current measurement framework.
Carry out extensive measurements on large Erlang
applications, aiming for a precise understanding of their
static and dynamic characteristics.
Begin investigation into new optimizations, exploring the knowledge gained in
To verify that our implementation of Erlang is stable enough to run
very large programs, we will validate our implementation by means of a
test suite provided by Ericsson's Open Telecom Platform division
Our measurement framework will be extended to precisely measure time
spent per function and identify the application kernel of procedures
where the main portion of time is spent.
Measurements on large Erlang application will be carried out with the
assistance of Ericsson's OTP division and Ericsson development
projects. We will concentrate on the following aspects:
Based on this information, we will develop optimizations and prototype
implementations suitable for
very large programs. We intend to pursue these optimizations more fully
in the continuation of the project.
- Static characteristics, such as program size and complexity
and available type information. This information guides static
- Dynamic characteristics, based on measuring the executing system.
These include determining where time is spent in the system,
memory usage profiles, garbage collection overheads (pause times and
total time overheads),
concurrency characterization, and other similar aspects.
This information guides system design choices and profile-based
The task of a compiler is to utilize the hardware as efficiently as
possible for a given source program. Hardware technology increasingly
imposes two limits on performance: branches and memory references. In
order to overcome these limitations, we intend to investigate techniques that
reduce load/stores and branches for realistic
sequential and concurrent programs.
Collaborations are currently in progress with the Computer Science Lab
and the Open Telecom Platform division of Ericsson. There are two
purposes of this collaboration: (1) it will facilitate the use of a proper
scientific methodology in the project as explained above, and (2) it
will introduce Ericsson to new efficient compilation optimization.
Thomas Lindgren / email@example.com
Last modified: Wed Feb 11 15:04:52 MET 1998