Area 3 - Architecture: Software Architectures for Cloud-based and Multicore Systems
Area manager: Prof. Lars Lundberg
Researcher: Prof. Håkan Grahn, Dr. Mikael Svahnberg, Dr. David Erman, Dr. Andrew Moss
Two system trends that affect the software architecture are Cloud Computing and Multicore processors. In cloud computing software services are provided in the cloud and not on the local computer. In a multicore processor, several processor cores are placed on the same chip. These cores can be utilized to either execute several independent programs at the same time or execute a single program faster. Exploiting the performance potential of multicore processors for an individual program requires that the program is parallel and scalable.
Placing a service in the cloud has several advantages, e.g. there is an on-line contact between the service provider and the customer. An important software architecture trend is software ecosystems, where an organization provides a platform and a community of developers provides functionality that extends the platform. Some software ecosystems (e.g. Linux) are non-profit. Others provide a platform by which developers can charge users (e.g. add-ons for Firefox). The existing charging model is, however, limited to the traditional one-time buy. Since a service is provided in the cloud, a number of innovative charging models can be considered, e.g. charging based on time, usage, etc. Since the software added by external developers will interact partly with unknown software we need to ensure that one piece of unstable software does not jeopardize the stability of the entire system. It must also be possible to package new services into components that can be added to the system separately while still enabling them to interact with other (unknown) services.
Verification, testing, and debugging of programs constitutes a significant portion of the software development time. In sequential programs, testing and debugging can be done in a fairly deterministic way, since only one thing happens at the time. Further, a sequential program (usually) behaves the same each time it is executed with the same input. However, parallel programs running on multicore processors generate new types of problems that are timing dependent, e.g., concurrent access of shared data, different execution orders, and transient bugs (aka Heisenbugs). Several of these problems may be very hard to reproduce and debug. In particular, shared data access is a source of correctness problems. Traditionally, locks are used to protect shared data, but they have a number of problems, e.g., deadlocks and priority inversion, and they also complicate software composability.
In BESQ+ we will develop software architectures, methods and tools that will help the software industry to take advantage of the new system trends. In cloud computing, the key to providing good solutions to the challenges concerning composability and charging is to find appropriate software architectures. For multicore processors, we will develop novel methods, techniques, and tools for low-overhead dynamic tracing, deterministic re-execution, and combinations of static and dynamic analysis. Further, we would like to study alternative methods for protecting shared data, e.g., Transactional Memory (TM). TM associates the protection of shared data with the data accesses themselves, while locks associate the protection mechanism with a specific lock primitive (variable) independent of the shared data. In order to learn from existing systems, we will study a number of use cases from different application domains, e.g. computer games and telecommunication services.
- To develop software architectures that will make it possible for cloud-based software ecosystem to grow into new domains. These architectures must address the issues concerning stability and sustainable business models.
- To develop methods, techniques and tools that will make it possible for software developers to benefit from multicore processors. These methods, techniques and tools must address the issues concerning correctness, testing and debugging.
Industrial partner: ST-Ericsson