Jan Hendrik Schönherr

Clustered publish/subscribe in wireless actuator and sensor networks

In this paper, we present a new method to realize a selforganizing and self-stabilizing publish/subscribe middleware for wireless actuator and sensor networks. By using simple, yet powerful compositional rules, our approach forms hierarchical clusters of nodes and sets up many small publish/subscribe networks, that interact with each other. Thereby, we are able to integrate the necessary routing of messages between clusters into the publish/subscribe substrate itself. This technique reveals several benefits, such as redundant routes and automatic route recovery, which show up as emergent behavior at no additional cost. The provided publish/subscribe middleware allows an elegant design of eventbased applications for pervasive environments.

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.

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.

Analyzing resource interdependencies in multi-core architectures to improve scheduling decisions

Since the advent of multi-core processors, different multi-core system and in particular processor architectures have emerged exhibiting individual advantages and disadvantages. One of the main distinguishing factors among these architectures is their varying degree and type of resource sharing among individual cores. On the one hand, resource sharing is necessary for the cores to communicate, while on the other hand resource sharing is often used for economic reasons. Depending on the degree and type of resource sharing, the impact on performance depends on the workload applied and can vary to a large extend. In this paper, we investigate the impact of different kinds of resource interdependencies found in current processors on the performance of scheduling strategies using a set of benchmarks. Our results show that the architecture has a major impact on the performance of a process placement strategy. However, they also point out that simple strategies taking only a few basic architectural characteristics into account fall short. Thus, new holistic scheduling strategies are needed that take more characteristics into account.

Towards Energy-Aware Multi-Core Scheduling

ABSTRACT There are two major current trends that can easily be identified in computer industry: (i) the shift towards massively parallelization fostered by multi-core technology resulting in growing numbers of cores per processor and (ii) the increasing importance of energy-awareness in computing due to rising energy costs and environmental awareness. In current operating systems, these two issues are often addressed independently: one component, the scheduler, assigns processes to cores and a second component manages the power states of individual cores in time. In this paper, we explain why this orthogonal treatment can lead to problems such as a considerably degraded system performance in case of on-demand processor power state management. Furthermore, we present an approach to energy-aware multi-core scheduling at the operating system level avoiding the performance penalty while still saving energy. To corroborate our argumentation and to illustrate the applicability of the presented approach, we give numbers from experiments based on Linux and current multi-core processors.

Partial coscheduling of virtual machines based on memory access patterns

Virtualization is omnipresent in server environments. The scheduling of virtual machines is a challenging task because it is necessary to avoid differences in processing progress of the virtual CPUs, which otherwise can lead to a severe performance degradation. Coscheduling is a commonly used technique to solve this issue. With coscheduled virtual machines, all virtual CPUs are executed at the same time by the host. However, in a situation with virtual machines of arbitrary size, coscheduling of a whole virtual machine can lead to an under-utilization of the host. This situation occurs when the sizes of the virtual machines prohibit a scheduling where all cores of the host machines are used at every point in time. In this paper, we show that this under-utilization can be reduced through partial coscheduling. Partial coscheduling uses sets that are not based on the size of the virtual machine but on the requirements of the load inside the virtual machine. We show through experiments with the Linux Kernel Virtual Machine (KVM) in combination with a coscheduling capable Linux kernel, that partial coscheduling can lead to an overall performance improvement compared to full coscheduling of complete virtual machines. The partial coscheduling approach requires knowledge about the relation between processes and threads inside the virtual machine, which is usually not available at runtime. To gather this information without modifying the guest, we propose an automatic algorithm based on the recent technique of Communication Detection through Shared Pages (SPCD), which detects the memory access behavior of applications inside virtual machines. Our experiments show that partial coscheduling can improve the utilization of the host by reducing the waste of computation time caused by unnecessarily idle cores, thereby increasing the performance of virtual machines. In many scenarios, automated partial coscheduling can also increase the host utilization.

TACO: A scheduling scheme for parallel applications on multicore architectures

While multicore architectures are used in the whole product range from server systems to handheld computers, the deployed software still undergoes the slow transition from sequential to parallel. This transition, however, is gaining more and more momentum due to the increased availability of more sophisticated parallel programming environments. Combined with the ever increasing complexity of multicore architectures, this results in a scheduling problem that is different from what it has been, because concurrently executing parallel programs and features such as non-uniform memory access, shared caches, or simultaneous multithreading have to be considered. In this paper, we compare different ways of scheduling multiple parallel applications on multicore architectures. Due to emerg- ing parallel programming environments, we primarily consider applications where the parallelism degree can be changed on the fly. We propose TACO, a topology-aware scheduling scheme that combines equipartitioning and coscheduling, which does not suffer from the drawbacks of the individual concepts. Additionally, TACO is conceptually compatible with contention-aware scheduling strategies. We find that topology-awareness increases performance for all evaluated workloads. The combination with coscheduling is more sensitive towards the executed workloads and NUMA effects. However, the gained versatility allows new use cases to be explored, which were not possible before.