Vous êtes sur la page 1sur 13


A Swarm is a collection of agents with a schedule of events over those agents and swarm
computing is the simulation of the concurrent processes that occur in some rural or
artificial world. Swarm is especially well suited for studying processes of computation
that occur in nature. Here we can say that swarm is a framework for simulating processes
that occur across large numbers of concurrently interacting agents. Agents infract directly
with each other and with other objects representing the structure of is environment. In
principles, all agents act concurrently and auto nomously: an abstract model of swarm is
a concurrent object system in which all objects can be continuously active. The core of a
swarm simulation is the modeled world itself. The swarm approach has been successfully
applied to a number of optimization and control problem.the simultaneous emergence of
ubiquitous computing ( connected appliances ) and peer-to-peer computing will
necessitate new paradigms: Swarm Intelligence is leading the way. This paper covers
the different methods of implementation of swarm computing, applications of swarm
computing, the work proposed for swarm model and the challenges faced by swarm
The objective of this research is to create the system architectural, algorithmic, and
technological foundations for exploiting programmable materials. These are materials
that incorporate vast numbers of programmable elements that react to each other and to
their environment. Such materials can be fabricated economically, provided that the
computing elements are amassed in bulk without arranging for precision interconnect and
testing. In order to exploit programmable materials we must identify engineering
principles for organizing and instructing myriad programmable entities to cooperate to
achieve pre-established goals, even though the individual entities are unreliable and
interconnected in unknown, irregular, and time-varying ways. We call this effort the
study of amorphous computing. The advances in hardware technology, power
management, and wireless communication enable large-scale development of tiny
embedded processors, fit with non-trivial computing capacity and memory, as well as
with sensors, actuators, and wireless radio communication.
One can never deny that programs in the future will run on collections of mobile
processors that interact with the physical world and communicate over ad hoc networks.
We can view such collections as swarms. As with natural swarms, such as a beehive or
ant colony, the behavior of a computational swarm emerges from the behaviors of its
individual members. Instead of deploying a solitary unit to survey a planet or other
inaccessible area, a multitude of devices might be employed. These devices would be
rather small in size, but they would have locomotion, sensing and significant processing
capabilities. Furthermore, they would be able to communicate and coordinate their
activities to maximize the use of their resources (power being the most important. In the
Swarm system the basic unit of simulation is the swarm, supports hierarchical modeling
approaches whereby agents can be composed of swarms of other agents in nested
structures. Swarm provides object-oriented libraries of reusable components for building
models and analyzing, displaying, and controlling experiments on those models.
Swarm computing is sometimes called Amorphous computing to emphasize that the
collective result emerges from individual micro level behaviors with the surprising
symmetry of a relocating bee or ant colony. This form of computing is also important for
controlling the devices created by nano-technology. Amorphous computing builds on
research into distributed computing models like Jini.
The principal task of Swarm is to provide a mapping of its abstract model to various
classes of available computing machinery.
Swarm computing involves devices operating like a swarm of insects. A Swarm device is
a small mobile robot with sensing capabilities. As more and more devices are equipped
with micro controllers and sensors, a new class of computational devices will emerge.
These devices fall into the class of computing referred to as Swarm computing, because
they operate in a manner that can be likened to a swarm of insects. Most of these
primitives have analogs in the insect world such as swarm (all the nodes going in one
direction) and cluster (all the nodes gathering together).
Structure of a swarm simulation
The fundamental component that organizes the agents of a swarm model is an
object called a “swarm.” A swarm is a collection of agents with a schedule of
events over those agents. For example, a swarm could be a collection of 15
coyotes, 50 rabbits, a garden with carrots, and a simple schedule: the rabbits
eating the carrots and hiding and the coyotes eating the rabbits (Figure 1). The
swarm represents an entire model: it contains the agents as well as the
representation of time.)

Eat hideHIDE

The core of a Swarm simulation is the modeled world itself. In the simplest case,
a model consists of one swarm inhabited by a group of agents and a schedule of
activity for those agents. The agents themselves are implemented as objects.
Agents are created by taking a class from the swarm libraries, specializing it for
the particular modeling domain, and then instantiating it, one object per agent. For
example, and agent that is a neural network could start by taking a general
purpose neural network class from the neuro library, adding extra methods needed
for the specific type of network, and then creating an instance of it to be the actual
neural network.
Once a user has defined the agents and established their relationships, the last step
in building the model itself is to put the agents together into a swarm. The user
writes a schedule of activity for the agents, defining how time is simulated in the
system by creating a set of actions in a specified ordering. Schedules are built by
creating instances of data structures from the activity library, filling them in with
ordered object/message pairs. Once the schedule is completed the model swarm is
ready to be executed.
In Swarm measurement happens by the actions of observer agents, special objects
whose purpose it is to observe other objects via the prove interface (Figure 4). For
example, one observer agent might be watching the number of rabbits and
producing a time series graph of population dynamics. Another observer agent
could track the spatial distribution of the coyotes, storing data to a file for later
analysis. Figure



