1,588 research outputs found
Scalable data abstractions for distributed parallel computations
The ability to express a program as a hierarchical composition of parts is an
essential tool in managing the complexity of software and a key abstraction
this provides is to separate the representation of data from the computation.
Many current parallel programming models use a shared memory model to provide
data abstraction but this doesn't scale well with large numbers of cores due to
non-determinism and access latency. This paper proposes a simple programming
model that allows scalable parallel programs to be expressed with distributed
representations of data and it provides the programmer with the flexibility to
employ shared or distributed styles of data-parallelism where applicable. It is
capable of an efficient implementation, and with the provision of a small set
of primitive capabilities in the hardware, it can be compiled to operate
directly on the hardware, in the same way stack-based allocation operates for
subroutines in sequential machines
Automated Algebraic Reasoning for Collections and Local Variables with Lenses
Lenses are a useful algebraic structure for giving a unifying semantics to program variables in a variety of store models. They support efficient automated proof in the Isabelle/UTP verification framework. In this paper, we expand our lens library with (1) dynamic lenses, that support mutable indexed collections, such as arrays, and (2) symmetric lenses, that allow partitioning of a state space into disjoint local and global regions to support variable scopes. From this basis, we provide an enriched program model in Isabelle/UTP for collection variables and variable blocks. For the latter, we adopt an approach first used by Back and von Wright, and derive weakest precondition and Hoare calculi. We demonstrate several examples, including verification of insertion sor
AGENT-BASED UNDER HOOD PACKING
Improving vehicle performance and passenger comfort has been a prime engineering concern and focus of research for many years in automotive design. Turning to high-performance components in an effort to improve vehicle performance alone is often not enough and their placement and interactions with other components should also be an integral part of the improvement process. With the advancement in hybrid electric vehicle technology, the packing of components under the hood is ever more essential and challenging. Under hood packing is a multi-objective optimization problem with many, and mostly conflicting objectives. A non-deterministic multi-objective evolutionary algorithm needs to be integrated with the packing algorithm to obtain solutions. However, it is almost impossible to find optimal solutions in a limited amount of time due to the computationally intensive algorithm. Therefore, a new and efficient approach needs to be developed. This study applies an agent-based approach to the under hood vehicle packing problem with three objectives, namely: center of gravity, survivability, and maintainability subject to no overlap among components and with the enclosure, and minimum ground clearance. As per the weak notion of agency, a layered architecture is built with an agent on top of object model. A non-deterministic evolutionary multi-objective algorithm (AMGA-2) is used to identify non-dominated solutions, speed up the convergence to a non-dominated set and prevents unpredictability in the agent system. The developed agent-based model is applied to a passenger car but, it can also address large packing problems for SUVs and Trucks (FMTV). This work demonstrates the applicability and benefits of an agent-based approach to the packing problem
Efficient abstractions for visualization and interaction
Abstractions, such as functions and methods, are an essential tool for any programmer. Abstractions encapsulate the details of a computation: the programmer only needs to know what the abstraction achieves, not how it achieves it. However, using abstractions can come at a cost: the resulting program may be inefficient. This can lead to programmers not using some abstractions, instead writing the entire functionality from the ground up. In this thesis, we present several results that make this situation less likely when programming interactive visualizations. We present results that make abstractions more efficient in the areas of graphics, layout and events
Bluefish: A Relational Framework for Graphic Representations
Complex graphic representations -- such as annotated visualizations,
molecular structure diagrams, or Euclidean geometry -- convey information
through overlapping perceptual relations. To author such representations, users
are forced to use rigid, purpose-built tools with limited flexibility and
expressiveness. User interface (UI) frameworks provide only limited relief as
their tree-based models are a poor fit for expressing overlaps. We present
Bluefish, a diagramming framework that extends UI architectures to support
overlapping perceptual relations. Bluefish graphics are instantiated as
relational scenegraphs: hierarchical data structures augmented with adjacency
relations. Authors specify these relations with scoped references to components
found elsewhere in the scenegraph. For layout, Bluefish lazily materializes
necessary coordinate transformations. We demonstrate that Bluefish enables
authoring graphic representations across a diverse range of domains while
preserving the compositional and abstractional affordances of traditional UI
frameworks. Moreover, we show how relational scenegraphs capture previously
latent semantics that can later be retargeted (e.g., for screen reader
accessibility).Comment: 27 pages, 14 figure
Synthesizing stream control
For the management of reactive systems, controllers must coordinate time, data streams, and data transformations, all joint by the high level perspective of their control flow. This control flow is required to drive the system correctly and continuously, which turns the development into a challenge. The process is error-prone, time consuming, unintuitive, and costly. An attractive alternative is to synthesize the system instead, where the developer only needs to specify the desired behavior. The synthesis engine then automatically takes care of all the technical details. However, while current algorithms for the synthesis of reactive systems are well-suited to handle control, they fail on complex data transformations due to the complexity of the comparably large data space. Thus, to overcome the challenge of explicitly handling the data we must separate data and control.
We introduce Temporal Stream Logic (TSL), a logic which exclusively argues about the control of the controller, while treating data and functional transformations as interchangeable black-boxes. In TSL it is possible to specify control flow properties independently of the complexity of the handled data. Furthermore, with TSL at hand a synthesis engine can check for realizability, even without a concrete implementation of the data transformations. We present a modular development framework that first uses synthesis to identify the high level control flow of a program. If successful, the created control flow then is extended with concrete data transformations in order to be compiled into a final executable.
Our results also show that the current synthesis approaches cannot replace existing manual development work flows immediately. During the development of a reactive system, the developer still may use incomplete or faulty specifications at first, that need the be refined after a subsequent inspection. In the worst case, constraints are contradictory or miss important assumptions, which leads to unrealizable specifications. In both scenarios, the developer needs additional feedback from the synthesis engine to debug errors for finally improving the system specification. To this end, we explore two further possible improvements. On the one hand, we consider output sensitive synthesis metrics, which allow to synthesize simple and well structured solutions that help the developer to understand and verify the underlying behavior quickly. On the other hand, we consider the extension of delay, whose requirement is a frequent reason for unrealizability. With both methods at hand, we resolve the aforementioned problems and therefore help the developer in the development phase with the effective creation of a safe and correct reactive system.Um reaktive Systeme zu regeln mĂŒssen SteuergerĂ€te Zeit, Datenströme und Datentransformationen koordinieren, die durch den ĂŒbergeordneten Kontrollfluss zusammengefasst werden. Die Aufgabe des Kontrollflusses ist es das System korrekt und dauerhaft zu betreiben. Die Entwicklung solcher Systeme wird dadurch zu einer Herausforderung, denn der Prozess ist fehleranfĂ€llig, zeitraubend, unintuitiv und kostspielig. Eine attraktive Alternative ist es stattdessen das System zu synthetisieren, wobei der Entwickler nur das gewĂŒnschte Verhalten des Systems festlegt. Der Syntheseapparat kĂŒmmert sich dann automatisch um alle technischen Details. WĂ€hrend aktuelle Algorithmen fĂŒr die Synthese von reaktiven Systemen erfolgreich mit dem Kontrollanteil umgehen können, versagen sie jedoch, sobald komplexe Datentransformationen hinzukommen, aufgrund der KomplexitĂ€t des vergleichsweise groĂen Datenraums. Daten und Kontrolle mĂŒssen demnach getrennt behandelt werden, um auch groĂe DatenrĂ€umen effizient handhaben zu können. Wir prĂ€sentieren Temporal Stream Logic (TSL), eine Logik die ausschlieĂlich die Kontrolle einer Steuerung betrachtet, wohingegen Daten und funktionale Datentransformationen als austauschbare Blackboxen gehandhabt werden. In TSL ist es möglich Kontrollflusseigenschaften unabhĂ€ngig von der KomplexitĂ€t der zugrunde liegenden Daten zu beschreiben. Des Weiteren kann ein auf TSL beruhender Syntheseapparat die Realisierbarkeit einer Spezifikation prĂŒfen, selbst ohne die konkreten Implementierungen der Datentransformationen zu kennen. Wir prĂ€sentieren ein modulares GrundgerĂŒst fĂŒr die Entwicklung. Es verwendet zunĂ€chst den Syntheseapparat um den ĂŒbergeordneten Kontrollfluss zu erzeugen. Ist dies erfolgreich, so wird der resultierende Kontrollfluss um die konkreten Implementierungen der Datentransformationen erweitert und anschlieĂend zu einer ausfĂŒhrbare Anwendung kompiliert. Wir zeigen auch auf, dass bisherige Syntheseverfahren bereits existierende manuelle Entwicklungsprozesse noch nicht instantan ersetzen können. Im Verlauf der Entwicklung ist es auch weiterhin möglich, dass der Entwickler zunĂ€chst unvollstĂ€ndige oder fehlerhafte Spezifikationen erstellt, welche dann erst nach genauerer Betrachtung des synthetisierten Systems weiter verbessert werden können. Im schlimmsten Fall sind Anforderungen inkonsistent oder wichtige Annahmen ĂŒber das Verhalten fehlen, was zu unrealisierbaren Spezifikationen fĂŒhrt. In beiden FĂ€llen benötigt der Entwickler zusĂ€tzliche RĂŒckmeldungen vom Syntheseapparat, um Fehler zu identifizieren und die Spezifikation schlussendlich zu verbessern. In diesem Zusammenhang untersuchen wir zwei mögliche Erweiterungen. Zum einen betrachten wir ausgabeabhĂ€ngige Metriken, die es dem Entwickler erlauben einfache und wohlstrukturierte Lösungen zu synthetisieren die verstĂ€ndlich sind und deren Verhalten einfach zu verifizieren ist. Zum anderen betrachten wir die Erweiterung um Verzögerungen, welche eine der Hauptursachen fĂŒr Unrealisierbarkeit darstellen. Mit beiden Methoden beheben wir die jeweils zuvor genannten Probleme und helfen damit dem Entwickler wĂ€hrend der Entwicklungsphase auch wirklich das reaktive System zu kreieren, dass er sich auch tatsĂ€chlich vorstellt
Recommended from our members
Modular and Safe Event-Driven Programming
Asynchronous event-driven systems are ubiquitous across domains such as device drivers, distributed systems, and robotics. These systems are notoriously hard to get right as the programmer needs to reason about numerous control paths resulting from the complex interleaving of events (or messages) and failures. Unsurprisingly, it is easy to introduce subtle errors while attempting to fill in gaps between high-level system specifications and their concrete implementations.This dissertation proposes new methods for programming safe event-driven asynchronous systems.In the first part of the thesis, we present ModP, a modular programming framework for compositional programming and testing of event-driven asynchronous systems.The ModP module system supports a novel theory of compositional refinement for assume-guarantee reasoning of dynamic event-driven asynchronous systems. We build a complex distributed systems software stack using ModP.Our results demonstrate that compositional reasoning can help scale model-checking (both explicit and symbolic) to large distributed systems.ModP is transforming the way asynchronous software is built at Microsoft and Amazon Web Services (AWS). Microsoft uses ModP for implementing safe device drivers and other software in the Windows kernel.AWS uses ModP for compositional model checking of complex distributed systems. While ModP simplifies analysis of such systems, the state space of industrial-scale systems remains extremely large.In the second part of this thesis, we present scalable verification and systematic testing approaches to further mitigate this state-space explosion problem.First, we introduce the concept of a delaying explorer to perform prioritized exploration of the behaviors of an asynchronous reactive program. A delaying explorer stratifies the search space using a custom strategy (tailored towards finding bugs faster), and a delay operation that allows deviation from that strategy. We show that prioritized search with a delaying explorer performs significantly better than existing approaches for finding bugs in asynchronous programs.Next, we consider the challenge of verifying time-synchronized systems; these are almost-synchronous systems as they are neither completely asynchronous nor synchronous.We introduce approximate synchrony, a sound and tunable abstraction for verification of almost-synchronous systems. We show how approximate synchrony can be used for verification of both time-synchronization protocols and applications running on top of them.Moreover, we show how approximate synchrony also provides a useful strategy to guide state-space exploration during model-checking.Using approximate synchrony and implementing it as a delaying explorer, we were able to verify the correctness of the IEEE 1588 distributed time-synchronization protocol and, in the process, uncovered a bug in the protocol that was well appreciated by the standards committee.In the final part of this thesis, we consider the challenge of programming a special class of event-driven asynchronous systems -- safe autonomous robotics systems.Our approach towards achieving assured autonomy for robotics systems consists of two parts: (1) a high-level programming language for implementing and validating the reactive robotics software stack; and (2) an integrated runtime assurance system to ensure that the assumptions used during design-time validation of the high-level software hold at runtime.Combining high-level programming language and model-checking with runtime assurance helps us bridge the gap between design-time software validation that makes assumptions about the untrusted components (e.g., low-level controllers), and the physical world, and the actual execution of the software on a real robotic platform in the physical world. We implemented our approach as DRONA, a programming framework for building safe robotics systems.We used DRONA for building a distributed mobile robotics system and deployed it on real drone platforms. Our results demonstrate that DRONA (with the runtime-assurance capabilities) enables programmers to build an autonomous robotics software stack with formal safety guarantees.To summarize, this thesis contributes new theory and tools to the areas of programming languages, verification, systematic testing, and runtime assurance for programming safe asynchronous event-driven across the domains of fault-tolerant distributed systems and safe autonomous robotics systems
Multi-scale data storage schemes for spatial information systems
This thesis documents a research project that has led to the design and prototype
implementation of several data storage schemes suited to the efficient multi-scale
representation of integrated spatial data. Spatial information systems will benefit from
having data models which allow for data to be viewed and analysed at various levels
of detail, while the integration of data from different sources will lead to a more
accurate representation of reality.
The work has addressed two specific problems. The first concerns the design of an
integrated multi-scale data model suited for use within Geographical Information
Systems. This has led to the development of two data models, each of which allow for
the integration of terrain data and topographic data at multiple levels of detail. The
models are based on a combination of adapted versions of three previous data
structures, namely, the constrained Delaunay pyramid, the line generalisation tree and
the fixed grid.
The second specific problem addressed in this thesis has been the development of an
integrated multi-scale 3-D geological data model, for use within a Geoscientific
Information System. This has resulted in a data storage scheme which enables the
integration of terrain data, geological outcrop data and borehole data at various levels
of detail.
The thesis also presents details of prototype database implementations of each of the
new data storage schemes. These implementations have served to demonstrate the
feasibility and benefits of an integrated multi-scale approach.
The research has also brought to light some areas that will need further research before
fully functional systems are produced. The final chapter contains, in addition to
conclusions made as a result of the research to date, a summary of some of these areas
that require future work
- âŠ