Stefan Bosse - Distributed Computing and Reliable Communication in Sensor Networks using Multi-agent Systems

COMMUNICATION

Distributed computing and reliable communication in sensor

networks using multi-agent systems

Stefan Bosse

•

Florian Pantke

Received: 14 July 2012 / Accepted: 15 October 2012 / Published online: 29 October 2012

Ó German Academic Society for Production Engineering (WGP) 2012

Abstract There is a growing demand for robust distrib-

uted computing and systems in sensor networks. Interac-

tion between nodes is required to manage and distribute

information. One common interaction model is the mobile

agent. An agent approach provides stronger autonomy than

a traditional object or remote-procedure-call based

approach. Agents can decide for themselves, which actions

are performed, and they are capable of ﬂexible behaviour,

reacting on the environment and other agents, providing

some degree of robustness. The focus of the application

scenario lies on sensor networks and low-power, resource-

aware single System-On-Chip designs, i.e., for use in

sensor-equipped technical structures and materials. We

propose and compare two different data processing and

communication architectures for the implementation of

mobile agents in sensor networks consisting of single

microchip low-resource nodes. Furthermore, a reliable

smart communication protocol for incomplete and irregular

networks are introduced. Two case studies show the

suitability of agent-based approaches for distributed

computing.

Keywords Distributed computing  Agent  Sensor

network  Energy management  Data fusion

1 Introduction

Trends recently emerging in engineering and micro-system

applications such as the development of sensorial materials

show a growing demand for autonomous networks of

miniaturized smart sensors and actuators embedded in

technical structures [7]. With increasing miniaturization

and sensor-actuator density, decentralized network and

data processing architectures are preferred or required. A

multi-agent system can be used for a decentralized and

self-organizing approach of data processing in a distributed

system like a sensor network, enabling the mapping of

distributed data sets to related information, for example,

required for object manipulation with a robot manipulator.

Simpliﬁcation and reduction of synchronization constraints

owing to the autonomy of agents is provided by the dis-

tributed programming model of mobile agents [5]. Tradi-

tionally, mobile agents are executed on generic computer

architectures [8, 10], which usually cannot easily be

reduced to single microchip level like they are required,

e.g., in sensorial materials with high sensor node densities.

In the following sections, we propose and compare two

different data processing and communication architectures

suitable for the implementation of mobile agents in sensor

networks consisting of single microchip low-resource

nodes. A reliable communication protocol suitable for

robust communication in agent based systems is introduced

and analysed. Finally, the two agent processing architec-

tures are compared.

S. Bosse (&)

Department of Computer Science, Workgroup Robotics,

University of Bremen, Bremen, Germany

e-mail: sbosse@uni-bremen.de

S. Bosse  F. Pantke

ISIS Sensorial Materials Scientiﬁc Centre,

University of Bremen, Bremen, Germany

F. Pantke

TZI-Center for Computing and Communication Technologies,

University of Bremen, Bremen, Germany

123

Prod. Eng. Res. Devel. (2013) 7:43–51

DOI 10.1007/s11740-012-0420-8

2 Distributed data processing with state-based agents

Initially, a sensor network is a collection of independent

computing nodes. Interaction between nodes is required to

manage and distribute data and computed information. One

common interaction model is the mobile agent. An agent is

capable of autonomous action in an environment with the

goal to meet its delegated objectives. An agent is a data

processing system, a program executed on a computer

system, that is situated in this environment [11]. A multi-

agent system is a collection of loosely coupled autonomous

agents migrating through the network. Agents can be used

in sensor networks for

– Sensor data processing and extraction

– Sensor data fusion, ﬁltering, and reduction of sensor

data to information in a region of interest

– Sensor data and information distribution and transport

– Global energy management, exploration and negotiation

Agents can operate state-based. Such an agent consists

of a state, holding data variables and the control state, and a

reasoning engine, implementing behaviours and actions. In

this proposed data processing and communication archi-

tecture, the state of an agent is completely kept in messages

transferred in the network providing agent mobility. The

functional behaviour of an agent can be easily implemented

statically with a ﬁnite-state machine part of the local data

processing system on register-transfer level (RTL), or

dynamically by using a programmable code approach.

Agents record information about the environment state

e2E and history. Let I be the set of all internal states of the

agent. An agent’s decision-making process is based on this

