S. Dali (1952)Galatea of the Spheres

Amorphous Amorphous Computing Computing SystemsSystems

Jiří Wiedermann & Lukáš Petrů

Academy of Sciences Charles University

Prague, CZ

Institute of Computer Science

Academy of Sciences of the Czech Republic

Partially supported by grant 1ET100300517

Scientific fiction:Scientific fiction:• The Black Cloud by Fred Hoyle, 1957The Black Cloud by Fred Hoyle, 1957• A Deepness in the Sky by Vernor Vinge, 1999 A Deepness in the Sky by Vernor Vinge, 1999

Device MiniaturizationDevice Miniaturization Technology allows producing very small

energy efficient processors (MEMS, NEMS) equipped by sensors, transmitters and a power source

They can be built in large numbers→ Wireless (sensor) networks→ Amorphous computers (Smart Dust)

Cellular engineeringCellular engineering• Synthetic biology (Biots)

Motivation

A collection (of order 10^6 up to 10^12) of computational particles dispersed irregularly on a surface or throughout a volume creating a self-organizing computing network

Particles: • have no a priori knowledge about their positions, no identifiers• are possibly faulty, contain sensors and effectors, might be mobile• are not synchronized but operate at the same speed• are identically programmed

Each particle:• has energy source, modest computing power and modest amount of memory, random number generator, plus sender/receiver apparatus• Can communicate only with nearby neighbors (via radio, chemically, optically, acoustically,…)• communication is unreliable, no assurance of message delivery

m 1/1000 mm 1/1000 m 1/1000 nm Å

..

The Scale

Possible applications:

• Traffic control, • people and item tracking in buildings, • monitoring plant yield in agriculture, • environment monitoring, • weather forecast, • ocean, atmosphere and underwater flow, • intruder detection, • battle field surveillance, • artificial immune systems in the blood stream, • space prospecting, etc.

Amorphous Computer Amorphous Computer

A bag containing a large number of computing elements

Amorphous ComputerAmorphous Computer

Amorphous ComputerAmorphous Computer

Amorphous ComputerAmorphous Computer

A simple model: synchronous static amorphous computer

• all processors are the same, have no identifiers, and can be modeled by finite automata• the nodes communicate via a single channel radio with each other only within a bounded distance• the nodes are synchronizedAssumptions:• a uniformly distributed set of processors in a bounded area• no “big holes” in the actual distribution of nodes• the number of neighbors of a node is bounded by a fixed constantExperiment: wave propagation

Simulating a two-dimensional cellular automaton:

• establish a regular 2D grid consisting of so-called virtual cells over the nodes of the amorphous computer

• in one round simulate one (parallel) step of a cellular automaton by letting the nodes in each virtual cell communicate with the nodes from the neighboring virtual cells •

Rows and columns formation in an amorphous computer:

Grid formation with node density 20:

Theorem 1: Let C be an amorphous computer whose target square area consists of M squares of size r r. The probability that some square is not covered by any node or that nodes of one square cannot communicate with any node in some adjacent square is not greater than 5M(1-1/5M)^N.

Theorem 2: Any n n cellular automaton can be simulated by a well-formed synchronous amorphous computer with O(n n) nodes with a constant slow-down.

Well-formed: there is a constant c1 such the square area of the amorphous computer can be covered by a regular grid in such a way that each virtual cell contains at least one and at most c nodes of the amorphous computer.

Registers

Size O(log N) bits

Control unit

…

Random numberRadio

Transceiver

Local clock, not synchronized with other nodes

No identifiers

Radio transceiver: single channel limited range r No collision detection (a node cannot distinguish the case of no broadcasting from the case of two or more nodes broadcasting simultaneously)A node of an amorphous computer

A more realistic model: asynchronous AC

Random TopologyRandom Topology

When the node topology is random, what are the necessary conditions for the communication among nodes to work?

For low densities, majority of nodes will beisolated

Random TopologyRandom Topology

For medium densities, there will be many fixed-sizes components

Node density: average number of nodes in the communication area of one node:

d=Nr²/a

where a is the size of A

Random TopologyRandom Topology

High density

For high densities, above so-called percolation threshold, one large component containing almost all nodes will emerge

Experiments: d=6 gives components of size ~0.5N in 98% of cases

Important properties of Important properties of random communication random communication

graphsgraphs Connectivity: one large connected component (“giant

component”) containing majority of nodes (a density above percolation threshold is needed) Remark: Determining percolation threshold is an important open

problem, with many applications

Small diameter; asymptotically, D=N (verified experimentally)

Bounded node degree; asymptotically, deg=~logN/loglog N with probability ~1/N (proved analytically)

Jungle telegraph

• No synchronization• no addresses• no sense of direction• no collision detection

Protocol SendProtocol Send transmitting a message to node’s neighbours; the key ideas:

– send sporadically (in order to avoid broadcast conflicts),– Repeat sending a few times (increases the probability of error-free

message receiving)

procedure Send (m:message; p:probability; k:integer) if the processor is not locked w.r.t m then for i := 1 to k do

{ Wait for time 2T;With probability p do Send message m};

lock the processor w.r.t m;

Theorem: If all nodes of the network use algorithm Send, then the probability that a message fails to be delivered from a sender to any of its neighbours is at most ε.

The protocol works in time O (Q log (1/ε) ).

Protocol FloodProtocol FloodPurpose: message m is to be delivered from node X to

all other network nodes Assumption: all nodes, except of X, are not locked

w.r.t m; Algorithm:

