Taylor L. Riché

Upright cluster services

The UpRight library seeks to make Byzantine fault tolerance (BFT) a simple and viable alternative to crash fault tolerance for a range of cluster services. We demonstrate UpRight by producing BFT versions of the Zookeeper lock service and the Hadoop Distributed File System (HDFS). Our design choices in UpRight favor simplifying adoption by existing applications; performance is a secondary concern. Despite these priorities, our BFT Zookeeper and BFT HDFS implementations have performance comparable with the originals while providing additional robustness.

A case for run-time adaptation in packet processing systems

Most packet processing applications receive and process multiple types of packets. Today, the processors available within packet processing systems are allocated to packet types at design time. In this paper, we explore the benefits and challenges of adapting allocations of processors to packet types in packet processing systems. We demonstrate that, for all the applications and traces considered, run-time adaptation can reduce energy consumption by 70--80% and processor provisioning level by 40--50%. The adaptation benefits are maximized if processor allocations can be adapted at fine time-scales and if the total available processing power can be allocated to packet types in small granularities. We show that, of these two factors, allocating processing power to packet types is small granularity is more important---if the allocation granularity is large, then even a very fine adaptation time-scale yields meager benefits.

Pushouts in software architecture design

A classical approach to program derivation is to progressively extend a simple specification and then incrementally refine it to an implementation. We claim this approach is hard or impractical when reverse engineering legacy software architectures. We present a case study that shows optimizations and pushouts---in addition to refinements and extensions---are essential for practical stepwise development of complex software architectures.

Rapid and high-level constraint-driven prototyping using lab VIEW FPGA

Many varied domain experts use Lab VIEW as a graphical system design tool to implement DSP algorithms on myriad target architectures. In this paper, we introduce the latest LabVIEW FPGA compiler that enables domain experts with minimum hardware knowledge to quickly implement, deploy, and verify their domain-specific applications on FPGA hardware. We present two compiler techniques that we use to 1) extract extra parallelism from a users application to take advantage of the parallel hardware resources of the FPGA and 2) minimize memory-access traffic, which is often a bottleneck that restricts overall FPGA performance. Finally, our approach provides the user a simple constraint-driven experience to maximize their development efficiency. We use two case studies in two different domains, a 3GPP Turbo decoder and a Smith-Waterman algorithm, to show the benefits our tool provides to users.

Is the derivation of a model easier to understand than the model itself

Software architectures can be presented by graphs with components as nodes and connectors as edges. These graphs, or models, typically encode expert domain knowledge, which makes them difficult to understand. Hence, instead of presenting a complete complex model, we can derive it from a simple, easy-to-understand model by a set of easy-to-understand transformations. In two controlled experiments, we evaluate whether a derivation of a model is easier to understand than the model itself.

From Software Extensions to Product Lines of Dataflow Programs

Dataflow programs are widely used. Each program is a directed graph where nodes are computations and edges indicate the flow of data. In prior work, we reverse-engineered legacy dataflow programs by deriving their optimized implementations from a simple specification graph using graph transformations called refinements and optimizations. In MDE speak, our derivations were PIM-to-PSM mappings. In this paper, we show how extensions complement refinements, optimizations, and PIM-to-PSM derivations to make the process of reverse engineering complex legacy dataflow programs tractable. We explain how optional functionality in transformations can be encoded, thereby enabling us to encode product lines of transformations as well as product lines of dataflow programs. We describe the implementation of extensions in the

Lagniappe: Multi-* Programming Made Simple

\mathtt{ReFlO}

Convergence analysis of program variables

ReFlO tool and present two non-trivial case studies as evidence of our work’s generality.