information. The perception function see maps environ-

ment states to perceptions, function next maps an internal

state and percept to an internal state, the action-selection

function action maps internal states to actions (see also

Fig. 1):

see : E ! Per

next : I  Per ! I

action : I ! Act

3 Approach I: non-programmable message-based/state

machine agent processing architecture

Figure 2 shows the ﬁrst proposed non-programmable exe-

cution environment used for the data processing of mobile

agents. This execution environment is preferred for low-

resource implementations of mobile agents with low

algorithm complexity. All nodes must comply with data

structures and message formats speciﬁed at design time

required for the cooperation of agents. There is a message

module implementing smart adaptive delta-distance

routing of messages (SLIP, the Scalable Local Intranet

Protocol, explained later), providing some kind of fault-

tolerance regarding interconnect failures, and several ﬁnite-

state machines implementing the agent behaviours and

providing virtual machines able to process incoming

agents. All parts are mappable to digital logic on RT level

and single-SoC system architectures, a prerequisite for

miniaturized sensor nodes embedded in structures and

sensorial materials.

The functional agent behaviour is implemented with a

(non-mobile) ﬁnite state machine (virtual machine) built in

the sensor node, modelled with a high-level synthesis

approach on an imperative multi-process programming

language level [1]. Inter-agent communication is provided

by shared data structures, available on each sensor node.

Each node is represented by a node agent, too, to ensure

Fig. 1 State-based agents and interaction with environment

AGENT

STATE

A-Queue

MESSAGE

POOL

SCHEDULER

M-QueueM-Queue

Sensor

SoC

Micro-

chip

Messages

Finite

State

Machine

RTL

DATA PRO.

COMMU.

AGENT VM

AGENT

STATE

A-Queue

AGENT VM

Fig. 2 Sensor node building blocks providing mobility and process-

ing for multi-agent systems: parallel agent virtual machines, agent-

processing scheduler, communication, and data processing. All parts

are mappable to digital logic on RTL and SoC system architecture

44 Prod. Eng. Res. Devel. (2013) 7:43–51

123

interaction and information exchange between mobile

agents and the sensor node. All interacting agents must

comply about the data structures and types, ﬁxed at design

time. A scheduler is responsible to map incoming messages

(M), holding information about the agent class and agent

state, to agent executions frames (A), passed to an agent

virtual machine by using queues. Finally, the scheduler

transforms the state of ﬁnished agents ready for migration

to messages and passes them to the communication unit by

using queues, too. The design process is shown in Fig. 3,

and requires the textual speciﬁcation of the agent on

algorithmic and programming level (left part). This speci-

ﬁcation is transformed into an abstract agent ﬁnite state

machine (FSM) model, the state memory layout (middle

part), and the message structure. Finally the microchip

implementation on RTL (right part) can be synthesized

from this intermediate representation, creating an applica-

tion speciﬁc processing environment for mobile agents.

4 Approach II: programmable multi-agent processing

architecture using code morphing

Multi-agent systems providing migration mobility using

code morphing can help to reduce the communication cost

in a distributed system [3]. The second proposed hardware

architecture and run-time environment is speciﬁcally

designed towards the implementation of mobile agents by

using dynamic code morphing under the constraints of low-

power consumption and high component miniaturization.

Code morphing is the ability of a program to modify its

own program code to reﬂect state changes and embedding

computational results. The advantage of this distributed

computation model using code morphing is the computa-

tional independence of each node and the eliminated

necessity for nodes to comply with previously deﬁned

common data types and structures as well as message

formats. Computing nodes perform local computations by

executing code and cooperate by distributing modiﬁed

code (carrying embedded information) to execute a global

task. It uses a modiﬁed and extended version of FORTH as

the programming language for agent programs. FORTH is

a stack-based interpreted language whose source code is

extremely compact. Furthermore, FORTH is extensible,

that is new language constructs (called words, zero-oper-

and functions) can be deﬁned on the ﬂy by its users.

A FORTH program contains built-in core instructions

directly executed by the FORTH processing unit and user-

deﬁned high-level word and object deﬁnitions that are

added to and looked up from a dictionary data structure.

This dictionary plays a central role in the implementation

of distributed systems and mobile agents. Words can be

added, updated, and removed (forgotten), controlled by the

FORTH program itself. User-deﬁned words are composed

