Publication

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 today’s 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 modularization—when 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.

@phdthesis{abc,
	abstract = {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 today\&$\#$146;s 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 modularization\&$\#$151;when not only applied
on a logical level to the source code but also in a physical form and preserved until
runtime\&$\#$151; 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.},
	author = {Jan S. Rellermeyer},
	school = {19610},
	title = {Modularity as a Systems Design Principle},
	year = {2011}
}