Jan Richling

The pitfalls of deploying solid-state drive RAIDs

Solid-State Drives (SSDs) are about to radically change the way we look at storage systems. Without moving mechanical parts, they have the potential to supplement or even replace hard disks in performance-critical applications in the near future. Storage systems applied in such settings are usually built using RAIDs consisting of a bunch of individual drives for both performance and reliability reasons. Most existing work on SSDs, however, deals with the architecture at system level, the ash translation layer (FTL), and their influence on the overall performance of a single SSD device. Therefore, it is currently largely unclear whether RAIDs of SSDs exhibit different performance and reliability characteristics than those comprising hard disks and to which issues we have to pay special attention to ensure optimal operation in terms of performance and reliability. In this paper, we present a detailed analysis of SSD RAID configuration issues and derive several pitfalls for deploying SSDs in common RAID level configurations that can lead to severe performance degradation. After presenting potential solutions for each of these pitfalls, we concentrate on the particular challenge that SSDs can suffer from bad random write performance. We identify that over-provisioning offers a potential solution to this problem and validate the effectiveness of over-provisioning in common RAID level configurations by experiments whose results are compared to those of an analytical model that allows to approximately predict the random write performance of SSD RAIDs based on the characteristics of a single SSD. Our results show that over-provisioning is indeed an effective method that can increase random write performance in SSD RAIDs by more than an order of magnitude eliminating the potential Achilles heel of SSD-based storage systems.

Stochastic performance analysis and capacity planning of publish/subscribe systems

Publish/subscribe systems are used increasingly often as a communication mechanism in loosely-coupled distributed applications. With their gradual adoption in mission critical areas, it is essential that systems are subjected to a rigorous performance analysis before they are put into production. However, existing approaches to performance modeling and analysis of publish/subscribe systems suffer from many limitations that seriously constrain their practical applicability. In this paper, we present a set of generalized and comprehensive analytical models of publish/subscribe systems employing different peer-to-peer and hierarchical routing schemes. The proposed analytical models address the major limitations underlying existing work in this area and are the first to consider all major performance-relevant system metrics including the expected broker and link utilization, the expected notification delay, the expected time required for new subscriptions to become fully active, as well as the expected routing table sizes and message rates. To illustrate our approach and demonstrate its effectiveness and practicality, we present a case study showing how our models can be exploited for capacity planning and performance prediction in a realistic scenario.

Stochastic Analysis of Hierarchical Publish/Subscribe Systems

With the gradual adoption of publish/subscribe systems in mission critical areas, it is essential that systems are subjected to rigorous performance analysis before they are put into production. However, existing approaches to performance modeling and analysis of publish/subscribe systems suffer from many limitations that seriously constrain their practical applicability. In this paper, we present a generalized method for stochastic analysis of publish/subscribe systems employing identity-based hierarchical routing. The method is based on an analytical model that addresses the major limitations of existing work in this area. In particular, it supports arbitrary broker overlay topologies and allows to set workload parameters, e.g., publication rates and subscription lifetimes, individually for each broker. The analysis is illustrated by a running example that helps to gain better understanding of the derived mathematical relationships.

Lightweight services for embedded systems

We propose creating service oriented-architecture for embedded systems. We introduce the concept of contracts for embedded systems, and propose architectural and design solutions for accessing embedded systems using lightweight services based on contracts. We define proxy, translator and full service architectures, that enable us to link with a variety of classes of embedded devices. By treating embedded systems as services we expect to make a concept of self-descriptive and reusable embedded systems more accessible to clients.

Design and implementation of the Rebeca publish/subscribe middleware

Publish/subscribe is used increasingly often as a communication mechanism in loosely-coupled distributed applications. Research and product development have focused mostly on efficiency issues and neglected methodological support to build concrete middleware implementations so far. In this paper, we present the novel design of the REBECA publish/subscribe middleware that is based on the experience gained with previous versions. As basic design concept, we focus on a modular pipeline architecture that is built around a minimal, but extendable publish/ subscribe core. With respect to modularity, we employ the concept of features that are well-defined aspects of a software systems functionality, encapsulated in pluggable modules, and, thereby, facilitate a separation of concerns. We address the composition of features and show how this is realized in REBECAs pipeline architecture with independently working plugins that can influence passing messages in three dedicated stages.