of a sequence of words. The principal system architecture

of one lFORTH processing unit (PU, part of the node

runtime environment) is shown in Fig. 4. A complete run-

time unit consists of a communication system with the

smart routing protocol stack SLIP, one or more lFORTH

processing units with a code morphing engine, resource

management, code relocation and dictionary management,

and a scheduler managing program execution and distri-

bution, that are normally part of an operating system,

which does not exist here. A lFORTH processing unit

initially waits for a frame (a FORTH program) to be exe-

cuted. During program execution, the lFORTH processing

Type Perc = Record

energy : Integer;

links: Connectivity;

End;

Function see(node) : Perc =

Begin

VAR p:Perc;

p.energy:=Node.energy-ET;

p.links:=Node.links;

Return p;

End;

Function next(s,p) : State =

Begin

Case s of

| Explore =>

If p.energy > ET Then

Return Stay;

| ..

End;

Procedure action (s) = ...

Agent Specification

Type Message =

Record

state: State;

energy: Integer;

migration: Bool;

...

End;

Agent Message Structure

Agent Finite State Machine

state

energy

perception

....

Agent State Memory

AGENT

STATE

AGENT VM

A-Queue

COMMUN.

MESSAGE

POOL

SCHEDULER

DATA PRO.

M-Queue

SoC

Microchip

Finite

State

Machine

RTL

System On Chip/RTL

Architecture

Algorithmic &

Programming Level

Fig. 3 Design process for state-machine based agent implementation

Prod. Eng. Res. Devel. (2013) 7:43–51 45

123

unit interacts with the scheduler to perform program

forking, frame propagation, program termination, object

creation (allocation), and object modiﬁcation. The sched-

uler is the bridge between a set of locally parallel exe-

cuting lFORTH processing units, and the communication

system, a remote procedure call (RPC) interface layered

above SLIP, providing fault-tolerant message-based com-

munication system used to transfer messages (containing

code) between nodes using smart XY delta-distance vector

routing.

The simple FORTH instruction format is an appropriate

starting point for code morphing, i.e., the ability of a pro-

gram to modify itself or make a modiﬁed copy, mostly as a

result of a previously performed computation. Calculation

results and a subset of the processing state can be stored

directly in the program code, which changes the program

behaviour. The standard FORTH core instruction set was

extended (see Table 1) and adapted for the implementation

of agent migration in mesh networks with two-dimensional

grid topology. In our system, a lFORTH program is con-

tained in a contiguous memory fragment, called a frame. A

frame can be transferred to and executed on remote nodes

and processing units. The virtual lFORTH machine can

execute most of the core words from the FORTH core

programming language.

All architecture parts of the multiprocessor-FORTH

node, including SLIP communication, lFORTH process-

ing units, scheduler, dictionary and relocation support, are

mapped entirely to hardware multi-RT level and a single

SoC design using the ConPro compiler [1]. The resource

demand depends on the choice of design parameters and is

in the range of 1M–3M equivalent gates (in terms of FPGA

architectures). The entire design is partitioned into 43

concurrently executed sequential processes, communicat-

ing by using 24 queues, 13 mutex, 8 semaphores, 52 RAM

blocks, 59 shared registers, and 11 timers.

5 Robust and reliable communication for mobile agent

systems

Most actual work in communication focusses on wireless

networks [9]. But sensorial materials and highly integrated

robotics systems require basically wired networks [7]. The

Scalable Local Intranet Protocol (SLIP) and a communi-

cation controller design was developed for message based

robust communication in low-resource and low-power

sensor networks [2]. To meet the goal of miniaturization

and low-power capability, the protocol must be capable of

implementation in SoC and RTL designs, and adaptable to

local communication requirements.

5.1 Reliable communication protocol SLIP

SLIP is scalable with respect to network size (address size

class (ASC), ranging from 4 to 16 bit), maximal data

payload (data size class (DSC), ranging from 4 to 16 bit

length) and the network topology dimension size (address

dimension class (ADC), ranging from 1 to 4). Network

nodes are connected using (serial) point-to-point links, and

they are arranged along different metric axes of different

geometrical dimensions: a one-dimensional network

(ADC = 1) implements chains and rings, a two-dimen-

sional network (ADC = 2) can implement mesh grids, a

three-dimensional (ADC = 3) can implement cubes, and so

