Michael P. Ashley-Rollman

Meld: A declarative approach to programming ensembles

This paper presents Meld, a programming language for modular robots, i.e., for independently executing robots where inter-robot communication is limited to immediate neighbors. Meld is a declarative language, based on P2, a logic- programming language originally designed for programming overlay networks. By using logic programming, the code for an ensemble of robots can be written from a global perspective, as opposed to a large collection of independent robot views. This greatly simplifies the thought process needed for programming large ensembles. Initial experience shows that this also leads to a considerable reduction in code size and complexity. An initial implementation of Meld has been completed and has been used to demonstrate its effectiveness in the Claytronics simulator. Early results indicate that Meld programs are considerably more concise (more than 20times shorter) than programs written in C++, while running nearly as efficiently.

A Language for Large Ensembles of Independently Executing Nodes

We address how to write programs for distributed computing systems in which the network topology can change dynamically. Examples of such systems, which we call ensembles , include programmable sensor networks (where the network topology can change due to failures in the nodes or links) and modular robotics systems (whose physical configuration can be rearranged under program control). We extend Meld [1], a logic programming language that allows an ensemble to be viewed as a single computing system. In addition to proving some key properties of the language, we have also implemented a complete compiler for Meld. It generates code for TinyOS [14] and for a Claytronics simulator [12]. We have successfully written correct, efficient, and complex programs for ensembles containing over one million nodes.

Generalizing metamodules to simplify planning in modular robotic systems

In this paper we develop a theory of metamodules and an associated distributed asynchronous planner which generalizes previous work on metamodules for lattice-based modular robotic systems. All extant modular robotic systems have some form of non-holonomic motion constraints. This has prompted many researchers to look to metamodules, i.e., groups of modules that act as a unit, as a way to reduce motion constraints and the complexity of planning. However, previous metamodule designs have been specific to a particular modular robot. By analyzing the constraints found in modular robotic systems we develop a holonomic metamodule which has two important properties: (1) it can be used as the basic unit of an efficient planner and (2) it can be instantiated by a wide variety of different underlying modular robots, e.g., modular robot arms, expanding cubes, hex-packed spheres, etc. Using a series of transformations we show that our practical metamodule system has a provably complete planner. Finally, our approach allows the task of shape transformation to be separated into a planning task and a resource allocation task. We implement our planner for two different metamodule systems and show that the time to completion scales linearly with the diameter of the ensemble.

Distributed Localization of Modular Robot Ensembles

Internal localization, the problem of estimating relative pose for each module of a modular robot, is a prerequisite for many shape control, locomotion, and actuation algorithms. In this paper, we propose a robust hierarchical approach that uses normalized cut to identify dense sub-regions with small mutual localization error, then progressively merges those sub-regions to localize the entire ensemble. Our method works well in both two and three dimensions, and requires neither exact measurements nor rigid inter-module connectors. Most of the computations in our method can be distributed effectively. The result is a robust algorithm that scales to large ensembles. We evaluate our algorithm in two- and three-dimensional simulations of scenarios with up to 10,000 modules.

Blinky blocks: a physical ensemble programming platform

A major impediment to understanding programmable matter is the lack of an existing system with sufficiently many modules of sufficient capabilities. In this paper we describe the requirements of physically distributed ensembles and discuss the use of the distributed programming language Meld to program ensembles of these units. We demonstrate a new system designed to meet these requirements called Blinky Blocks and discuss the hardware design we used to create 100 of these modules.

Simulating multi-million-robot ensembles

Various research efforts have focused on scaling modular robotic systems up to millions of cooperating devices. However, such efforts have been hampered by the lack of prototype hardware in such quantities and the unavailability of accurate and highly scalable simulations. This paper describes a simulation framework for such systems, which can model the execution of distributed software and the physical interaction between modules. We develop a scalable, multithreaded version of an off-the-shelf physics engine, and create a software execution engine that can efficiently harness hundreds of cores in a cluster of commodity machines. Our approach is shown to run 108x faster than a previous scalable simulator, and permit simulations with over 20 million modules.

Research Summary: Logic Programming for Massively Distributed Systems

My research focuses on finding a better way to program massively distributed systems. Programming these systems is crucial as we move into a world where they are increasingly necessary. Unforunately, existing concurrency models in modern languages are very difficult for programmers to understand and to reason about. Many programmers have an extremely hard time writing and debugging concurrent programs, let alone massively distributed ones. Race conditions, in particular, are among the most challenging bugs to find, understand, and resolve.