The observer agents themselves are a swarm, a group of agents and a schedule of
1. Unpredicatable consequently many of the techniques used to create and
verify traditional program will not work in swarm computing.
2. Networks of sensors and actuators differ from the traditional networked
systems in that, due to their less reliable operation, they must be highly
adaptive, must cope with high rates of component failure, mobility, and
reconfiguration, and must export a highly flexible collection of services
that may involve coordinating a rich set of heterogeneous components in
the embedded network.
3. With respect to other object systems, probably the most distinctive feature
of Swarm is its definition of an explicit linear time shared by all agents
belonging to a swarm.
4. The limited processing power, memory and bandwidth available to these
devices render conventional security methods unusable.
The logical structure of swarms of agents interacting through discrete events is
implemented in a straightforward way in any object oriented language viz. C++, or
The Swarm system itself is an object framework: a set of class libraries that are designed
to work together. There are seven core libraries in Swarm: defobj, collections, random,
tkobjc, activity, swarmobject and simtools. The first four libraries are support libraries
with potential use outside of Swarm; the last three are Swarm- specific. There are also
currently three domain-specific libraries available for Swarm model builders: space, ga,
and neuro.
The disperse primitive is where all the nodes in the simulation attempt to situate
themselves so that they are not adjacent to any other nodes. In the context of the swarm
simulator, adjacent means any square that is touching the square in question.
Here is the generalized pseudo code for disperse:
if is_Dispersed(swarm)
for all bugs
if bug has neighbors
return false
return true
for all bugs
if bug has neighbors
The cluster primitive is essentially the opposite of disperse. Each node attempts to situate
itself so that it is adjacent to at least one other node. The pseudo code for cluster is very
similar to disperse.
if is_Clustered(swarm)
for all bugs
if bug has no neighbors
return false
return true
for all bugs
if bug has no neighbors
The only portion of the code that is variable is the implementation of the move function.
Major difference between Cluster and Disperse:
While Cluster and Disperse may seem very similar, there is one major difference that
makes Disperse more difficult to implement. In cluster, one a bug has moved adjacent to
another but, it will never move again. In Disperse, however, a bug may satisfy the
disperse criteria and stop moving, but at some later time be forced to move again by
another bug moving adjacent to it.
The swarms of computational entities can be used in a field that requires a
multitude of devices. Swarm computing finds its application in:
1) To accomplish such tasks as the exploration of Mars.
2) Clearing the blockage in arteries.

Smart Dust Project:

The Smart Dust Project is essentially a group of micro sensors that report their readings
to a Base-Station Transceiver or BTS. In the simplest situation, the pieces of dust (notes)
simply relay the information they collect to the BTS using lasers. The primary problem
with this method is that it depends on line-of-sight, so if a node can’t see the BTS, it will
be unable to transmit its data.

Swarm Simulator in Java:

We have to design a Java applet that simulates swarm computing or amorphous

computing. These classes can be used to implement a swarm application fairly painlessly.
Positions of the nodes, and their connectivity matrix, have been precomputed to keep
message-passing efficient. A swarm simulator is pretty useless unless it models at least
hundreds of processors, ideally thousands.

We can design a model of Swarm Agents taking the idea of smart dust project. There is a
central base transceiver system i.e. a PC and to implement the Swarm Agent we can have
two (or more) robots. Now these swarm agents or robots can easily be interfaced with the
PC through (parallel or serial port). Thus we have real life model of swarm agents. Now,
suppose if we want to do some practical application like exploration of terrain, our goal is
to search a substance say a water body. Now these robots can be placed over a surface to
be explored. The agents move randomly over the surface. They are equipped with sensors
to detect the water. When a robot detects the water body it sends a pulse to the PC hence
the source is located.
To make the second robot the water source we require:
(a) The original path traced by the first agent.
(b) The second agent strictly traverses that path.

The path traced using simple implementation of graph concept of data structure. The
robots can move in predefined directions say four. We initialize four variables to count
the paces moved by the swarm agents in four directions. Their motion can be traced using
a constraint that swarm agents move by a specified unit (call it pace). After each pace the
agents send a pulse to the PC and the number of paces in subsequent directions can be
stored in direction variables, this way we have an exact idea about the path traced by the
first agent. A graph can now be plotted and then a Minimum Cost Path joining two points
of location of swarm agents, is calculated using algorithm via. Prim’s, Kruskal. Now the
second agent can be moved through this path in a similar way, so as to reach the location
detected by the first swarm agent. The coordination is maintained by the Base
Transceivers System (BTS) i.e., the PC. In this way we can reach to our goal.


One of the key areas that need to be addressed for such tiny devices is security and
authentication. The hope is that a large number of these tiny devices, known as swarms,
will be autonomously communicating between themselves and to a base station,
performing different tasks. The applications envisioned include defense applications,
such as battlefield surveillance and target indentification, and smart environments where
the environment can sense your presence and adjust to your personal preferences. In such
cases, privacy and security become essential. You do not want the swarms to be
broadcasting your personal information for an eavesdropper to discover. Also you do not
want the swarms to be responding to commands from bad sources (like the enemy in the
battlefield), so authentication is required. Thus, authentication and security are two of the
major challenges faced by swarm computing.
Reserchers have successfully applied the swarm approach to a number of real
optimization and control problems, from factory scheduling to telecommunications-
network routing, from medical sciences to land mine researches and etc. the ant approach
is always the one with the most flexibility in response to changing conditions. Beyond
optimization and control, swarm intelligence provides and entirely new way of thinking
about and harnessing distributed computing. The simultaneous emergence of ubiquitous
computing (connected appliances) and peer-to-peer computing will necessitate new
paradigms: swarm intelligence is leading the way.
The swarms simulation system: By C. Langton, N. Minar and R. Burkhart.
1. Swarm intelligence : By James Kennedy, Russel C., Yuhui shi, Eberhart.
2. www.sciencenews.org
3. http://willware.net.8080/jswarm
4. www.multitask.com.au
5. www.cs.man.ac
6. www.cs.virginia.edu
7. dsonline.computer.org

Thanks to
Mr. Vinay Rishiwal