Standby efficiency for connected devices is one of the priorities of the G20’s Energy Efficiency Action Plan. We propose transparent programming language mechanisms to enforce that applications remain in the deepest standby modes for the longest periods of time. We extend the programming language Céu with support for interrupt service routines and with a simple power management runtime. Based on these primitives, we also provide device drivers that allow applications to take advantage of standby automatically. Our approach relies on the synchronous semantics of the language which guarantees that reactions to the environment always reach an idle state amenable to standby. In addition, in order to lower the programming barrier of adoption, we show that programs in Céu can keep a sequential syntactic structure, even when applications require non-trivial concurrent behavior.

Overload control requires different scheduling policies in different application scenarios. In this work, we propose an API that allows the programmer to choose and program scheduling policies in the specific setting of a staged event driven architecture. Through the study of various scheduling policies, we have extracted common requirements and built an interface that allows developers to build and combine scheduling controllers. The implementation is specific to the Leda event driven architecture, but the same model could be applied in other systems with similar needs. Using this interface, we have built controllers for a set of scheduling policies, and we report the results of experiments with these policies in two Leda applications with different load profiles.

Extensible operating system is a design based on the idea that operating systems can be adapted to meet user requirements by allowing user extensions. In a different scenario, that of application development, there is a paradigm that supports that complex systems should allow users to write scripts to tailor an application to their needs. In this paper we propose the concept of scriptable operating system, which applies scripting development paradigm to the concept of extensible operating systems. Scriptable operating systems support that operating systems can adequately provide extensibility by allowing users to script their kernel. We also present an implementation of a kernel-scripting environment that allows users to dynamically extend Linux and NetBSD operating systems using the scripting language Lua. To evaluate this environment, we extended both OS kernels to allow users to script CPU frequency scaling and network packet filtering using Lua.

The Staged Event Driven Architecture (SEDA) can be seen as a milestone as regards integration of threads and events in a single model. By decomposing applications into sets of multi-threaded stages connected by event queues, SEDA allows for the use of each concurrency model where most appropriate. Inside each SEDA stage, the number and scheduling policy of threads can be adjusted to enhance performance. SEDA lends itself to parallelization on multicores and is well-suited for many high-volume data stream processing systems and highly concurrent event processing systems. In this paper, we discuss the design of Leda, a platform that extends the staged model proposed by SEDA, decoupling application design from specific execution environments. In Leda, stages are defined purely by their role in application logic, with no concern for locality of execution, and are bound together through asynchronous communication channels, called connectors, to form a directed graph representing the flow of events inside the application. Decisions about the configuration of the application at execution time are delayed to later phases of the implementation process. Stages in the application graph can then be grouped to form clusters, and each cluster is mapped to an exclusive OS process, running on an arbitrary host. The paper briefly reviews a classification of hybrid concurrent models in order to establish SEDA's and Leda's role in this space. It then describes the design of Leda, which emphasizes decoupling at several levels, and discusses how its implementation in Lua helped to reinforce these design goals.

This article advocates the revival of coroutines as a convenient general control abstraction. After proposing a new classification of coroutines, we introduce the concept of full asymmetric coroutines and provide a precise definition for it through an operational semantics. We then demonstrate that full coroutines have an expressive power equivalent to one-shot continuations and one-shot delimited continuations. We also show that full asymmetric coroutines and one-shot delimited continuations have many similarities, and therefore present comparable benefits. Nevertheless, coroutines are easier implemented and understood, especially in the realm of procedural languages.