– X sends m with probability /N using SEND– Upon receiving m, the respective node also starts

sending m– After re-sending m once, any node locks itself w.r.t

m; – This continues until the base station after time

O(DQ log(N/) floods the network by another signal

Protocol FloodProtocol Flood

Theorem:On a network of diameter D, in which all nodes, are not locked w.r.t. m, algorithm Flood started at X sending m will run in timeO(D · Q · log (N/ε)), and

with probability 1-ε, message m from X will be delivered to each node

at the end, all nodes will be locked w.r.t m

Simulating a RAMAssumptions: The simulating AC has one large connected component of size N of diameter

D and maximum neighborhood size Q containing the base station The unit time complexity of our RAM is T(n); each RAM register is of size O(log

T(n))=O(log N) The nodes are used as RAM registers while RAM accumulators are in the base

station The simulation is controlled by the base station where the RAM program also

resides

Simulation consists of three phases: 1. Address assignment using the random no. generators in nodes2. Input reading and register initialization – via the base node3. Simulation – using protocol FLOOD from communication between the

nodes with the respective addresses

The complexity of simulation:

• Theorem: a unit-cost RAM of time complexity T(n) and space complexity S(n) can be simulated by an amorphous computer of size N>2S(n) in time

• O(T(n) D Q log(2NT(n)/)), • with probability of failure at most

• D – network diameter• Q – neighbourhood size

Remark: our AC is a non-uniform model

Communicating mobile nano-machines

Nano-machines• molecular cell-sized devices or engineered organisms • produced by self-assembly or self-replication • capable of performing simple tasks such as actuation and sensing

Communication Molecular Conventional

Carrier Molecule Electromagnetic waves

Signal type Chemical Digital

Propagation Slow (by diffusion) Fast (light speed)

Environment Aqueous Airborne or cable

Energy costs Low High

Reliability Low (stochastic) High accuracy

• A finite number of nanomachines freely moving (actively or passively) in a closed liquid environment

• no external control

• interaction via molecular communication

Computational/Communication Scenario:

Recei-ver

Sender

Sender

Sender

Nano-machine Computational Model

Timed probabilistic finite-state automaton – • each transition has a probability value and a timer assigned determining the likelihood that the transition occurs and the time at which it does so; • a timer can be reset by a transition and since that time the timer starts running

A biomolecular realization of probabilistic automata has been described, e.g., in Adar R., Benenson Y., Linshiz G., Rozner A, Tishby N., Shapiro E.: Stochastic computing with biomolecular automata. Proc. Natl. Acad. Sci. USA, 101, pp. 9960-65, 2004

Open: biomolecular timer realization

Distributed computing through nano-machines

Idea:• represent the input in unary, i.e., each machines reads a symbol from {0,1} via a special sensor and stores it in its state• simulate a so-called counter machine:

Elementary operations:• add and subtract 1• test for zero

Counter – a set of nanomachines in the same stateBoth adding and subtracting 1 requires determining ofa single nanomachine – so-called leader

Determining a leader by randomized halving of a set:

Theorem: a nanonet can correctly simulate a counter machine with a high probability

Throughout, protocols SEND and FLOOD are used

Flying amorphous computerModel: the same as in the case of a static asynchronousamorphous computer (“a RAM with distributed registers”), but this time the nodes are mobile.

The nodes move in a square area in random directions, with a constant speed, bouncing when reaching a boundary:

Obviously, protocol SEND will also workin this case, but FLOOD need not work at all, because there is a new kind of problems:

A node’s temporal inaccessibility…

We say that a flying amorphous computer is a lively flying computer if any of its nodes cannot stay isolated (unreachable) from other nodes for an infinite time.

That is, for any node the following property holds: if a message is repeatedly broadcast from that node then after a finite time the message will reach all other nodes.

No upper bound on the time complexity for actionsof lively flying amorphous computers can be given

Broadcasting in a flying amorphous computer

Simulating a RAM

1. Address assignment: repeatedly use the leader selection strategy for assigning addresses 1,2,…

N0.

2. Reading the input into the first registers (see the next item) and initializing the rest of the

registers

3. The base node simulates the individual RAM instructions:

• It alternates between sending a request to perform an instruction in a specific register and expecting the acknowledgement from it

until such an acknowledgement is received (this must happen in a finite time)

Theorem: Let M1 be a RAM with N0 registers of length s1 bits. Let M2 be a lively flying amorphous computer with N N0 nodes. Let the nodes of M2 have assigned unique addresses and contain the input values.

Then there exists a simulation algorithm such that M2 correctly simulates the computation of M1 on a given input.

The simulation ends in a finite time.

Experimental validation of the communication protocol

Average time needed to send a message and to receive a reply. Parameter l (decreased after each broadcast) ranging from 50 to 180 denotes the number of the broadcast steps of the Broadcast protocol; parameter p (probability of sending) ranges from 0.3 to 0.9. Darker color represents better values.

N=400d=6

Average time needed to send a message and to receive a reply. Speed v goes from 0.0001 to 1.

Can a Turing machine simulate a flying amorphous computer?

Scenario: the AC processorsfly about, read the (changeable)input data from the environmentand compute some function of the data

The problem of the“mobile parallel input”

?

ConclusionConclusion

We have …

Introduced a new class of computing devices: amorphous computers inspired both by nature and scientific imagination

Shown the universal computing power of families of such computers

Members of the respective families are among the simplest computational devices possessing universal computing power

Further research is needed to better understand the paradigm of amorphous computing