Self-developing blob machines for spatial computing: the foundations

Technology can now produce massive hardware resources, large enough so that it becomes increasingly difficult to organize it in a centralized way. Spatial computing proposes to model such huge hardware as a relatively homogeneous computing medium satisfying a locality constraint: communication time is related to geometric distance. While the constraint is weak enough to allow arbitrary scalability, it is strong enough to make the tasks of programming and mapping significantly more complex; programming thus becomes the central problem. We propose a two level programming approach: at low level, a run time system layer runs on the computing medium and transforms it into a virtual machine, called the blob machine; at high level, programs run on this more expressive virtual machine. The system layer is implemented on the computing medium as a local rule that manages distributed objects similar to membranes and filament channels; system calls are distributed primitives that allow objects to be created or deleted. The physical interpretation of the objects allows the implementation on arbitrary spatial computing medium. This layer is responsible for placing the objects in the space and does it by simulating physical forces. Each object is controlled by a FSA (Finite State Automaton) whose output actions are the object primitives (creation \& deletion). The set of FSAs together with the communication pathways implied by the topology of encapsulated membranes and channels, define a network of FSA that can self develop. This ``self-developing network of FSA'' is the formal definition of the blob machine. We present this blob machine, and how to program it using a higher level language description. We illustrate the execution of many examples of small and simple programs that cover a wide spectrum of parallel paradigms, including SIMD, data parallelism, Divide and Conquer and pipelining. Usually, if the problem needs a space of O(n), the time complexity can be reduced to O(n^{1/d}) where d is the dimensionality of the computing medium: 2D, or 3D. In some cases the same program runs optimally for any value of d, in other cases, the dimensionality must be considered. Citation about a computer using physical objects as primitives, like blobs and channels, which has given us inspiration: `The kinematic model [of self reproducing machine] deals with the geometric-kinematic problems of movement, contact, positioning, fusing and cutting'', John Von Neumann, Theory of Self-Reproducing Automata, 1966.

[1]  Frédéric Gruau,et al.  Cellular Gravity , 2000, Parallel Process. Lett..

[2]  David B. Skillicorn,et al.  Models and languages for parallel computation , 1998, CSUR.

[3]  Radhika Nagpal Programmable self-assembly: constructing global shape using biologically-inspired local interactions and origami mathematics , 2001 .

[4]  K. Kennedy,et al.  Automatic Data Layout for High Performance Fortran , 1995, Proceedings of the IEEE/ACM SC95 Conference.

[5]  Thomas Lengauer VLSI Theory , 1990, Handbook of Theoretical Computer Science, Volume A: Algorithms and Complexity.

[6]  Tommaso Toffoli,et al.  Cellular automata machines - a new environment for modeling , 1987, MIT Press series in scientific computation.

[7]  Chris Hanson,et al.  Amorphous computing , 2000, Commun. ACM.

[8]  John von Neumann,et al.  Theory Of Self Reproducing Automata , 1967 .

[9]  M. Arbib,et al.  Neural Organization: Structure, Function, and Dynamics , 1997 .

[10]  John Wawrzynek,et al.  Stream Computations Organized for Reconfigurable Execution (SCORE) , 2000, FPL.

[11]  Guy Durrieu,et al.  MaRS, a Combinator Graph Reduction Multiprocessor , 1989, PARLE.

[12]  Dario Floreano,et al.  POEtic Tissue: An Integrated Architecture for Bio-inspired Hardware , 2003, ICES.

[13]  Stephen A. Cook,et al.  Parallel pointer machines , 2005, computational complexity.

[14]  Guy E. Blelloch,et al.  NESL: A Nested Data-Parallel Language (Version 2.6) , 1993 .

[15]  Seth Copen Goldstein,et al.  Scalable shape sculpting via hole motion: motion planning in lattice-constrained modular robots , 2006, Proceedings 2006 IEEE International Conference on Robotics and Automation, 2006. ICRA 2006..

[16]  John E. Savage,et al.  Evaluation of design strategies for stochastically assembled nanoarray memories , 2005, JETC.

[17]  K. Tomita,et al.  Graph automata: natural expression of self-reproduction , 2002 .

[18]  Gheorghe Paun,et al.  Membrane Computing , 2002, Natural Computing Series.

[19]  Chris Dwyer,et al.  Circuit and System Architecture for DNA-Guided Self-Assembly of Nanoelectronics , 2004 .

[20]  Frédéric Gruau,et al.  Computing Media and Languages for Space-Oriented Computation, 03.09. - 08.09.2006 , 2007, Computing Media and Languages for Space-Oriented Computation.

[21]  J. Van Leeuwen,et al.  Handbook of theoretical computer science - Part A: Algorithms and complexity; Part B: Formal models and semantics , 1990 .

[22]  Edmond Schonberg,et al.  Programming with Sets: An Introduction to SETL , 1986 .

[23]  James Aspnes,et al.  An Introduction to Population Protocols , 2007, Bull. EATCS.

[24]  Olivier Temam,et al.  BLOB computing , 2004, CF '04.

[25]  Pinaki Mazumder,et al.  VLSI cell placement techniques , 1991, CSUR.

[26]  Jean-Louis Giavitto,et al.  Invited Talk: Topological Collections, Transformations and Their Application to the Modeling and the Simulation of Dynamical Systems , 2003, RTA.

[27]  Tommaso Toffoli,et al.  Programmable matter methods , 1999, Future Gener. Comput. Syst..

[28]  Ehud Shapiro,et al.  Spatial machines: a more realistic approach to parallel computation , 1992, CACM.

[29]  Frédéric Gruau,et al.  The Blob: A Basic Topological Concept for "Hardware-Free" Distributed Computation , 2002, UMC.

[30]  K. Mani Chandy,et al.  UC: A Set-Based Language for Data-Parallel Programming , 1995, J. Parallel Distributed Comput..

[31]  Erik M. Rauch Discrete, Amorphous Physical Models , 2003 .

[32]  Thompson The VLSI Complexity of Sorting , 1983, IEEE Transactions on Computers.

[33]  Daniel Coore,et al.  Botanical computing: a developmental approach to generating interconnect topologies on an amorphous computer , 1999 .

[34]  Limsoon Wong,et al.  Principles of Programming with Complex Objects and Collection Types , 1995, Theor. Comput. Sci..

[35]  Luca Cardelli,et al.  BioAmbients: an abstraction for biological compartments , 2004, Theor. Comput. Sci..

[36]  John L. Casti,et al.  Unconventional Models of Computation , 2002, Lecture Notes in Computer Science.

[37]  Björn Lisper,et al.  On the relation between functional and data parallel programming languages , 1993, FPCA '93.

[38]  Daniel Le Métayer,et al.  Programming by multiset transformation , 1993, CACM.

[39]  L. Adleman Computing with DNA , 1998 .

[40]  David A. Padua,et al.  A Second Opinion on Data Flow Machines and Languages , 1982, Computer.

[41]  Jingke Li,et al.  Index domain alignment: minimizing cost of cross-referencing between distributed arrays , 1990, [1990 Proceedings] The Third Symposium on the Frontiers of Massively Parallel Computation.

[42]  Michael G. Norman,et al.  Models of machines and computation for mapping in multicomputers , 1993, CSUR.