SISTEMA DE ABASTECIMIENTO

Parallel processing systems are characterised by the existence of multiple agents that co­ operate in the execution of a task [9]. Depending on the level of abstraction at which a parallel processing system is described, the notion of an agent may embody several different entities, and therefore imply various patterns of behaviour and characteristics. In a parallel machine, for instance, an agent is naturally identified with one of the processors in that machine. At a higher level of abstraction, however, the system might be a set of processes that constitute a parallel program, and in this case an agent would be identified with one of the processes. From a strictly conceptual point of view, it is irrelevant whether the parallelism is present at the hardware level or at the topmost software system level. In fact, parallel processing agents can be easily identified in as seemingly disparate settings as operating systems and computer networks, for example. According to this concept, a parallel genetic algorithm is considered as a multi-agent model, possibly exhibiting various degrees of interaction among its agents. The analysis of PGA models found in the literature [38,106,107,108,109] reveals three im portant characteristics for the implementation of agents and their interactions:

• granularity,

• synchronisation and • type of parallelism.

The concept o f granularity relates to the average size of the actions performed by agents (measured in number o f executed instructions and used memory) and their degree of interaction (measured in terms of the rate between the time spent for execution and communication). Three granularity levels can be identified in parallel genetic algorithm models:

• Coarse-grained VG As have th eir agents (w hole algorithm s) executing alm ost independently. The interaction among them is very occasional.

• Medium-grained PGAs exhibit frequent communication among their agents (genetic operators in this case), however the interval between two consecutive interactions is far longer than the time spent during communication.

• Fine-grained PGAs present highly interactive agents (here, individuals from sub­ populations). The execution interval between consecutive interactions is short, and may be comparable to the time spent for communication.

The traditional genetic algorithm is inherently synchronous due to its centralised selection stage. Many parallel models however, overcome this problem by adopting basically two different strategies. In coarse-grained PGAs, selection occurs over sub-populations local to each genetic algorithm instance. Conversely, fine-grained PGAs use distributed selection where a local individual may only be replaced by a migrant if this presents better fitness. In the first case each separate GA still has the synchronous selection stage, but the w hole p arallel GA is not synchronous. The second strategy is completely asynchronous.

The third important characteristic of parallel genetic algorithms programs relates to the type of parallelism they exhibit. There are two types of parallelism; control parallelism and data parallelism. A program is said to have control parallelism if it could be divided into a number of agents operating independently on different processors (or processes). Problems presented by this type of parallel programs relate to the difficulty in identifying the agents and synchronising their actions. Programs presenting data parallelism take advantage of large amounts of data elements that are independent, or unrelated, and assign processors (or processes) to operate over sub-sets or individual data elements. Both types of parallelism coexist in most parallel genetic algorithm models. Data parallelism in PGAs is always associated with the population structure, and control parallelism is associated with algorithms and genetic operators working as independent agents.

Figure 2.7 shows three models of genetic algorithms with different degrees of interaction. The fu*st model (Figure 2.7a) is a pure sequential GA, like Goldberg’s Simple Genetic Algorithm [36]. It has a central control (Algorithm Control), which maintains the global population, the generation counter, the termination criteria and the genetic operators (Op.A ... Op.n). The genetic operators are activated in sequence to evolve the global population, represented by a large set of unrelated data elements. The second model (Figure 2.7b) is a parallel implementation of the same GA, where each genetic operator works as an independent agent, co-ordinated by the algorithm agent. Genetic operators in this model work in a pipeline that is synchronised by, and starts with, the selection operator. As soon as a pair o f individuals is selected, the crossover operator is activated to produce modified offspring. These are then passed on to the mutation operator. While crossover is acting on a pair, selection may be choosing a new pair, and mutation modifying

Chapter 2 Genetic Algorithms Revisited 41

another one. This model presents medium granularity, since interactions among genetic operator agents are quite frequent {[3 x N x g] -i- 2, where N is the population size and g is the number of generations), but the interval between two consecutive interactions is expected to be longer than the time spent during communication.

The third model (Figure 2.7c) represents a coarse-grained implementation of the same algorithm. A number of similar genetic algorithm agents (sequential or pipelined) execute independently, evolving their own sub-populations. From time to time, these GAs may exchange members of their populations.

