Dominik Schäfer

Tasklets: "Better than Best-Effort" Computing

The modern computing landscape consists of numerous heterogeneous devices, all of which can contribute to a distributed environment as generic computation resources. In unstructured environments, resources can easily be shared and consumed at the cost of certainty. While some applications can handle such a best-effort service, many others require execution qualities, e.g., reliability or speed. We introduce Quality of Computation (QoC) as a thin layer on top of uniformly abstracted best-effort resources, which allows to tailor computation tasks to application-specific needs. The QoC layer provides execution guarantees for reliability, speed, precision, privacy, cost, and energy. We demonstrate QoC on the basis of the Tasklet system. Tasklets are fine-grained units of computation that can be issued for local or remote execution. The Tasklet system has two layers. Below is the best-effort execution layer, a virtual machine that provides raw computation. Above is the orchestration layer, which federates these virtual machines to one distributed computing environment and enforces the mechanisms that guarantee the requested QoC. We evaluated the performance of QoC in the Tasklet system in various scenarios. Results indicate that our system provides QoC guarantees at minimal performance cost.

Configuration Management for Proactive Adaptation in Pervasive Environments

Pervasive computing applications have to adapt in order to cope with changes in their environment. Proactive adaptation allows to change the application and/ or the context based on prediction of context and user behavior, in order to reduce adaption delay and provide a seamless service to the user. Thus, such applications are self-organizing systems. Ideally, self-organizing systems adapt by changing their structure or behavior without requiring the users intervention. A prerequisite to that is the knowledge of the possible configurations and their order with respect to the suitability. We introduce a comprehensive framework based on an application model with suitability and cost metrics. Based on the application model, we construct a CSP and develop an algorithm with two heuristics that finds all configurations. We rate the configurations depending on their expected instantiation using novel utility and cost functions. In the evaluation, we show the feasibility of our approach.

COMITY: Coordinated application adaptation in multi-platform pervasive systems

Pervasive applications are designed to support users in their daily lives. In order to provide their services, these applications interact with the environment, i.e. their context. They either adapt themselves as a reaction to context changes, or adapt the context via actuators according to their needs. If multiple applications are executed in the same context, interferences are likely to occur. In this paper, we present COMITY-a framework for interference management in multi-platform pervasive systems. Based on contracts specifying an applications interaction with the context, the framework automatically detects interferences and resolves them through a coordinated application adaptation. We analyze the problem of interference resolution, discuss respective algorithms and extensively evaluate our prototype.

COMITY: A framework for adaptation coordination in multi-platform pervasive systems

Pervasive applications are designed to support users in their daily lives. In order to provide their services, these applications interact with the environment, i.e., their context. They either adapt themselves as a reaction to context changes, or adapt the context via actuators according to their needs. If multiple applications are executed in the same context, interferences are likely to occur. In this paper, we present COMITY-a framework for interference management in multi-platform pervasive systems. Based on contracts specifying an applications interaction with the context, the framework automatically detects interferences and resolves them through a coordinated application adaptation.

Fault-avoidance strategies for context-aware schedulers in pervasive computing systems

Scheduling in distributed computing systems is the process of allocating resources to a computational task. The complexity of this allocation process increases with the amount of criteria that are considered for the scheduling decision. Pervasive computing systems show a high degree of heterogeneity and dynamism. The constant joining and leaving of devices makes the system error-prone and less predictable. The involved devices differ in various properties that we subsume as their context. We argue, that these context dimensions can be used to implement fault-avoidant scheduling strategies. In this paper, we introduce the concept of context-aware scheduling for pervasive computing systems. The schedulers in these systems consider multiple context dimensions to avoid failing resource providers. We discuss relevant context dimensions, develop context-aware scheduling strategies and implement them into an existing distributed computing system. We show how to monitor the context dimensions and evaluate the fault-avoidant scheduling strategies in a large-scale simulation.

Tasklets: Overcoming Heterogeneity in Distributed Computing Systems