Event-driven processor power management

Energy-efficient computing as a research area has been receiving increasing attention in recent years due to rising energy costs and environmental awareness. In this paper, we present an approach to increasing the energy efficiency of modern multi-core computers, which is suitable for scenarios with varying load characteristics often found in private and small office/home office (SOHO) machines. The approach is based on a closer integration of the operating system scheduler and frequency governor, while shifting the mode of operation from time-driven to event-driven. We discuss theoretical as well as practical considerations, and describe experiments for both desktop and server systems. Based on a fully functional implementation within the Linux kernel, it is shown that our approach is feasible and allows for power savings of up to 10% while delivering a performance comparable to disabled power management and being more energy-efficient than the traditional time-driven variant.

Adaptive routing in publish/subscribe systems using hybrid routing algorithms

In this paper, we present a distributed algorithm that autonomously adapts the routing configuration in a broker overlay network to dynamically optimize the system. The possibility of adaptation arises from a new kind of routing algorithms, called hybrid routing algorithms, that combine the usage of different routing algorithms in one overlay network. The presented algorithm works decentralized without global knowledge, performs the optimizations link by link at runtime, and generates only marginal extra traffic.

Dynamic Guaranteed Service Communication on Best-Effort Networks-on-Chip

In order to execute applications under real-time constraints on many-core processors with a Network-on-Chip (NoC), guaranteed service (GS) communication with guaranteed end-to-end latency and bandwidth is required. Several hardware-based solutions for GS communication have been proposed in literature. However, commercially available many-core processors, e.g., Tileras Tile Pro64 or Adapt Evas Epiphany, do not support such features. In this paper, we propose a software solution that allows GS communication on 2D-mesh packet-switching NoCs. Our investigation is based on a hardware model that is applicable to commercially available processors, which include multiple NoCs to separate request and response packets and support only best-effort communication. We prove that a common upper bound of the injection rate for all sources limits the congestion which leads to an upper bound of the worst-case transmission latency (WCTL) for any transmission, i.e., the combination of a request and a response packet. Furthermore, our approach supports arbitrary transmission streams that can be modified at runtime without violating the upper bound of the WCTL, as long as the injection rate is not violated. This enables adaptive features such as task migration or dynamic scheduling policies. Experiments evaluate our solution for different traffic patterns.

Non-intrusive coscheduling for general purpose operating systems

Coscheduling, invented originally on early parallel computer systems 30 years ago, provided the possibility to improve the resource utilization of these systems substantially by coordinating the execution of processes across multiple processors in time. Almost forgotten in the multicore era, recent research addressing certain problems on multicore systems, such as performance of virtual machines, contention of processor resources, or dynamic energy budget distribution, concludes that coscheduling is a viable solution. In this paper, we do not focus on a specific problem or application of coscheduling, but on coscheduling itself. We present a coscheduling design that is able to cover most of the identified use cases on multicore systems and can be seamlessly integrated into currently used general purpose operating systems. We have applied this design to the Linux kernel and show that this approach allows a non-intrusive solution that fulfills the promises of coscheduling and is able to achieve a similar performance as a specialized commercial solution.

Dynamic Teams in OpenMP

While OpenMP conceptually allows to vary the degree of parallelism from one parallel region to the next in order to adapt to the system load, this might still be too coarse-grained in certain scenarios. Especially applications designed for parallelism may stay within one parallel region for a long time. This may lead either to an oversubscribed system where individual applications are not restricted in their degree of parallelism, or to an underutilized system, because individual applications are restricted to a too small degree of parallelism. In this paper, we tackle both problems by dynamically restricting the number of active threads within a parallel region without violating the OpenMP specification.