The following keywords have been assigned to this publication so far. If you have logged in,
you can tag this publication with additional keywords.
If you log in you can tag this publication with additional keywords
A publication can refer to another publication (outgoing references) or it can be referred to by other
publications (incoming references).
If you log in you can add references to other publications
A publication can be assigned to a conference, a journal or a school.
Computing systems are increasingly becoming dynamic. One example is cloud computing
and its property of elasticity. On cloud platforms, resources in the form of additional
nodes can be added and removed at any time. Software systems expected to run in such
environments, on the other hand, are not nearly as elastic and flexible. Another example
is the clearly visible trend towards incorporating an increasing number of processor
cores into modern computer systems. In the future, it is likely that not all of these cores
will have a uniform instruction set anymore but specialized units are used to accelerate
certain tasks. At the same time, however, the power envelope of computer systems is
increasingly becoming an issue so that probably not all cores can run at the same time
anymore. Software written for such systems is thereby required to adapt to a changing
pool of resources, a situation that todays software is hardly prepared for.
This thesis contributes towards understanding how to build software systems that are
able to reflect such a degree of flexibility. The fundamental observation underlying this
work is that in order to respond to the emerging dynamism in the platforms, software
has to become equally flexible in its design. This requires a segregation of the software
into smaller units. In the early days of computer science similar challenges in the development
process of complex software have catalyzed the concept of software modularity.
The premise of this thesis is that the same kind of modularizationwhen not only applied
on a logical level to the source code but also in a physical form and preserved until
runtime results in the required degrees of freedom in the design of software systems.
In combination with a smart runtime system, this approach turns software into flexible,
fluid entities able to adapt to a dynamic environment.
Three systems are presented in this thesis which are based upon the OSGi standard
for dynamic modules in the Java language. They enhance the standard with different
degrees of flexibility. The Juggle system co-manages software modules and the binaries
for reprogramming an FPGA device so that applications can be selectively accelerated
on demand and without interrupting running operations. The CPU/FPGA board serves
as an example of a computer system that is already dynamic and reprogrammable today.
© 2014 ETH Zurich