Nov 22, 2016
Jolley Hall, Room 309
"A Transactional Model and Platform for Designing and Implementing Reactive Systems"
Advisor: Chris Gill
Reactive programs such as operating systems, servers, and smart phone apps have ongoing asynchronous concurrent interactions with their environment. If developed with traditional models of concurrency and interaction this may lead to subtle timing bugs and other concurrency hazards, and may limit developers' ability to ensure correct behavior when systems are composed from smaller sub-systems. To overcome these limitations with the current state of the art, this dissertation makes four contributions to the state of the art in reactive systems.
First, we propose a formal yet practical model for (asynchronous) reactive systems called reactive components. A reactive component is a set of state variables and atomic transitions that can be composed with other reactive components to yield another reactive component. Within this model, (1) the result of composition is always another reactive component, for consistency of reasoning; (2) systems may be decomposed to an arbitrary degree and depth, to foster divide-and-conquer approaches when designing and re-use when implementing systems; (3) the behavior of a reactive component can be stated in terms of its interface, which is necessary for abstraction; and (4) properties of reactive components that are derived from transitions protected by encapsulation are preserved through composition, which permits assume-guarantee reasoning.
Second, we develop a prototypical programming language for reactive components called rcgo that is based on the syntax and semantics of the Go programming language. The semantics of the rcgo language enforce key aspects of the reactive component model, e.g., the isolation of state between components and safety of concurrency properties, while permitting techniques such as reference and move semantics. Third, we provide a run-time interpreter for the rcgo language that can detect composition hazards like recursively defined or non-deterministic transactions, and enforce the model efficiently on existing architectures. Fourth, we compare the performance of two schedulers for the run-time system to that of different custom compiled multi-threaded approaches. Results of our evaluations demonstrate that our run-time environment for reactive components can perform adequately in practice, but that additional work is necessary to approach the best performance achieved with customized compiled thread based approaches.