Johan Nordlander

Positive supercompilation for a higher order call-by-value language

Previous deforestation and supercompilation algorithms may introduce accidental termination when applied to call-by-value programs. This hides looping bugs from the programmer, and changes the behavior of a program depending on whether it is optimized or not. We present a supercompilation algorithm for a higher-order call-by-value language and we prove that the algorithm both terminates and preserves termination properties. This algorithm utilizes strictness information for deciding whether to substitute or not and compares favorably with previous call-by-name transformations.

The Semantic Layers of Timber

We present a three-layered semantics of Timber, a language designed for programming real-time systems in a reactive, object-oriented style. The innermost layer amounts to a traditional deterministic, pure, functional language, around which we formulate a middle layer of concurrent objects, in terms of a monadic transition semantics. The outermost layer, where the language is married to deadline-driven scheduling theory, is where we define message ordering and CPU allocation to actions. Our main contributions are a formalized notion of a time-constrained reaction, and a demonstration of how scheduling theory, process calculii, and the lambda calculus can be jointly applied to obtain a direct and succinct semantics of a complex, real-world programming language with well-defined real-time behavior.

A correct and useful incremental copying garbage collector

Designing a garbage collector with real-time properties is a particularlydifficult task, involving the construction of both an incremental run-timealgorithm as well as methods enabling a priori reasoning about schedulability in two dimensions (time and memory usage in conjunction). In order to comply with such ambitious goals with any amount of formal rigor, a comprehensive understanding of the actual algorithm used is of course a fundamental requirement. In this paper we present a formal model of an incremental copying garbage collector, where each atomic increment is modeled as a transition between states of a heap process. Soundness of the algorithm is shown by proving that the garbage collecting heap process is weakly bisimilar to a non-collecting heap with infinite storage space. In addition, we show that our collector is both terminating and useful, in the sense that it actually recovers the unreachable parts of any given heap in a finite number of steps.

Live heap space bounds for real-time systems

Live heap space analyses have so far been concerned with the standard sequential programming model. However, that model is not very well suited for embedded real-time systems, where fragments of code execute concurrently and in orders determined by periodic and sporadic events. Schedulability analysis has shown that the programming model of real-time systems is not fundamentally in conflict with static predictability, but in contrast to accumulative properties like time, live heap space usage exhibits a very state-dependent behavior that renders direct application of schedulability analysis techniques unsuitable. In this paper we propose an analysis of live heap space upper bounds for real-time systems based on an accurate prediction of task execution orders. The key component of our analysis is the construction of a nondeterministic finite state machine capturing all task executions that are legal under given timing assumptions. By adding heap usage information inferred for each sequential task, our analysis finds an upper bound on the inter-task heap demands as the solution to an integer linear programming problem. Values so obtained are suitable inputs to other analyses depending on the size of a systems persistent state, such as running time prediction for a concurrent tracing garbage collector.

Enabling Component-Based Design for Embedded Real-Time Software

The increasing complexity of embedded software calls for a new, more efficient design approach. A natural choice is to use well-established component-based design; however, its adoption to design of embedded software has been slow and riddled with difficulties. It can be argued that these problems are due to the following peculiarities of embedded systems. Firstly, the tight integration between hardware and software, typical for embedded systems, makes it virtually impossible to model and implement software separately from hardware. Secondly, it is difficult to express timing requirements, an intrinsic part of functionality of many embedded systems, in dataflow abstractions traditionally used in component-based design. We propose to overcome these difficulties by introducing a uniform, consistent modeling of both hardware and software and by integrating timing requirements into the model. We present a modeling framework based on the notions of reactive objects and time-constrained reactions, which enables component-based design of embedded real-time systems. Within this framework, functionality of both hardware and software components is defined in terms of reactions to discrete external events, and timing requirements are specified for each reaction relative to the event that triggered it. We also present a detailed software design methodology for embedded real-time systems based on our modeling framework.

Taming code explosion in supercompilation

