Cellular automata (CA) are used in various simulation contexts, for
example, physical simulations, fire propagation, or artificial
life. These simulations basically consider large numbers of
small-sized identical components, called cells, with local
interactions and a global synchronized evolution.
Reactive
programming (RP) basically considers software systems made of
concurrent components sharing the same global instants. In RP, all
components are running at the same pace as they necessarily
synchronize at the end of each instant. The existence of instants
allows one to define broadcast events which are a powerful mean for
modular programming.
Using RP for implementing CA has the following advantages:
- Modularity of programming. The behaviors of cells is rather opaque in
usual CA implementations. This is however generally not felt as a big
issue because cells behaviors are often very simple. In some contexts,
for example artificial life, one may ask for more complex cell
behaviors. In these cases, modularity is certainly a plus.
- Multiprocessing. Sequential programming of CA makes difficult the use
of several processors because cells must be protected from concurrent
accesses of their neighbors and because the global synchronization of
cells has to be preserved. The proposed concurrent implementation of
CA is compatible with multiprocessing.
One gets an efficient implementation in which cells are threads created when
needed. Cell behaviors are coded at a higher level than the one of
look-up tables. The example of self-replicating loops is
considered, following the work of Langton and Sayama in artificial life.
For Linux and Mac OSX:
- The LOFT version, including the version v1.2 of FairThreads
(tgz file, 185k)
- The reactive implementation of Cellular Automata and SR Loops
(tgz file, 15k) (LOFT needed)
The
SDL graphical library
must be installed (including the command sdl-config).
All animations are made of animated gif snapshots:
