Slow Computing

From MurrayWiki
Jump to: navigation, search

This page is being written up for a report on the “Impact of Control,” being edited by Tariq Samad and Anuradha Annaswamy.

Current techniques for the design of software-enabled control systems rely on the existence of high performance sensing, actuation and computational devices that can be embedded within a physical system at modest cost. Driven by Moore's law, the success of this paradigm can be seen through the broad usage of feedback controllers in modern application areas, ranging from transportation to communications to medicine to robotics. The goal of this challenge lies at the other end of the computational spectrum: can we develop new principles and tools for the design of closed loop control systems using highly distributed, but slow, computational elements.

The motivation for control design using slow computing is to develop new architectures for feedback control systems that can be used in applications where computational power is extremely limited. One important class of such systems is that for which the energy usage of the system must remain small, either due to the source of power available (e.g. batteries or solar cells) or the physical size of the device (e.g. microscale and nanoscale robots). A longer term application area is in the design of control systems using novel computing substrates, such as biological circuits. A critical element in both cases is the tight coupling between the dynamics of the underlying process and the temporal properties of the algorithm that is controlling it.

Design of feedback systems using slow computing is particularly challenging due to the performance limitations placed on systems with computational delays that are comparable to the underlying dynamics. These systems are likely to use highly parallel, non-deterministic architectures to achieve what is normally accomplished through the tightly synchronized, serial interconnections of sensing, filtering, estimation, planning, regulation and actuation that are common in traditional control systems. Unfortunately, current techniques for systematic design of control systems assume a mostly serial processing architecture and techniques that make use of parallel architectures (such as neural networks) do not provide sufficiently systematic design methods. New research is required to develop the architectures, theory and tools required to design controllers where computational delay does not allow current techniques to be utilized.

Flyflight-circuitry.png Flyflight-block.png

Context

Current approaches to design of software-controlled systems make use of a combination of abstractions and design techniques that are often implicitly based on the assumption that significant computational capacity is available to implement computations and communications. This is a good assumption for many application areas where substantial amounts of computing can be embedded within a physical system to control the dynamical behavior of the underlying process. As a consequence, many of the approaches that are available for designing complex, cyberphysical systems rely on large amounts of computing to achieve complex and robust behavior.

As a complementary approach, consider instead the control system for a fruit fly, depicted in the figure at the top of the page. This system uses approximately 300,000 neurons with typical time constants in the range of 1--100 msec (10-1000 Hz) and has a physical size approximately equal to that of a sesame seed~\cite{mjd09-private}. Yet it is able to take off, land, avoid obstacles, find food and mate (among other things), often with performance that is beyond what we can do in engineered systems at this size scale. As just two specific instances, the control system of a fly is capable of executing saccades (rapid changes in direction) that occur at angular rates of up to 1800 deg/sec~\cite{BD06-JEB} and it can fly in wind gusts that are up to 2X its flight speed in air~\cite{FSDM09-inprep}.

Challenge

The goal of this challenge is to develop the fundamental insights and tools that would allow us to design control systems that can perform the tasks of modern high-speed control systems but using an architecture that is compatible with the speed of computation used by an insect. The development of such an architecture has the possibility of providing new ways of integrating control into systems where large amounts of fast computation are not easily available, either due to limitations on power, physical size or choice of computing substrate. It is likely that many of the tools and insights required to design such systems will be central to design of other classes of systems in which the effects of time delay, asynchronous execution of parallel computations and highly complex interconnections play a defining role.

A candidate architecture for implementation of such a system is shown below:

Slowncs-arch.png

The system consists of a set of agents that are interconnected through a network. Each individual agent has a highly structured inner loop, that interacts with a guarded commond language (GCL) protocol engine. The ``inner loop control system makes use of an interconnection matrix $L$, a set of asynchronous delays (represented by the blocks labeled $\tau$) and nonlinear elements $N(\cdot)$. Internal feedback between the nonlinear block and the interconnection block allows a general set of dynamical systems to be formed from this simple structure. The protocol-based feedback system modifies the inner loop dynamics, but also controls communications between other agents, using a packet-based communications network. In addition, assume that multiple agents interact with each other across a communcations network, using packet-based communication protocols. This network introduces another layer of variable time-delays and asynchronous behavior. It also enables the creation of complex interactions between agents, requiring formal tools for specification, design and verification.

And There's Much More

References and Resources