Supercompilation algorithms can perform great optimizations but sometimes suffer from the problem of code explosion. This results in huge binaries which might hurt the performance on a modern processor. We present a supercompilation algorithm that is fast enough to speculatively supercompile expressions and discard the result if it turned out bad. This allows us to supercompile large parts of the imaginary and spectral parts of nofib in a matter of seconds while keeping the binary size increase below 5%.

TinyTimber, reactive objects in C for real-time embedded systems

Embedded systems are often operating under hard real-time constraints. Such systems are naturally described as time-bound reactions to external events, a point of view made manifest in the high-level programming and systems modeling language Timber. In this paper we demonstrate how the Timber semantics for parallel reactive objects translates to embedded real-time programming in C. This is accomplished through the use of a minimalistic Timber Run-Time system, TinyTimber (TT). The TT kernel ensures state integrity, and performs scheduling of events based on given time-bounds in compliance with the Timber semantics. In this way, we avoid the volatile task of explicitly coding parallelism in terms of processes/threads/semaphores/monitors, and side-step the delicate task to encode time-bounds into priorities. In this paper, the TT kernel design is presented and performance metrics are presented for a number of representative embedded platforms, ranging from small 8-bit to more potent 32- bit micro controllers. The resulting system runs on bare metal, completely free of references to external code (even C-lib) which provides a solid basis for further analysis. In comparison to a traditional thread based real-time operating system for embedded applications (FreeRTOS), TT has tighter timing performance and considerably lower code complexity. In conclusion, TinyTimber is a viable alternative for implementing embedded real-time applications in C today.

Rethinking network management: Models, data-mining and self-learning

Network Service Providers are struggling to reduce cost and still improve customer satisfaction. We have looked at three underlying challenges to achieve these goals; an overwhelming flow of low-quality alarms, understanding the structure and quality of the delivered services, and automation of service configuration. This thesis proposes solutions in these areas based on domain-specific languages, data-mining and self-learning. Most of the solutions have been validated based on data from a large service provider. We look at how domain-models can be used to capture explicit knowledge for alarms and services. In addition, we apply data-mining and self-learning techniques to capture tacit knowledge. The validation shows that models improve the quality of alarm and service models, and enables automatic rendering of functions like root cause correlation, service and SLA status, as well as service configuration. The data-mining and self-learning solutions show that we can learn from available decisions made by experts and automatically assign alarm priorities.

A simple and flexible timing constraint logic

Formats for describing timing behaviors range from fixed menus of standard patterns, to fully open-ended behavioral definitions; of which some may be supported by formal semantic underpinnings, while others are better characterized as primarily informal notations. Timing descriptions that allow flexible extension within a fully formalized framework constitute a particularly interesting area in this respect. We present a small logic for expressing timing constraints in such an open-ended fashion, sprung out of our work with timing constraint semantics in the TIMMO-2-USE project [15]. The result is a non-modal, first-order logic over reals and sets of reals, which references the constrained objects solely in terms of event occurrences. Both finite and infinite behaviors may be expressed, and a core feature of the logic is the ability to restrict any constraint to just the finite ranges when a certain system mode is active. Full syntactic and semantic definitions of our formula language are given, and as an indicator of its expressiveness, we show how to express all constraint forms currently defined by TIMMO-2-USE and AUTOSAR. A separate section deals with the support for mode-dependencies that have been proposed for both frameworks, and we demonstrate by an example how our generic mode-restriction mechanism formalizes the details of such an extension.

Positive Supercompilation for a Higher-Order Call-By-Value Language

Previous deforestation and supercompilation algorithms may introduce accidental termination when applied to call-by-value programs. This hides looping bugs from the programmer, and changes the behavior of a program depending on whether it is optimized or not. We present a supercompilation algorithm for a higher-order call-by-value language and prove that the algorithm both terminates and preserves termination properties. This algorithm utilizes strictness information to decide whether to substitute or not and compares favorably with previous call-by-name transformations.