Wolfgang Heenes

GCA: Global Cellular Automata. A Flexible Parallel Model

A model called global cellular automata (GCA) will be introduced. The new model preserves the good features of the cellular automata but overcomes its restrictions. In the GCA the cell state consists of a data field and additional pointers. Via these pointers, each cell has read access to any other cell in the cell field, and the pointers may be changed from generation to generation. Compared to the cellular automata the neighbourhood is dynamic and differs from cell to cell. For many applications parallel algorithms can be found straight forward and can directly be mapped on this model. As the model is also massive parallel in a simple way, it can efficiently be supported by hardware.

A Multiprocessor Architecture with an Omega Network for the Massively Parallel Model GCA

The GCA (Global Cellular Automata) model consists of a collection of cells which change their states synchronously depending on the states of their neighbors like in the classical CA (Cellular Automata) model. In differentiation to the CA model the neighbors are not fixed and local, they are variable and global. The GCA model is applicable to a wide range of parallel algorithms. In this paper a general purpose multiprocessor architecture for the massively parallel GCA model is presented. In contrast to a special purpose implementation of a GCA algorithm the multiprocessor system allows the implementation in a flexible way through programming. The architecture mainly consists of a set of processors (Nios II) and a network. The Nios II features a general-purpose RISC CPU architecture designed to address a wide range of applications. The network is a well-known omega network. Only read-accesses through the network are necessary in the GCA model leading to a simplified structure. A system with up to 32 processors was implemented as a prototype on an FPGA. The analysis and implementation results have shown that the performance of the system scales with the number of processors.

GCA: a massively parallel model

We have previously introduced the massively parallel global cellular automata (GCA) model. Parallel algorithms derived from applications can be mapped straightforward onto this model. In this model a cell in the cell field is dynamically connected (access pattern, dynamic neighbourhood) to other cells. The model can be implemented by pointers stored in the cell state. Via these pointers, each cell has read access to any other cell in the cell field, and the pointers may be changed from generation to generation. We have investigated different types of the model in order of minimize hardware/software implementation cost. So we have classified the GCA into types with respect to space, time or data dependency of the access pattern. We have investigated a number of different GCA algorithms and found out, that in most cases a time dependent access pattern is sufficient. To find out the usefulness of the data dependent access pattern we constructed a sophisticated merge sort algorithm, in which the target addresses are computed in contrast to classical algorithms where the data elements are moved. It turned out, that we could not achieve a speed up which we expected compared to an algorithm implemented on the more simple time dependent model. This is another confirmation that it is sufficient to implement only the time and space dependent model and thus reduce the hardware/software implementation cost.

Optimizing the behavior of a moving creature in software and in hardware

We have investigated a problem where the goal is to find automatically the best rule for a cell in the cellular automata model. The cells are either of type OBSTACLE, EMPTY or CREATURE. Only CREATURE can move around in the cell space in one changeable direction and can perform four actions: if the path to the next cell is blocked turn left or right, if the path is free, i. e. the neighbor cell is of type EMPTY: move ahead and simultaneously turn left or right. The task of the creature is to cross all empty cells with a minimum number of steps.

FPGA implementations of the massively parallel GCA model

The GCA (global cellular automata) model is a very interesting and flexible model which can be used to implement all kind of parallel algorithms. The GCA model consists of afield of cells similar the cellular automata model. Each cell has links to a set of remote cells which can be dynamically changed from generation to generation. A cell reads the remote neighbors states and then changes its own state according to a local rule. The model is massively parallel because all cells can change their states independently and in parallel. We have investigated how the GCA model can be implemented efficiently in hardware using a field-programmable gate array (FPGA) prototyping platform. We have implemented a fully parallel architecture where all cells operate fully in parallel and other architectures where the cells are stored in memories in order to handle a large number of cells. We are showing that in the fully parallel architecture a speed-up of around 190 is realistic on a modern FPGA platform compared to a software implementation on a PC. In the partially parallel architecture based on memories the speed-up will be lower but the number of cells is only restricted by the capacity of the memories.

Implementation of the Massively Parallel Model GCA

The GCA (Global Cellular Automata) model is a very interesting model which can be used to implement all kind of parallel problems. The GCA model consists of a field of cells as in the Cellular Automata model. Each cell has links to a set of remote cells which can be dynamically changed from generation to generation. A cell reads the remote neighbours states and then changes its own state according to a local rule. The model is massively parallel because all cells can change their states independently in parallel. We have investigated how the GCA model can be implemented efficiently in hardware using a FPGA prototyping platform. We have implemented a fully parallel architecture where all cells really operate in parallel and another architecture where the cells are stored in memories in order to handle a large number of cells. We are showing that in the fully parallel architecture a speed-up of more than 3000 compared to a software implementation on a PC is realistic on a modern FPGA platform. In the partially parallel architecture based on memories the speed-up will be lower but the number of cells is only restricted by the capacity of the memories.

A multiprocessor architecture for the massively parallel model GCA

The GCA (global cellular automata) model consists of a collection of cells which change their states synchronously depending on the states of their neighbors like in the classical CA model. In differentiation to the CA model the neighbors are not fixed and local, they are variable and global. The GCA model is applicable to a wide range of parallel algorithms. In this paper, a multiprocessor architecture for the massively parallel GCA model is presented. In contrast to a special purpose implementation of a GCA algorithm the multiprocessor system allows the implementation in a flexible way through programming. The architecture mainly consists of a number of cell processors and a network. The cell processors are dedicated RISC processors, the network is a crossbar implemented with multiplexers. Only read-accesses through the network are necessary in the GCA model leading to a simplified structure. A system with 32 processors was implemented as a prototype on a FPGA. The analysis and implementation results have shown that the performance of the system scales very well with the number of processors

Efficient traffic simulation using the GCA model

The GCA (Global Cellular Automata) model consists of a collection of cells which change their states synchronously depending on the states of their neighbors like in the classical CA (Cellular Automata) model. In contrast to the CA model the neighbors can be freely and dynamically selected at runtime. The GCA model is applicable to a wide range of parallel algorithms. We present a mapping of the the well known Nagel-Schreckenberg algorithm for traffic simulation onto the GCA model using agents. The vehicles are considered as agents that are modeled as GCA cells with a certain state. The proposed GCA algorithm uses multiple data and link fields per cell to interconnect the relevant cells. An agent is connected to its agent in front, and an empty cell is connected to its agent behind. In the current generation t the position of an agent is already computed for the generation t+2 (one generation in advance). Thereby the agents movements and all cell updates can directly be calculated as defined by the cell rule. No searching of specific cells during the computation is necessary. The complexity is of O(N) when simulating the N cells of an GCA sequentially. Compared to an optimized CA algorithm (with searching for agents) the GCA algorithm executes significantly faster, especially for low traffic densities and high vehicle speeds. Simulating 2048 cells and 204 agents on a multiprocessor system resulted in a speed-up (measured in clock ticks) of 14.75 for a system with 16 NIOS II processors configured on an FPGA.