on. Both incomplete (missing links) and irregular networks

SCHEDULER

PC FRM

μFORTH

PROCESSING UNIT

FRAME

FRAME’’

PC’’ FRM’’

FRAME

DATA

STACK

RETURN

STACK

EXCEPTION

STACK

CODE SEGMENT DATA SEGMENT

DICTIONARY

LUT

OBJ

SLIP / RPC Communication

Fig. 4 Mobile-agent run-time

architecture providing code

morphing, consisting of FORTH

data processing units, shared

memory and objects, dictionary,

scheduler, and communication

(PC Program Counter, FR*M*

Frame Pointer, OBJ Object

Pool, CS Code, LUT Lookup

Table, *S Stack)

46 Prod. Eng. Res. Devel. (2013) 7:43–51

123

(with missing nodes and links) are supported for each

dimension class, shown in Fig. 5.

The main problem in message-based communication is

routing and thus addressing of nodes. Absolute and unique

addressing of nodes in a high-density sensor network is not

suitable. An alternative routing strategy is delta-distance

routing, used by SLIP. A delta-distance vector D speciﬁes

the way from the source to a destination node counting the

number of node hops for each dimension. A message

packet contains a header descriptor specifying the type of

the packet and the scalable parameters ASC, DSC, and

ADC, shown in Table 2. The network adress dimension

ADC and the size class ASC reﬂect the network topology,

the data size class DSC the data payload. There are two

different main message types: requests and replies. A

packet descriptor follows the header descriptor, contain-

ing:the actual delta-vector D, the original delta-vector D

preferred routing direction x, an application layer port p,a

backward-propagation vector C, and the length of the fol-

lowing data part. The total bit length of the packet header

depends on the fASC; DSC; ADCg scalable parameter tuple

setting, which optimises application speciﬁc the overhead

and energy efﬁciency (spatial & temporal). Each time a

packet is forwarded (routed) in some direction, the delta-

vector is decreased (magnitude) in the respective dimen-

sion entry. For example, routing in x-direction results in:

¼ D

 1. A message has reached the destination iff

D ¼ 0 and can be delivered to the application port p. There

are different smart routing rules, applied in order showed

below until the packet can be routed (or discarded), shown

in Ex. 5. First the normal XY routing is tried, where the

packet is routed in each direction one after another with the

goal to minimize the delta count of each particular direc-

tion. If this is not possible (due to missing connectivity),

the packet is tried to send to the opposite direction,marked

in the gamma entry C part of the message packet

descriptor. Opposite routing is used to escape small area

traps, backward routing is used to escape large area traps or

to send the packet back to the source node (packet not

deliverable). The routing decision is based on the actual

NODE

HDT PDT DATA

ADC

TYP

DSC

ASC

ΔΔ

LEN

Fig. 5 Message based communication in two-dimensional networks

using delta-distance vector routing. Networks with incomplete

(missing links) and irregular (missing nodes) topologies are supported

by using smart routing routes

Table 1 lForth extensions for code morphing and agent migration support

Word Description

frame c! SETC: Sets frame of shadow environment for code morphing

