Thomas Knauth

Scalable and Low-Latency Data Processing with Stream MapReduce

We present StreamMapReduce, a data processing approach that combines ideas from the popular MapReduce paradigm and recent developments in Event Stream Processing. We adopted the simple and scalable programming model of MapReduce and added continuous, low-latency data processing capabilities previously found only in Event Stream Processing systems. This combination leads to a system that is efficient and scalable, but at the same time, simple from the users point of view. For latency-critical applications, our system allows a hundred-fold improvement in response time. Notwithstanding, when throughput is considered, our system offers a ten-fold per node throughput increase in comparison to Hadoop. As a result, we show that our approach addresses classes of applications that are not supported by any other existing system and that the MapReduce paradigm is indeed suitable for scalable processing of real-time data streams.

Energy-aware scheduling for infrastructure clouds

More and more data centers are built, consuming ever more kilo watts of energy. Over the years, energy has become a dominant cost factor for data center operators. Utilizing low-power idle modes is an immediate remedy to reduce data center power consumption. We use simulation to quantify the difference in energy consumption caused exclusively by virtual machine schedulers. Besides demonstrating the inefficiency of wide-spread default schedulers, we present our own optimized scheduler. Using a range of realistic simulation scenarios, our customized scheduler OptSched reduces cumulative machine uptime by up to 60.1%. We evaluate the effect of data center composition, run time distribution, virtual machine sizes, and batch requests on cumulative machine uptime. IaaS administrators can use our results to quickly assess possible reductions in machine uptime and, hence, untapped energy saving potential.

Low-Overhead Fault Tolerance for High-Throughput Data Processing Systems

The MapReduce programming paradigm proved to be a useful approach for building highly scalable data processing systems. One important reason for its success is simplicity, including the fault tolerance mechanisms. However, this simplicity comes at a price: efficiency. MapReduces fault tolerance scheme stores too much intermediate information on disk. This inefficiency negatively affects job completion time. Furthermore, this inefficiency in particular forbids the application of MapReduce in near real-time scenarios where jobs need to produce results quickly. In this paper, we discuss an alternative fault tolerance scheme that is inspired by virtual synchrony. The key feature of our approach is a low-overhead deterministic execution. Deterministic execution reduces the amount of persistently stored information. In addition, because persisting intermediate results are no longer required for fault tolerance, we use more efficient communication techniques that considerably improve job completion time and throughput. Our contribution is twofold: (i) we enable the use of MapReduce for jobs ranging from seconds to a few tens of seconds, satisfying these deadlines even in the case of failures, (ii) we considerably reduce the fault tolerance overhead and as such the overhead of MapReduce in general. Our modifications are transparent to the application.

Scaling Non-elastic Applications Using Virtual Machines

Hardware virtualization is a cost effective mean to reduce the number of physical machines (PMs) required to handle computational tasks. Virtualization also guarantees high levels of isolation (performance and security wise) between virtual machines running on the same physical hardware. Besides enabling consolidation of workloads, virtual machine (VM) technology also offers an application independent way of shifting workloads between physical machines. Live migration, i.e., shifting workloads without explicitly stopping the virtual machine, is particularly attractive because of the minimal impact on virtual machine and hence service availability. We explore the use of live migration to scale non-elastic (i.e., static runtime configuration) applications dynamically. Virtual machines thus provide an application agnostic way to dynamic scalability, and open new venues for minimizing the physical resource usage in a data center. We will show that virtualization technology in connection with the live migration capabilities of modern hyper visors can be used to scale non-elastic application in a generic way. Some problems still present in current virtualization techniques with respect to live migration will also be highlighted.

Prospect: a compiler framework for speculative parallelization

Making efficient use of modern multi-core and future many-core CPUs is a major challenge. We describe a new compiler-based platform, Prospect, that supports the parallelization of sequential applications. The underlying approach is a generalization of an existing approach to parallelize runtime checks. The basic idea is to generate two variants of the application: (1) a fast variant having bare bone functionality, and (2) a slow variant with extra functionality. The fast variant is executed sequentially. Its execution is divided into epochs. Each epoch is re-executed by an executor using the slow variant. The approach scales by running the executors on multiple cores in parallel to each other and to the fast variant. We have implemented the Prospect framework to evaluate this approach. Prospect allows custom plug-ins for generating the fast and slow variants. With the help of our novel StackLifter, a process can switch between the fast variant and the slow variant during runtime at arbitrary positions.

DreamServer: Truly On-Demand Cloud Services

Todays cloud offerings, while promising flexibility, fail to deliver this flexibility to lower-end services with frequent, minute-long idle times. We present DreamServer, an architecture and combination of technologies to deploy virtualized services just-in-time: virtualized web applications are suspended when idle and resurrected only when the next request arrives. We demonstrate that stateful VM resume can be accomplished in less than one second for select applications. We have implemented DreamServer by customizing well-known open source software projects, the Apache web server and the virtual machine emulator qemu. Our evaluation of just how fast idle services can be reactivated includes different storage technologies, local and networked storage, and multiple VM resume strategies. The empirical results show that just-in-time deployment of virtualized services is possible with a minimal additional delay. This brings us closer to our understanding of flexibility in the cloud especially for customers with sporadic resource usage.