Distributed computing is a good alternative to expensive supercomputers. There are plenty of frameworks that enable programmers to harvest remote computing power. However, until today, much computation power in the edges of the Internet remains unused. While idle devices could contribute to a distributed environment as generic computation resources, computation-intense applications could use this pool of resources to enhance their execution quality. In this paper, we identify heterogeneity as a major burden for distributed and edge computing. Heterogeneity is present in multiple forms. We draw our vision of a comprehensive distributed computing system and show where existing frameworks fall short in dealing with the heterogeneity of distributed computing. Afterwards, we present the Tasklet system, our approach for a distributed computing framework. Tasklets are fine-grained computation units that can be issued for remote and local execution. We tackle the different dimensions of heterogeneity and show how to make use of available computation power in edge resources. In our prototype, we use middleware and virtualization technologies as well as a host language concept.

Interactive Display Services for Smart Environments

Our daily environments become more and more populated with technology, creating so-called smart environments. In these environments, pervasive applications can make use of remote resources in order to improve their user experience. Streaming content from one device to a remote display has become very popular since the release of consumer products such as Apples AirPlay or Googles Chromecast, if not earlier. However, these streaming devices and protocols do not offer user interaction at the remote display and require manual setup. Additionally, both applications and displays are operated by the user. In this paper, we present middleware-based display services for public and private displays that offer user interaction as well as sensor input at the remote device. Further, our approach not only supports the users application to connect to an environment display, but also lets the user consume content that is provided by an application in the environment, using his/her own device.

Writing a Distributed Computing Application in 7 Minutes with Tasklets

This demo paper introduces a middleware for distributed computation applications -- the Tasklet system. The Tasklet system allows developers to execute self-contained units of computation -- the so-called Tasklets -- in a pool of heterogeneous computing devices, including desktop computers, cloud resources, mobile devices, and graphical processing units. In this demonstration of the Tasklet system, we visualize the otherwise transparent process of computation offloading, starting from the development of an application until the actual distributed execution of tasks. While existing systems have high setup costs the Tasklet system emphasizes the ease of use and a seamless integration of various heterogeneous devices. In the demonstration, we focus on three key benefits of the Tasklet system. First, we demonstrate the usability of the system by live developing a distributed computing application in less than ten minutes. Second, we show how heterogeneous devices can be set up and join the resource pool during the execution of Tasklets. With a monitoring tool we visualize how the computational workload is split up among these resources. Third, we introduce the concept of quality of computation to tailor the otherwise generic computing framework to the requirements of individual applications.

Developing distributed computing applications with Tasklets

This demo paper presents the Tasklet system - a middleware for distributed computing. The Tasklet system allows developers to offload self-contained units of computation - the so-called Tasklets - to a pool of heterogeneous computing devices. In this demonstration of the Tasklet system, we uncover the otherwise transparent process of computation offloading and scheduling. Further, we show the easy integration of heterogeneous computing devices and applications for Tasklets. In the demonstration, we focus on three key aspects of the Tasklet system. First, we present the API of the Tasklet middleware and the process of application tailoring with quality of computation. Second, we integrate computation devices during the runtime of Tasklets. A monitoring tool visualizes how Tasklets are scheduled and how resource providers simultaneously enter and leave the system. To show the easy integration of resources, we invite the audience to spontaneously contribute their computational resources to the environment. Third, we show five example applications from different application domains that benefit from using Tasklets.

Using quality of computation to enhance quality of service in mobile computing systems

Mobile devices are ubiquitous but their resources are limited. However, they must be capable to run computationally intensive software, for example for image stitching, face recognition, and simulation-based artificial intelligence. As a solution, mobile devices can use nearby resources to offload computation. Distributed computing environments provide such features but ignore the nature of mobile devices, such as mobility, network, or battery changes. This leads to long delays, which reduce the quality of experience for the user. In this paper, we present Mobile Tasklets, a mobile extension of our distributed computing middleware. The design of Mobile Tasklets includes context monitoring, context-aware scheduling mechanisms, and an Android API for application integration. We identify the challenges of the integration of mobile devices into our distributed computing environment. We evaluate Mobile Tasklets in a real-world testbed with different context settings.