m1 m2 [[ c COPYC: Switches to morphing state: Transfers code from program frame between two markers m1 and m2 into shadow frame

(including markers)

[c TOC: Copy next word from program frame into shadow frame

n s[c STOC: Pop n data value(s) from stack and store values as word literals in shadow frame

\m[ MARKER: set a marker position anywhere in a program frame

dx dy fork Send contents of shadow frame for execution to node relative to actual node. If dx = 0 and dy = 0, the shadow

frame is executed locally and concurrently on a different FORTH processing unit

Prod. Eng. Res. Devel. (2013) 7:43–51 47

123

message entries fD; C; xg and achieves adaptive routing

reﬂecting the actual network topology and the path the

message already had travelled, including back-end traps,

resulting in alternative paths by choosing different routing

directions.

A message is only send to a neighbour node using the

particular link iff the connection to the neighbour node was

negotiated and is fully operational concerning the sending

and the receiving of messages to and from the neighbour

node. For this purpose, the communication controller sends

periodically ALIVE messages to all direct surrounding

nodes and waits for ACKNOWLEDGE messages send back

from the neighbour node to check the state of a connection.

Non-existing nodes can be detected this way, too.

The hardware implementation (using Conpro and stan-

dard cell ASIC synthesis) requires about 244k gates, 15k

FF % 2.5 mm

assuming ASIC standard cell technology

0.18 lm. The design is partitioned on programming level in

34 processes, communicating by using 16 queues.

5.2 Robustness and stability analysis

A simulation of a sensor network consisting nodes arranged

in a two-dimensional matrix with 10 rows and 10 columns

was performed by using a multi-agent model. Messages and

sensor nodes were modelled with agents. A comparison of

XY and smart routing using the routing rules introduced in

Ex. 1 is shown in Fig. 6. The diagram shows the analysis

results of operational paths depending on the number of link

failures. A path is operational (reachable) iff a node (device

under test), for example node at position (2,2), can deliver a

request message to a destination node at position (x,y) with

x = 2_y = 2, and a reply can be delivered back to the

requesting node. A failure of a speciﬁc link and node results

in a broken connection between two nodes. The right image

in Fig. 6 shows an incomplete network with 100 broken

links. With traditional XY routing there is a strong decrease

of operational paths, from a speciﬁc node (DUT) to any

other node, if the number of broken links increases. Using

smart routing increases the number of operational paths

signiﬁcantly, especially for considerable damaged net-

works, up to 50 % compared with XY routing providing

only 5 % reachable paths any more.

Results from stability analysis shown in Fig. 7 point out

unstable behaviour under some particular network topolo-

gies. Though most situations are live lock free, there are

some live locked messages circulating for ever in some

isolated traps, shown for example in the snapshot on the

right side of this ﬁgure.

6 Case study I: energy management in sensor networks

Global energy management and distribution in sensor

networks introduces the ﬁrst application for distributed

computing using agents. Energy management in sensor

network can take place:

LOCALLY

– At design time: low-power, application speciﬁc

single System-On-Chip design

– At run-time: computation on demand, parametriza-

tion of algorithms with cost-feedback analysis,

control of duty-cycle of computation and sleep mode

GLOBALLY

– Distribution and collection of energy between nodes

(demonstrated by simulation and experiment in [4])

– Energy Management by exploring and exploiting the

neighbourhood of nodes

Table 2 SLIP message format (HDT: header descriptor, PDT: packet

descriptor)

Entry Size [bits] Description

HDT:ADC 2 Address Dimension Class

HDT:ASC 2 Address Size Class

HDT:DSC 2 Data Size Class

HDT:TYP 2 Message type = {Request,

Reply, Alive,

Acknowledge}

PDT:D Num(ADC)*Bits(ASC) Actual delta vector

PDT:D

Num(ADC)*Bits(ASC) Original delta vector

PDT:C 2*Num(ADC) Backward propagation vector

PDT:x Bits(ADC) Preferred routing direction

PDT:p Bits(ASC) Application layer port

PDT:LEN Bits(DSC) Length of packet

DATA LEN*Bits(DSC) Data

48 Prod. Eng. Res. Devel. (2013) 7:43–51

123

– The data processing system can use the communi-

cation unit to transfer data (D) and superposed

energy (E).

6.1 Implementation of smart energy management

with agents

For the following smart energy management (SEM)

implementation it is assumed that nodes are supplied by

local energy sources, for example by using energy har-

vesting techniques. Each node is capable of storing energy

in a local energy storage. Additionally, nodes can be sup-

plied by energy from neighbour nodes, transferred using

the communication system. Nodes having an energy level

below a threshold E

can send out mobile help agents. Help

agents explore the neighbourhood of the requesting node.

The state of an agent is stored and transferred in messages.

A message can carry energy E, too. The sensor node itself

contains a (non-mobile) node agent performing local

energy management. There are four different agent classes:

NODE: The node agent implements inter-agent commu-

nication and local energy management. In the case the

local stored energy is below a critical threshold, it sends

out HELP agents to the surrounding area.

HELP: The goal of this agent is to ﬁnd a good node with

local energy above a certain threshold E [ E

. If such a

node was found, the HELP agent stays on this good

node, and sends periodically DELIVER agents.

DELIVER: This agent has the goal to return energy to

the requesting bad node with help-on-way behaviour.

Help-on-way behaviour supplies bad nodes found on the

return path before the ﬁnal requesting node was reached.

Fig. 6 Robustness analysis with results obtained from simulation

(top) and snapshot of sensor network (bottom)

Fig. 7 Stability analysis (live locked messages, top) and snapshot of

sensor network with trapped messages (bottom)

Prod. Eng. Res. Devel. (2013) 7:43–51 49

123

This ensures a path from the source to the destination

node with fully operational nodes having enough energy

stored for energy distribution and propagation.

DISTRIBUTE: Very good nodes with an energy level

above a threshold E E

can distribute energy to

surrounding neighbourhood with the goal to ﬁnd bad

nodes.

The agent behaviour was implemented using the state-

based agent model introduced in Sect. 2. The agent state

machine implementing the behaviour consists of only nine

control states and nine state variables, preferred for the

low-resource state machine approach.

6.2 Simulation results

A simulation was performed to carry out the suitability of

the proposed smart energy management approach using

agents and the SeSAm Multi-Agent System (MAS) sim-

ulation framework [6]. It is assumed that nodes are

charged randomly with energy from a local source and

discharged by activity. Though there are nodes collecting

enough energy to be always operational, there are nodes

collecting not enough energy to be operational. Without

energy management, there are about 60 % non-opera-

tional bad nodes (E \ 250 energy units). Using smart

energy management with agents, the averaged fraction of

bad nodes is below 10 %, and permanently below 2 %,

shown in Fig. 8!

Because energy transfer is not lossless the simulation

contains simple efﬁciency considerations. Actually the

spatial agent exploration is initially random, with limited

memory of already visited nodes. This simple exploration

algorithm leeds to a low overall system efﬁciency below

10 % (fraction of distributed energy compared with total

harvested energy). Future investigations must improve the

exploration and distribution strategy with the goal to meet

higher energy efﬁciency.

7 Case study II: distributed Sobel ﬁlter

Originally applied in image processing and computer

vision, the Sobel ﬁlter is a edge detection ﬁlter, which can

also be used for crack detection in sensorial materials. As

an example, a simple technical structure such as a metal

plate can be considered,on which a high number of strain-

gauge equipped sensor nodes have been distributed in a

grid network [7]. The development and growth of cracks

due to overloading situations or material fatigue changes

the way load-induced strains propagate in the material.

These structural defects can appear as edges in the two-

dimensional sensor data ﬁeld and can, in principle, be

detected in a convolution process with a Sobel operator. It

is assumed that each network node can read data from only

one local sensor, i.e., an accumulated centralized view of

the structural state does not exist. A Sobel operator matrix

S is used for a neighbourhood operation on the original

image A composed of sensor data, for example a 4 9 4

matrix, and each matrix entry represents a node in the

sensor network. There are two different operators, each for

a different direction sensitivity (x/y), shown in Eq. 1.

101

202

101

; S

121

000

1 2 1

¼ S

 A;

¼ S

 A:

ð1Þ

8ði; jÞ2fx  1; x; x þ 1gfy  1; y; y þ 1gDO

i;j

þ s

2iþx;2jþy

 a

x;y

ð2Þ

A lFORTH program executed on the proposed

architecture in Sect. 4 implements a mobile agent moving

and migrating through the area of interest and performing the

image processing. Initially, a master agent is sent to the upper

left corner node, sampling data and performing a partial

image convolution. Each node calculation carries out partial

calculation of sum terms of g

i,j

elements containing only the

local sensor data a

x,y

, updating g

i,j

with pseudo-code shown

in Eq. 2 (assuming array index numbers within range 1...N).

The FORTH program is compiled to a word-code machine

program consisting of about 600 words by using a lFORTH

compiler. A word requires 2 byte of memory storage. Due to

the low code size the entire program can be ﬁt in one

message. To summarize, this case study showed the

implementation of a complex algorithm with multi-agent

systems executable on single microchip nodes using code

morphing for carrying computational results and the

suitability of the proposed runtime environment approach II.

8 Comparison and conclusions

Table 3 compares both run-time architectures and agent

implementations. Both approaches allow the implementation

Fig. 8 Left energy distribution population map without SEM, Right

with SEM (after 10,000 time steps)

50 Prod. Eng. Res. Devel. (2013) 7:43–51

123

of agent mobility and processing on hardware single-chip

level. Flexibility and design time versus resource require-

ments is the main difference. The state-machine based

approach I with ﬁxed and hard implemented functional agent

behaviour is well suited for a small set of different agents with

simple algorithm complexity, whereas the code morphing

approach II is suited for a larger set of different agents with

higher algorithm complexity. A program-controlled approach

II is less power efﬁcient and requires more resources, but

provides a higher lever of implementation and design free-

dom. The code morphing approach II reduces communication

complexity. One main issue addressed in the design of multi-

agent systems is cooperation and communication of agents,

and to ensure how can agents understand each other. Message

based systems require some kind of communication language.

Each node, which processes agents must comply about well

known data structures used for inter-agent communication,

ﬁxed at design time. There are only limited capabilities to

handle data type inconsistency and the non-availability of

expected data. In contrast, the code based approach II uses

named code and data words resolved by a dictionary, with a

well known interface, and the capability to check and handle

type inconsistency. The hardware implementation of the

dictionary and the operational interface produces a fairly high

overhead of the resources compared with the traditional

shared data approach using memory references (as used in the

state-machine-based approach I). The smart routing protocol

must be modiﬁed to overcome the message live lock issues

and to improve stability by preserving reliability and robust-

ness. Future experimental investigations using real sensor

networks with different classes of data processing algorithms

should clarify the advantages and disadvantages of both

approaches.

References

1. Bosse S (2011) Hardware-software-co-design of parallel and

distributed systems using a unique behavioural programming and

multi-process model with high-level synthesis. In: Proceedings of

the SPIE microtechnologies 2011 conference, 18.4.2011–

20.4.2011, Prague, session EMT 102 VLSI circuits and systems

2. Bosse S, Lehmhus D (2010) Smart communication in a wired

sensor- and actuator-network of a modular robot actuator system

using a hop-protocol with delta-routing. In: Proceedings of smart

systems integration conference, Como, Italy, 23 to 24 Mar 2010

3. Bosse S, Pantke F, Kirchner F (2012) Distributed computing in

sensor networks using multi-agent systems and code morphing.

In: ICAISC conference, Prague

4. Kansal A, Hsu J, Zahedi S, Srivastava MB (2007) Power man-

agement in energy harvesting sensor networks. ACM Trans

Embed Comput Syst 6(4):32-es

5. Kent A, Williams JG (1998) Mobile agents, encyclopedia for

computer science and technology. M.Dekker Inc., New York

6. Klu

gel F (1998) The multi-agent simulation environment

SeSAm. In: Bning HK (ed) Proceedings of workshop ’’simulation

in knowledge-based systems’’, Paderborn, Apr 1998

7. Pantke F, Bosse S, Lehmhus D, Lawo M (2011) An artiﬁcial

intelligence approach towards sensorial materials. In: Future

computing conference

8. Peine H, Stolpmann T (1997) The architecture of the ara platform

for mobile agents, MA ’97. In: Proceedings of the ﬁrst interna-

tional workshop on mobile agents, Springer, London

9. Ro

mer K, Mattern F (2004) The design space of wireless sensor

networks. In: IEEE Wireless Communications 11, Dezember,

Nr. 6, pp 54–61

10. Wang AI, Sørensen CF, Indal E (2003) A mobile agent archi-

tecture for heterogeneous devices. Wireless Opt Comm

11. Wooldridge M (2009) An introduction to multiagent systems.

Wiley, New York

Table 3 Comparison of the two data processing approaches for mobile agents

Approach I. State-machine Approach II. Code morphing

Agent behaviour is Fixed, nodes must comply with previously

deﬁned common data types and structures as

well as message formats

Not ﬁxed, can change dynamically, and nodes do

not require knowledge of data structures and

types in advance

Functional behaviour is implemented Statically in local data processing machine Dynamically in programming code, which can

be modiﬁed by the program itself

Implementation in Hardware, single chip Hardware, single chip

Agent state is kept in Data storage Code, stacks, and data storage

Message size depends on Data complexity and size, data and control state,

but is independent of code complexity

Code complexity and size, but is independent of

state

Hardware resources are Small (\1M eq. logic gates including storage) Large ([1M–3M eq. logic gates including

storage)

Storage resources are Small (\5,000 register cells) Large ([10,000 register cells)

Speed is High (1–2 clock cycles per statement) Medium (5–20 clock cycles per core word

instruction)

Power consumption is Low and depends on code complexity Medium and is independent of code complexity

Prod. Eng. Res. Devel. (2013) 7:43–51 51

123