Speculation for Parallelizing Runtime Checks

We present and evaluate a framework, ParExC , to reduce the runtime penalties of compiler generated runtime checks. An obvious approach is to use idle cores of modern multi-core CPUs to parallelize the runtime checks. This could be accomplished by (a) parallelizing the application and in this way, implicitly parallelizing the checks, or (b) by parallelizing the checks only. Parallelizing an application is rarely easy and frameworks that simplify the parallelization, e.g., like software transactional memory (STM), can introduce considerable overhead. ParExC is based on alternative (b). We compare it with an approach using a transactional memory-based alternative. Our experience shows that ParExC is not only more efficient than the STM-based solution but the manual effort for an application developer to integrate ParExC is lower. ParExC has --- in contrast to similar frameworks --- two noteworthy features that permit a more efficient parallelization of checks: (1) speculative variables, and (2) the ability to add checks by static instrumentation.

Fast Virtual Machine Resume for Agile Cloud Services

Resuming virtual machines is an important management operation in the virtualized data center. (Re)-instantiating VMs as quickly as possible helps to combat flash crowds and provide true on-demand services. Unfortunately, resuming a VM currently takes tens of seconds, depending on the VMs size and available disk I/O bandwidth. Because it is not strictly necessary to read the entire state from disk to continue executing the VM instance, we propose an on-demand resume feature. Instead of indiscriminately reading the entire state from disk, we utilize the host OSs support for lazily reading pages from disk only when they are needed. We have implemented our idea as part of the open-source, virtual machine emulator qemu. Our idea required to modify less than 100 lines of code. The experimental evaluation of our on-demand resume feature reveals that it works as expected: resume times no longer depend on the VMs total state but rather on the actively used state. We are able to resume instances with multiple gigabytes of state in as little as 3 seconds, i.e., we reduced the resume time to less than 1/10th compared to the default implementation.

Assertion-Driven Development: Assessing the Quality of Contracts Using Meta-Mutations

Agile development methods have gained momentum inthe last few years and, as a consequence, test-driven developmenthas become more prevalent in practice. However, test cases arenot sufficient for producing dependable software and we ratheradvocate approaches that emphasize the use of assertions orcontracts over that of test cases. Yet, writing self-checks in codehas been shown to be difficult and is itself prone to errors. Astandard technique to specify runtime properties is design-bycontract(DbC). But how can one test if the contracts themselvesare sensible and sufficient? We propose a measure to quantifythe goodness of contracts (or assertions in a broader sense). Weintroduce meta-mutations at the source code level to simulatecommon programmer errors that the self-checks are supposedto detect. We then use random mutation testing to determinea lower and upper bound on the detectable mutations andcompare these bounds with the number of mutants detected bythe contracts. Contracts are considered “good” if they detect acertain percentage of the detectable mutations.We have evaluatedour tools on Java classes with contracts specified using theJava Modeling Language (JML). We have additionally tested thecontract quality of 19 implementations, written independently bystudents, based on the same specification.

ParaDIME: Parallel Distributed Infrastructure for Minimization of Energy for data centers

Abstract Dramatic environmental and economic impact of the ever increasing power and energy consumption of modern computing devices in data centers is now a critical challenge. On the one hand, designers use technology scaling as one of the methods to face the phenomenon called dark silicon (only segments of a chip function concurrently due to power restrictions). On the other hand, designers use extreme-scale systems such as teradevices to meet the performance needs of their applications which in turn increases the power consumption of the platform. In order to overcome these challenges, we need novel computing paradigms that address energy efficiency. One of the promising solutions is to incorporate parallel distributed methodologies at different abstraction levels. The FP7 project ParaDIME focuses on this objective to provide different distributed methodologies (software–hardware techniques) at different abstraction levels to attack the power-wall problem. In particular, the ParaDIME framework will utilize: circuit and architecture operation below safe voltage limits for drastic energy savings, specialized energy-aware computing accelerators, heterogeneous computing, energy-aware runtime, approximate computing and power-aware message passing. The major outcome of the project will be a noval processor architecture for a heterogeneous distributed system that utilizes future device characteristics, runtime and programming model for drastic energy savings of data centers. Wherever possible, ParaDIME will adopt multidisciplinary techniques, such as hardware support for message passing, runtime energy optimization utilizing new hardware energy performance counters, use of accelerators for error recovery from sub-safe voltage operation, and approximate computing through annotated code. Furthermore, we will establish and investigate the theoretical limits of energy savings at the device, circuit, architecture, runtime and programming model levels of the computing stack, as well as quantify the actual energy savings achieved by the ParaDIME approach for the complete computing stack with the real environment.