Figure 2.7 - Sequential and parallel genetic algorithm models.

A LG O R ITH M C O N T R O L O p .A O p .B Op. N (a) ALG O RITH M CO N TR O L O p .A Op. N A LG O RITH M C O N T R O L Op. A O p .B Op. N ALG O R ITH M CO N TR O L O p .B . (c)

Current PGA implementations [33,37,62] can be grouped into three major categories: the panmitic, the island, and the massively parallel GA models. Massively parallel GA models are also called cellular GAs or fine-grain GAs (Table 2.1 lists examples for each category).

Panmitic PGAs are essentially parallel versions of ordinary sequential GAs. They operate over a global population, are normally synchronous and present coarse to medium granularity. Panmitic PGAs are best suited to parallel architectures with shared memory. A parallel implementation of Goldberg’s Simple GA, for instance, allocates n/2 processors (where n is the

population size) to operate over two members of the population at each generation. Other examples of panmitic PGAs include Whitley’s Genitor [101] and Eshelman’s CHC [35].

Table 2.1 - PGA Models

Panmitic isiand Massiveiy Paraiiei

SGA I-SGA Fine-Grained PGA

GAUCSD Asparagos

pCHC PGA Ceiluiar GA

Distributed GA DBGA

Genitor Punctuated Fine-Grained PGA Equilibria for Distributed Systems

Island and massively parallel models derive from population genetic theories stating that diversification occurs more naturally in populations with spatial structures. Selection and mating in these PGAs are restricted to neighbourhoods called demes. In the island model, the population is subdivided into a number of randomly distributed demes. The sub-populations are processed by independent instances of the same genetic algorithm, which, from time to time may exchange individuals w ith other algorithm s in the same deme. Island PGAs im plem entations are asynchronous, coarse-grained and have been mostly mapped onto transputer-based MIMD architectures. In its simplest form, pure sequential GAs are replicated and distributed over a number of processors. Since the execution of each algorithm is completely independent, their final results may differ only due to the stochastic nature of GAs and possibly different initial populations. The I-SGA, for example contains in each island a copy of the sequential SGA, operating only over its own sub-population. Most of the island model implementations include a migration operator, which is responsible for “exporting” a single copy of a selected member of the local population to an adjacent population. Another member o f the local population is also selected to be replaced by an incoming migrant. These PGAs are based on a ring topology and do not have central selection. GAUCSD [85] can be considered one of the first implementations of an island parallel GA. It is a distributed version of GENESIS, and does not use migration operators. Other implementations are the Punctuated Equilibria PGA from Cohoon [20], Pettey and Leuze’s Parallel Genetic Algorithm [66] and Tanese’s Distributed GA [92].

Massively parallel models are usually targeted at fme-grained parallel machines. They assign one individual per processing agent (processors in this case), and limit mating to a deme near the individual. In general, demes consist of four individuals, one in each direction in the plane that contains them. Edge elements wrap around, and the whole topology forms a torus. Each individual is processed in parallel at each generation and the offspring replaces the parent, if it has a better fitness. Again, there is no central selection. These PGAs are asynchronous and considered to exhibit fine-grain parallelism, since interactions among neighbour processors are

Chapter 2____________________ Genetic Algorithms Revisited___________________________ ^

quite high and the ratio between execution and communication can be very small. The preferred parallel architectures are SIMD machines, array processors and connection machines [33] (but some have also proven to be very effective on transputer-based implementations). Examples in this class are the Fine-G rained PGA from M anderick and Spiessens [58], Asparagos from Gorges-schleuter [39], W hitley’s Cellular GAs [102], the Distributed Breeder GA [63] from Mühlenbein and the Fine-Grained PGA for Distributed Systems from Maruyama et al. [59].

Parallel genetic algorithms present diverse characteristics ranging from synchronous coarse and medium-grained models, such as panmitic and island, to asynchronous fine-grained models like the massively parallel GA. They also exploit control and data parallelism in various degrees. M ost im plem entations are p latform dependent, th erefo re not easily portable. C o n seq u en tly , any program m ing en v iro n m en t in ten d in g to co v er the b road range o f characteristics presented by PGAs and achieve the required level of portability, needs to define a programming model, and a communication and parallel control mechanisms capable of being mapped onto diverse parallel platforms.