Software

Tools for CPU Scheduling

CPU Broker: Dynamic CPU Management

The CPU Broker is a reservation-based resource manager for CPU time. The broker mediates between multiple real-time applications and the facilities of an underlying real-time operating system: it implements a configurable CPU management policy, monitors resource use, and adjusts allocations over time. This architecture helps to ensure that the quality of service (QoS) needs of ``important'' applications are satisfied, especially when the relative importance of applications changes dynamically. An additional and important benefit is that the broker can automatically determine many of the scheduling parameters of its client applications. Our RTAS 2004 paper describes the broker's architecture and capabilities in greater detail.

Hourglass: A Synthetic Real-Time Application

Hourglass is a synthetic real-time application that can generate a variety of real-time workloads, monitor precisely when its threads are scheduled (and when they are not), and determine when its threads meet their deadlines (or not). It can also make use of advanced scheduling abstractions like CPU reservations. These capabilities are described in detail in our FREENIX 2002. Hourglass is open source software.

SPAK: Static Priority Analysis Kit

SPAK is a library of schedulability analysis functions that is designed to support CEE (see below). A subset of its capabilities are described in our RTSS 2002 paper. Briefly, it supports the analysis of tasks scheduled using priorities where there are mixed preemption relations (e.g. some preemptive scheduling, some non-preemptive scheduling) and can both minimize the number of threads required to run a task set and maximize the robustness of a schedule with respect to timing faults (tasks that run for too long but eventually return a correct result). SPAK is open source.

TSL: Task/Scheduler Logic

TSL is a logic for reasoning about correctness (race conditions, interrupt handlers that incorrectly acquire thread locks, etc.) in software containing multiple execution environments. Derivations in TSL can be used to infer the set of locks that can be safely used to protect each critical section, including the important special case where no lock is necessary at all.

Tools for Execution Environments

CEE: Composable Execution Environments

CEE is a new model of systems software that emphasizes the existence of multiple execution environments within systems software. The idea is to permit each part of a system to be constructed using an appropriate software structure; e.g. a single-threaded event loop, a set of cooperating threads, or a data flow graph. We then ensure that the environments can interoperate smoothly and that global real-time constraints can be met.

Tools for Java

Jiazzi: Components for Java

Jiazzi adds support for large-scale component programming in Java. Components in Jiazzi contain, import, and export Java classes and Java's in-language support for inheritance can be used across component boundaries. Jiazzi is both expressive, supporting cyclic component linking and mixin constructions, and robust; the implementation and linking of a component can be separately type checked.

Our current implementation integrates into Java using a linker, which manipulates components, and a stub generator, which allows Jiazzi to be used with normal Java source compilers. Jiazzi does not extend the Java language. Instead, Java code for a component is written using the normal Java language and a separate linking language is used to manipulate components.

Maya: Macros that Play

Maya is a version of Java that allows users to write their own syntax extensions, which are called Mayans. Mayans can reinterpret or extend Maya syntax by expanding it to other Maya syntax: they operate on abstract syntax trees, and their expansion is triggered during parsing as semantic actions. Maya's expressiveness comes from treating grammar productions as generic functions, and Mayans as multi-methods on those generic functions. Mayans are defined using a rich set of parameter specializers: Mayans can be dispatched on type of an AST node, the static type of an expression, the value of a token, or the substructure of any AST node. Multiple dispatch allows users to extend the semantics of the language by overriding the language's base actions.

The Maya distribution includes implementations of the MultiJava and Handi-Wrap Languages, as well as the Handi-Wrap retrofitter.

Handi-Wrap: Runtime Aspect Weaving

Handi-Wrap is an extension to Java that supports weaving aspects into code at runtime. Aspects in Handi-Wrap take the form of method wrappers, which allow aspect code to be inserted around method bodies like advice in AspectJ. Handi-Wrap offers several advantages over static aspect languages such as AspectJ. First, aspects can be woven into binary libraries. Second, a wrapper in Handi-Wrap is a first-class Java value, which allows users to exploit Java mechanisms to define and weave wrappers. For example, wrappers can be passed explicit constructor arguments, and wrapper objects can be composed. Finally, methods in all Java classes, including anonymous classes, can be wrapped.

Handi-Wrap is included as part of the Maya software distribution.

Tools for C

CMI: Cross Module Inliner for C

CMI is an optimizing frontend for gcc which allows gcc to inline across module (i.e., function) boundaries without requiring you to put inline functions in header files or even mark inline functions for inlining.

CMI gives you the power to decide exactly which functions to inline so you can choose whether you want to optimize for speed, code size, stack size, interrupt latency or any other property you care to dream up.

Knit: Components for C

Knit was the first component definition and linking toolset from the Alchemy project. Knit helps to make C code more understandable and reusable by third parties, helps eliminate much of the performance overhead of componentization, detects subtle errors in component composition that cannot be caught with normal component type systems, and provides a foundation for developing future analyses over C-based components, such as cross-component optimization.

Knit is especially designed for use with component kits, where standard linking tools provide inadequate support for component configuration. In particular, we initially developed Knit for use with The OSKit, a large collection of components for building low-level systems. However, Knit is not OSKit-specific.

OSKit/Knit: Operating System Components

OSKit/Knit applies Knit to the The OSKit, a set of low level components for building operating systems and embedded systems. Knit can be used with the Valentine's Day Snapshot (20010214) of the OSKit. Over 300 components are described in the documentation.