distributed agent based computing in material-embedded sensor network systems with the agent-on-chip...

IEEE SENSORS JOURNAL, VOL. 14, NO. 7, JULY 2014 2159

Distributed Agent-Based Computing inMaterial-Embedded Sensor Network Systems

With the Agent-on-Chip ArchitectureStefan Bosse

Abstract— Distributed material-embedded systems like sensornetworks integrated in sensorial materials require new dataprocessing and communication architectures. Reliability androbustness of the entire heterogeneous environment in the pres-ence of node, sensor, link, data processing, and communicationfailures must be offered, especially concerning limited service ofmaterial-embedded systems after manufacturing. In this paper,multiagent systems with state-based mobile agents are used forcomputing in unreliable mesh-like networks of nodes, usuallyconsisting of a single microchip, introducing a novel designapproach for reliable distributed and parallel data processingon embedded systems with static resources. An advanced high-level synthesis approach is used to map the agent behavior tomultiagent systems implementable entirely on microchip-levelsupporting agent-on-chip (AoC) processing architectures. Theagent behavior, interaction, and mobility are fully integratedon the microchip using a reconfigurable pipelined communicat-ing process architecture implemented with finite-state machinesand register-transfer logic. The agent processing architecture isrelated to Petri Net token processing. A reconfiguration mech-anism of the agent processing system achieves some degree ofagent adaptation and algorithmic selection. The agent behavior,interaction, and mobility features are modeled and specified withan activity-based agent behavior programming language. Agentinteraction and communication is provided by a simple tuple-space database implemented on node level and signals providingremote inter-node level communication and interaction.

Index Terms— Mobile agents, intelligent agents, parallelprocessing, distributed information systems.

I. INTRODUCTION AND OVERVIEW

EMBEDDED systems required for sensorial perceptionand structural monitoring (perceptive networks), used,

for example in Cyber-Physical-Systems (CPS) and StructuralHealth Monitoring (SHM) [6], perform the monitoring andcontrol of complex physical processes using applicationsrunning on dedicated execution platforms in a resource-constrained manner and with real-time processing constraints.

Trends emerging recently in engineering and micro-systemapplications such as the development of sensorial materials[15] show a growing demand for autonomous networks of

Manuscript received September 2, 2013; revised December 31, 2013;accepted January 6, 2014. Date of publication January 22, 2014; date ofcurrent version May 22, 2014. The associate editor coordinating the reviewof this paper and approving it for publication was Dr. Dirk Lehmhus.

The author is with the Department of Computer Science, Working GroupRobotics, ISIS Sensorial Materials Scientific Centre, University of Bremen,Bremen 28359, Germany (e-mail: [email protected]).

Color versions of one or more of the figures in this paper are availableonline at http://ieeexplore.ieee.org.

Digital Object Identifier 10.1109/JSEN.2014.2301938

miniaturized smart sensors and actuators embedded in tech-nical structures [6] (see Fig. 1). To reduce the impact ofsuch embedded sensorial systems on mechanical structureproperties, single microchip sensor nodes (in mm3 range) arepreferred. Real-time constraints require parallel data process-ing usually not provided by microcontrollers. Hence withincreasing miniaturization and node density, new decentralizednetwork and data processing architectures are required. Multi-agent systems (MAS) can be used for a decentralized andself-organizing approach of data processing in a distributedsystem like a sensor network [2], enabling the mappingof distributed raw sensor data to condensed information,for example based on pattern recognition [5]. In [2], theagent-based architecture considers sensors as devices usedby an upper layer of controller agents. Agents are organizedaccording to roles related to the different aspects to integrate,mainly sensor management, communication and data process-ing. This organization isolates largely and decouples the datamanagement from the changing network, while encouragingreuse of solutions. Multi-agent system-based structural healthmonitoring technologies are used to deal with high-densityand different kinds of sensors in reliable monitoring of largescale engineering structures [5]. In [18] and [19], agents aredeployed for distributed sensing and power management inwireless sensor networks, but still using embedded systemnodes not suitable for material integration.

Material-embedded data processing systems usually consistof single microchip nodes connected either wired in mesh-like networks [6] or wireless using ad-hoc networks [8] withlimited energy supply and processing resources. But tradi-tionally, mobile agents are processed on generic program-controlled computer architectures using virtual machines[7], [8], [18], [19], which usually cannot easily be reducedto single microchip level like they are required in sensor-ial materials. Furthermore, agents are treated with abstractheavy-weighted knowledge-based models, not entirely match-ing distributed data processing in sensor networks. In [3], amulti-agent system is used for advanced image processingmaking profit from the inherent parallel execution model ofagents.

Application specific digital logic hardware design hasadvantages compared to program controlled microcontrollerapproaches concerning power consumption, performance,and chip resources by exploiting parallel data processing(covered by the agent model) with lower clock frequenciesand enhanced performance [10].

1530-437X © 2014 IEEE. Personal use is permitted, but republication/redistribution requires IEEE permission.See http://www.ieee.org/publications_standards/publications/rights/index.html for more information.

2160 IEEE SENSORS JOURNAL, VOL. 14, NO. 7, JULY 2014

Fig. 1. Sensorial materials embedded in robots providing perception information of external applied load forces or internal structure load.

There are actually four major issues related to the scaling oftraditional software-based multi-agents systems to microchiplevel and their design:

1) limited static processing, storage,and communicationresources, real-time processing,

2) unreliable communication,3) suitable simplified programming models and processing

architectures offering hardware designs with finite statemachines (FSM) and resource sharing for parallel agentexecution, and

4) a generic high-level synthesis design approach.Microchip level implementations of multi-agent systems wereoriginally proposed for low level tasks, for example in[12] using agents to negotiate network resources and for high-level tasks using agents to support human beings in ambient-intelligence environments [14]. The first work implements theagent behavior directly in hardware, the second uses still a(configurable) microcontroller approach with optimized paral-lel computational blocks providing instruction set extension.A more general and reconfigurable implementation of agentson microchip level is reported in [1], providing a closed-loop design flow especially focussing on communication andinteraction, though still assuming and applying to programcontrolled data processing machines and architectures. Hard-ware implementations of multi-agent systems are still limitedto single or a few and non-mobile agents ([1], [20]).

In this work, an advanced high-level synthesis approach isintroduced to map the agent behavior of multi-agent systemson microchip-level with an Agent-On-Chip processing archi-tecture (AoC). The agent behavior, interaction, and mobilityare fully integrated on the microchip using a reconfigurablepipelined communicating process architecture implementedwith finite-state machines and register-transfer logic. Thisarchitecture supports parallel agent execution with a resourceshared pipeline approach. In this approach, the agent process-ing is comparable to Petri Net token processing. A reconfigura-tion mechanism of the agent processing system achieves somekind of agent adaptation and algorithmic section based onenvironmental changes like partial hardware or inter-connectfailures or based on learning and improved knowledge base.

The agent behavior, interaction, and mobility featuresare modelled and specified with an activity-based agent

behavior programming language (AAPL). The activity-graph based agent model is attractive due to theproximity to the finite-state machine model, which simplifiesthe hardware implementation. With this AAPL a high-levelagent compiler is able to synthesize a hardware model onRegister-Transfer Level (RTL, VHDL), alternatively a softwaremodel (C, ML), or a simulation model (XML) suitable tosimulate a multi-agent system using the SeSAm simulatorframework [9]. Agent interaction and communication areprovided firstly by a simple tuple-space database implementedon each node providing access and sharing of local data,and secondly by signals able to propagate in the network(like messages) preferred for fast and light-weighted remoteinter-node level communication and interaction. To enabledynamic adaptation of the agent behavior at run-time, theagent processing architecture implementing the agent behaviorcan be (re)configured by agents by modifying the transitionalnetwork.

Traditionally agent programs are interpreted, leading to asignificant decrease in performance. In the approach presentedhere the agent processing platform can directly be imple-mented in standalone hardware nodes without intermediateprocessing levels and without the necessity of an operatingsystem, but still enabling software implementations that canbe embedded in applications.

There is related work concerning agent programming lan-guages and processing architectures, like APRIL[13] providingtuple-space like agent communication, and widely used FIPA,ACL, and KQGML[11] focusing on high-level knowledgerepresentation and exchange. All those approaches representcommunication and information on complex and abstractlevel not fully suited for the synthesis of low-resource dataprocessing systems in distributed loosely coupled networks,especially in sensor networks, in contrast to the proposedAAPL approach, simple enough to enable hardware designsynthesis, but powerful enough to model the agent behaviorof complex distributed systems, which is demonstrated in thefollowing case study. Though the imperative programmingmodel is quite simple and closer to a traditional PL it can beused as a common source and intermediate representation fordifferent agent processing platform implementations: hardware(HW), software (SW), and simulation (SIM).

BOSSE: DISTRIBUTED AGENT-BASED COMPUTING 2161

Fig. 2. Prototype of a Sensorial Material using intelligent sensor networks.

What is novel compared to other approaches?

• Reliability and reactivity provided by the autonomy ofmobile state-based agents and reconfiguration.

• Agent mobility and interaction by using tuple-spacedatabases and global signal propagation aid solving datadistribution and synchronization issues in distributed sys-tems design, and tuple spaces represent agent belief.

• One common agent programming language and process-ing architecture enables the synthesis of standaloneparallel hardware implementations, alternatively stand-alone software implementations, and behavioral simula-tion models, enabling the design and test of large-scaleheterogeneous systems.

• AAPL provides powerful statements for computation andagent control with static resources.

• A token-based pipelined multi-process agent process-ing architecture suitable for hardware platforms withRegister-Transfer Level Logic offering optimized com-putational resources and speed.

• Improved scaling in large network applications comparedwith full or semi centralized and pure message basedprocessing architectures.

II. FIELDS OF APPLICATION: SENSORIAL MATERIALS

Sensorial Materials are equipped with material-embeddedhigh miniaturized distributed sensor networks performing loadmonitoring or environmental perception [15], shown in prin-ciple in Fig. 1. These embedded sensor networks consistof nodes equipped with sensor signal electronics and digitallogic performing computation and communication. Optionallythere are material-embedded energy sources (energy harvester)supplying the nodes locally.

Fig. 2 shows a prototype of a Sensorial Material usingintelligent sensor networks. Each autonomous network node isconnected with up to four neighbors and strain-gauge sensorsmounted on a rubber sheet, altogether equipped with nine

bi- axial strain-gauge sensors placed at a distance of 70 mm.The Sensorial Material was used to retrieve load informationabout the sheet (applied by external forces) by using advancedmachine learning methods from a small set of uncalibratedsensors with unknown electro-mechanical model still provid-ing high spatial resolution compared with the distance of thesensors to each other.

Fig. 3 shows the usage of such material in an intersectionelement of a robot arm manipulator providing external envi-ronmental perception required for robot control. The proposedrobot manipulator [16] consists of actors (joint drives) andintersection elements with integrated smart sensor networks.Distributed data processing is provided by mobile agents.The agent behavior is implemented with SoC designs onhardware-level. The intersection element connects two jointactors with a rigid double-pipe construction, which is sur-rounded by two opposite placed load sensitive skins (bentrubber plate), equipped each with four strain-gauge sensorpairs (bi-axially aligned). Each sensor pair is connected to asensor node providing parallel data processing, agent behaviorimplementation, and communication/networking. All sensornodes are arranged in a mesh-like network connected withserial point-to-point links. Communication is established by asmart and robust routing protocol.

III. STATE-BASED AGENTS AND THE AGENT

PROGRAMMING LANGUAGE APL

Initially, a sensor network is a collection of independentcomputing nodes. Interaction between nodes is required tomanage and distribute data and to compute information.One common interaction model is the state-based mobileagent.

The behavior of a state-based agent can be easily mod-elled with a finite-state machine completely implementablewith register-transfer logic (RTL) on microchip level eas-ing high-level synthesis and the exploitation of concurrency


Fig. 3. Robot arm manipulator intersection element equipped with smart sensor networks providing perception information of external applied load forcesbased on preliminary work with flat rubber plate.

Fig. 4. Agent behavior programming level with activities and transitions (AAPL programming level, left); agent class model organizing activities andtransitions in graphs (middle); agent instantiation, processing, and interaction on the network node level (right).

required for material-embedded real-time data processing. Theimplementation of mobile multi-agent systems for resourceconstrained embedded systems with a focus on microchiplevel is a complex design challenge. High-level agent pro-gramming languages can aid to solve this design issue.Though there are already several agent modelling, interaction,and communication languages, they are not fully suitableto carry out multi-agent systems on microchip level. Forthis purpose, the Agent Programming Language AAPL wasdesigned to enable the optimized design of state-based agentsand microchip scaled processing dealing with limited staticresources. This language consists of generic imperative andcomputational statements and a type system derived from asubset of the Modula-3 language, allowing subrange types

required for hardware synthesis, and agent specific statementsto specifying the behavior, mobility, and interaction of agents.This technology-independent programming model can bedirectly synthesized to hardware, alternatively to software andsimulation model targets without modification.

The agent behavior is partitioned and modelled with anactivity graph, with activities (representing the control stateof the agent) and conditional transitions enabling activities.Activities provide sequential execution of proceduraldata processing statements. An activity is activated bya conditional transition depending on the evaluation ofagent data (conditional transition), or using unconditionaltransitions. An agent belongs to a specific parameterizedagent class AC, specifying local agent data(only visible for


the agent itself), types, signals, activities, signal handlers, andtransitions, shown in principle in Fig. 4.

New agents of a specific class can be created at runtime byagents using the new AC(v1,v2,..) statement returninga node unique agent identifier. An agent can create multipleliving copies of itself with a fork mechanism, creating childagents of the same class with inherited data and control statebut with different parameter initialization, done by using thefork(v1,v2,..) statement. Agents can be destroyed byusing the kill(ID) statement.

Statements inside an activity are processed sequentially andconsist of data assignments (x :=ε) operating on agent’sprivate data, control flow statements (conditional branches andloops), and special agent control and interaction statements,summarized in Def. 1.

Agent interaction and synchronization is provided by atuple-space database server available on each node. An agentcan store an n-dimensional data tuple (v1,v2,..) in the databaseby using the out(v1,v2,..) statement(commonly the firstvalue is treated like a key). A data tuple can be removed orread from the database by using the in(v1,p2?,v3,..)or rd(v1,p2?,v3,..) statements with a pattern templatebased on a set of formal (variable,?) and actual (constant)parameters. These operations block the agent processing until amatching tuple was found/stored in the database. These simpleoperations solve the mutual exclusion problem in concurrentsystems easily. Only agents processed on the same networknode can exchange data this way.

The existence of a tuple can be checked by using theexist? function or with atomic test-and-read behavior usingthe try_in/rd functions. A tuple with a limited lifetime(a marking) can be stored in the database by using themark statement. Tuples with exhausted lifetime are removedautomatically by a garbage collector. Tuples matching aspecific pattern can be removed with the rm statement.

Remote light-weighted interaction between agents is pro-vided by signals with optional parameters, implementing aremote-procedure call interface.

A signal can be raised by an agent using thesend(ID,S,V) statement specifying the ID of the tar-get agent (which must be created by the sending agent),the signal name S, and an optional argument value Vpropagated with the signal. The receiving agent must pro-vide a signal handler (like an activity) to handle signals(asynchronously). Alternatively, a signal can be sent to agroup of agents belonging to the same class AC within abounded region using the broadcast(AC,DX,DY,S,V)statement.

Migration of agents to a neighbor node (by preserving thelocal data and processing state) is performed by an agent usingthe moveto(DIR) statement, assuming the arrangement ofnetwork nodes in a mesh- or cube-like network. To test ifa neighbor node is reachable (testing connection liveliness),the link?(DIR) statement returning a boolean result canbe used.

Within activities agents can change the transitional net-work (initially specified in the transition section) by chang-ing, deleting, or adding (conditional) transitions using the

Agent Class Definitionagent class (arguments)= definitions end;

Activity Definitionactivity name = statements end;

Data Statementsvar x,y,z:type;x := ε(variable,value,constant);

Conditional Statementsif cond then statements else statements end;case ε of | v1 -> statements |.. end;

Loop Statementsfor i := range do statements end;while cond do statements end;

Transition Network Definitiontransitions = transitions end;a1 -> a2: cond ;

Tuple Database Statementsout(v1,v2,..); .. exist?(v1,?,..)..in(v1,x1?,v2,x2?,...); rd(v1,x1?,v2,x2?,...);try_in(timeout,v1,..); try_rd(timeout,v1,..);mark(timeout,v1,v2,..); rm(v1,?,..);

Signalssignal S:datatype;handler S(x) = statements end;send(ID,S,v); reply(S,v);broadcast(AC,DX,DY,S,v);timer+(timeout,S);timer-(S); sleep; wakeup;

Exceptionsexception E; raise E;try statements except E -> statements end;

Mobility, Creation, and Reproductionmoveto(direction);.. link?(direction) ..id := new class (arguments);id := fork(arguments);kill(id);

Reconfigurationtransition+(a1,a2,cond);transition*(a1,a2,cond);transition-(a1,a2);

Def. 1: Summary of the AAPL Language (.. x.. means x is part of anexpression ε, and ; terminates procedural statements)

transition♦(S1,S2,cond) statements (with ♦=‘+’:add, ‘-’: remove, and ‘*’: change transition).

The usage of the programming language is illustrated inmore detail in the following case study.

IV. AGENT-ON-CHIP: THE AGENT PROCESSING

ARCHITECTURE AND SYNTHESIS

The agent processing architecture required at each networknode must implement different agent classes and must bescalable to the microchip level to enable material-integratedembedded system design, and represent a central design issuefor new the Agent-on-Chip data processing approach, furtherfocussing on parallel agent processing and optimized resourcesharing.

A. Activity Processing

In this work the agent behavior is implemented with a recon-figurable pipelined communicating process model derived


Fig. 5. Mapping of the agent behavior programming level to the agent processing architecture with pipelined communicating sequential processes and thefinal mapping on RT level. Agent tokens are passed by queues and conditional selectors from an outgoing to an incoming activity process.

from the Communicating Sequential Process model (CSP)proposed by Hoare (1985). The set of activities {Ai } is mappedon a set of sequential processes {Pi } executed concurrently.The set of transitions {Ti } is mapped on a set of synchronousqueues {Qi } and transition selectors {Si} providing inter-activity-process communication, shown in Fig. 5. Agents arerepresented by tokens (natural numbers equal to the agentidentifier, unique on each node), which are transferred by thequeues between activity processes depending on the specifiedtransition conditions. This multi-process model is directlymappable to RTL hardware and software implementations.Each process Pi is mapped to a finite state machine FSMi

controlling process execution and a register-transfer data path.Local agent data is stored in a region of a memory mod-ule assigned to each individual agent. There is only oneincoming transition queue for each process consuming tokens,performing processing, and finally passing tokens to outgoingqueues, which can depend on conditional expressions. Thereare computational and IO/event based activity statements. Thelatter ones can block the agent processing until an event occurs(for example, the availability of a data tuple in the database).Blocking statements {s j,i } of an activity Ai are assigned toseparate intermediate IO processes {Pi, j } handling only IOevents or additional post computations, as shown on the bottomof Fig. 5.

Agents in different activity states can be processed con-currently. Thus, activity processes that are shared by severalagents may not block. To prevent blocking of IO-event basedprocesses (for example waiting for data), not-ready processes

pass the agent token back to the input queue. An IO processeither processes unprocessed agent tokens or waits for thehappening of events, controlled by the agent manager.

The pipeline architecture offers advanced resource sharingand concurrent processing of agents in different activity states.Only one activity process chain implementation for each agentclass is required on each node, in contrast to previous program-mable architectures [4] providing only limited concurrency andresource sharing.

B. Resources

A rough estimation of the resource requirements R for thehardware implementation of the agent processing architecturesupporting a set of N different agent classes {ACi } is shownin Eq. 1, with each class having Mi activitie, Ti transitions,Di data cells with a resource weight wdata, and wact,i, j foreach activity, and a maximal number of managed agents foreach class Nagents,i . The tuple space database requires wts,i*Si

resources for each supported n-dimensional space. The Cx

values are control parts independent of the above values.

R � (wdata

∑

i∈AC

Nagentsi Di )

+ Csched + wsched(∑

i∈AC

Mi ) + wsched max(Nagentsi )

+ Ccomm + (wqueue + wcond )(∑

i∈AC

Ti )

+ (∑

i∈AC

∑

j∈ATi

wacti, j )+Cts + (

∑

i∈T S

wt si Si ) (1)


Fig. 6. Agent migration and signal propagation using message trans-fers (LAH:Local Agent Handler,LID : Local Agent Identifier,AC:AgentClass,LIVE: agent life,STATE: agent state, DX and DY: spatial displacementvector,SID: Signal Identifier,SIG: pending signal. ID).

For example, assuming simplified four agent classes withN=16 agents for each class, each class requires D=512bit memory, M=10 (wact=500), T=16, three tuple spaces(1,2,3) with S=32 (and w1=32, w2=64, w3=128) entries each,and wdata=4, wqueue=150, wsched=60, wcond=50, wact=500,Csched=5000, Ccomm= 10000, Cts=1000 (based on experi-mental experiences, all w and C values in eq. gates units),which results in 189400 eq. gates for the HW implementation.

C. Power/Efficiency

Agents are often heavy-weighted processing entities inter-preted by software-based virtual machines. In contrast, in theproposed RTL architecture the agent behavior is mapped onfinite state machines and a data path with data word lengthscaling, offering minimized power- and resource requirements,both in the control and data path. Most activity statements areexecuted by the platform in one or two clock cycles! All com-monly administrative parts like the agent manager, communi-cation protocols, and the tuple-space database commonly partof an operating system are implemented in hardware, offeringadvanced computational power enabling low-frequency andlow-power designs, well suited for energy-autonomous sys-tems. Transition network changes can be performed within afew clock cycles.

D. Agent Manager

The agent manager provides a node level interface foragents, and it is responsible for the creation, control (includingsignals, events, and transition network configuration), andmigration of agents with network connectivity, implementing amain part of an operating system. The agent manager controlsthe tuple-space database server and signal events required forIO/event based activity processes.

The agent manager uses agent tables and caches to storeinformation about created, migrated, and passed throughagents (req., for ex.,for signal propagation), see Fig. 6.

E. Migration

Migration of agents between nodes incorporates only thetransfer of the agent state consisting of data (the contentof body variables) and the control state (a pointer to thenext activity to be executed after migration and the transitionconfiguration) of the agent together with a unique global agentidentifier (extending the local ID with the agent class andthe relative displacement of its root node) encapsulated inmessages with low overhead, shown in Fig. 6. This approachminimizes network load and energy consumption significantly.Migration of simple agents results in a message size between100–1000 bits. The agent start-up time after the data transferis low (about some hundred clock cycles).

F. Transition Network

A switched transition network allows the reconfigurationof the activity transitions at runtime. Though the possiblereconfiguration and the conditional expressions must be knownat compile time (static resource constraint!), a reconfigurationcan release the use of some activity processes and enhancesthe utilization for concurrent processing of other agents of thesame class. The transition network is implemented with tablesin case of the HW implementation, and with dynamic listsin case of the SW and SIM implementations. Agent activitytransition configurations can be inherited by child agents.

G. Tuple-Space Database

Each n-dimensional tuple-space TSn (storing n-ary tuples)is implemented with fixed size tables in case of the hardwareimplementation, and with dynamic lists in the case of thesoftware and simulation model implementations. The access ofeach tuple-space is handled independently. Concurrent accessof agents is mutually exclusive. The HW implementationimplicates further type constraints, which must be known atdesign time (e.g. limitation of integer ranges) provided by sub-range-typing in the AAPL specification.

H. Signals

Signals must be processed asynchronously. Therefore, agentsignal handlers are implemented with a separate activityprocess pipeline, one for each signal handler. For each pendingagent signal, the agent manage injects an agent token inthe respective handler process pipeline independent of theprocessing state of the agent. Remote signals are processedby the agent manager, which encapsulate signals in messagessent to the appropriate target node and agent, shown in Fig. 6.

I. Synthesis

The database driven synthesis flow is illustrated in Fig. 7.The AAPL program is parsed and mapped to an abstractsyntax tree (AST). The first compiler stage analyzes, checks,and optimizes the agent specification AST. The second stageis divided into three parts: an activity to process mapper, atransition to queue mapper, a transition (pipelined process-ing architecture) network builder, and a message generator


Fig. 7. Simplified agent-on-chip high-level synthesis flow producing different (independent) output targets.

Fig. 8. Distributed feature extraction in an unreliable and incomplete mesh network (with missing links) by using distributed agents with directed diffusionmigration and self-organization behavior.

supporting agent and signal migration. There are differentsupported backends (HW/SW/SIM). The high-level hardwaredescription enables the SoC synthesis using the ConPro high-level synthesis framework [10], which maps activity processeson finite state machines and the RT datapath level.

The ConPro programming model reflects an extended CSP,which provides atomic guarded actions on shared resourcesaccess. Each process is implemented with a FSM and a RTdatapath. Furthermore, a software description (C), which canbe embedded in application programs, and a simulation modelusable for MAS simulation using the SeSAm simulator [9], canbe derived.

All implementation models (HW/SW/SIM) provide equalfunctional behavior, and only differ in their timing, resourcerequirements,and execution environments.

J. Simulation

In addition to real hardware-implemented agent processingplatforms there is the capability of the simulation of theagent behavior, mobility, and interaction on a functional levelusing the SeSAm simulation framework [9], which offers aplatform for the modelling, simulation, and visualization ofmobile multi-agent systems employed in a two-dimensionalworld. The behavior of agents is modelled with activity graphs

(specifying the agent reasoning machine) close to the AAPLmodel. But some special transformations must be applied toenable the simulation: 1. AAPL activities (IO/event-based) canblock the agent processing until an event occurs. Blockingagent behavior is not provided directly by SeSAm. ⇒ activitydecomposition 2. The transition network can change duringrun-time ⇒ use of a transition scheduler 3. The handling ofconcurrent asynchronous signals used in AAPL for inter-agentcommunication cannot be established with the generic activityprocessing in SeSAm ⇒ use of a signal scheduler.

V. CASE STUDY: STRUCTURAL HEALTH MONITORING

A small example implementing a distributed feature detec-tion in an incomplete and unreliable mesh-like sensor networkusing mobile agents should demonstrate the suitability ofthe proposed agent processing approach. The sensor networkconsists of nodes with each node attached to a sensor (e.g.Strain-gauge). The nodes can be embedded in a mechanicalstructure, for example, used in a robot arm. The goal of theMAS is to find extended correlated regions of increased sensorintensity (compared to the neighborhood) due to mechani-cal distortion resulting from externally applied load forces.A distributed directed diffusion behavior and self-organization(see Fig. 8) is used, derived from the image feature extractionapproach proposed in [17]. Single sporadic sensor activities


Fig. 9. Simulation results for two different sensor network situations (left: start, middle: exploration, right: final result situation). Top row: sensor activitywithin clusters, bottom row: sensor activity scattered over the network.

not correlated with the surrounding neighborhood should bedistinguished from an extended correlated region, which is thefeature to be detected.

There are three different agent classes: an exploration, anode agent, and a deliver agent. A node agent is immobileand is primarily responsible for sensor measurement andobservation.

The feature detection is performed by the mobile explo-ration agent that supports two main different behaviors: diffu-sion and reproduction. The diffusion behavior is used to movewithin a region, mainly limited by the lifetime of the agent, andto detect the feature, here the region with increased mechanicaldistortion (more precisely the edge of such an area). Thedetection of the feature enables the reproduction behaviorthat induces the agent to stay at the current node, setting afeature marking and sending out more exploration agents inthe neighborhood. The local stimuli H(i,j) for an explorationagent to stay at a specific node with the coordinates (i,j) isgiven by eq. 2.

H (i, j) =R∑

s=−R

R∑

t=−R

{‖S(i + s, j + t) − S(i, j)‖ ≤ δ}

S : Sensor Signal Strength

R : Square Region around (i, j) (2)

The calculation of H at the current location (i, j) of the agentrequires the sensor values within the square area (the regionof interest ROI) R around this location. If a sensor valueS(i+s, j+t) with i, j∈{−R,..,R} is similar to the value S atthe current position (diff. is smaller than the parameter δ),H is incremented by one.

If the H value is within a parameterized interval� = [ε0, ε1], the exploration agent has detected the featureand will stay at the current node to reproduce new exploration

agents send to the neighborhood. If H is outside this interval,the agent will migrate to a neighbor different node and restartsexploration (diffusion).

The calculation of H is performed by a distributed cal-culation of partial sum terms by sending out child exploreragents to the neighborhood, which itself can send out moreagents until the boundary of the region R is reached. Eachchild agent returns to its origin node and hand over the partialsum term to his parent agent, shown in Fig. 8. Because anode in the region R can be visited by more than one childagent, the first agent reaching a node sets a marking MARK.If another agent finds this marking, it will immediately returnto the parent. This multi-path visiting has the advantage ofan increased probability of reaching nodes with missing (nonoperating) communication links (see Fig. 8). A deliver agent,created by the node agent, finally delivers exploration resultsto interested nodes by using directed diffusion approaches, notdiscussed here.

Ex. 1 shows the AAPL behavior specification for theexploration agent. The agent behavior is partitioned in nineactivities and two signal handlers. If a sensor node agentobserves an increased sensor value, it creates a new exploreragent that enters the start activity (lines 8–19). Each exploreragent is initialized on creation with two parameter arguments:a direction and a radius value. The first agent created bythe sensor node has no specific direction. Child agents witha specific direction move to the respective node (line 11).In line 18, the transition move → percept_neighboris created (all existing transitions starting from activity moveare deleted first). The start activity transitions to the perceptactivity, which creates child agents (lines 44–46). Forkedagents inherit all parent data and the current transition networkconfiguration. For this, in line 56 the transition percept →move is established (and inherited), but after forking reseted in


TABLE I

HIGH-LEVEL AND GATE-LEVEL SYNTHESIS RESULTS FOR ONE SENSOR NODE

lines 61 and 62 for the parent agent behavior, which await thereturn of all child agents and a decision for behavior selection(reproduce/diffuse).

The child agents enter the move (lines 20–25) activityafter forking and will migrate in the specific direction to theneighbor node. Finally, the percept_neighbor activity isreached, which performs the local calculation (line 55) if therewas no marking found, and finally stores the partial result inthe tuple database. Further child agents are sent out if theboundary of the ROI is still not reached.

Otherwise the agent goes back to his origin (parent)by entering the goback activity performing the migration(lines 66–68), previously updating its h value from the tupledatabase. If the returning agent has arrived, it will deliver itsh value by adding it to the local H value stored in the database(lines 71 and 72) and raising the WAKEUP signal to notify theparent,which causes the entering of the parent’s signal handler(lines 77–79).

If there is enough input and all child agents had returned(or a time-out has occurred handled by the signal handlerTIMEOUT, lines 80 and 81), the exploration agent either entersthe diffuse or reproduce activity.

Diffusion and reproduction is limited by a lifetime(decreased each time an explorer agent is replicated or onmigration, lines 27 & 36).

A. Synthesis and Simulation

The agent behavior specification was synthesized to a digitallogic hardware implementation (single SoC) and a simulationmodel with equal functional behavior suitable for the MASsimulator environment SeSAm[9]. The suitability of the self-organizing approach for feature detection was justified bysimulation results shown in Fig. 9 for two different sensornetwork situations, each consisting of a 10 by 10 network withautonomous sensor nodes. Each node is connected with up tofour neighbors. One situation creates significant sensor valuesarranged in a bounded cluster region, for example, causedmy mechanical forces applied to the structure, and the othersituation creates significant sensor values scattered around thenetwork without any correlation, for example, caused by noisyor damaged sensors.

In the first clustered situation, the explorer agents arecapable to detect the bounded region feature for the twoseparated regions (indicated by the change of the agent colourto black). Due to the reproduction-behavior there are severalagents at one location, shown in the right agent density contour

plot. In the second unclustered situation, the explorer agentsdid not find the feature and vanish due to their limited lifetimebehavior.

The feature-search is controlled by a set of parameters:{δ, ε0, ε1, lifetime, search radius R}.The synthesis results of the hardware implementation

for one sensor node are shown in Table I, which are inaccordance with the resource estimation from Sec. IV. TheAAPL specification was compiled to the ConPro program-ming model and synthesized to an RTL implementationcreating VHDL models. Two different target technologieswere synthesized by using gate-level synthesis: 1. FPGA,Xilinx XC3S1000 device target using Xilinx ISE 9.2 soft-ware, 2. ASIC standard cell LIS10K library using theSynopsys Design Compiler software. The agent processingarchitecture consisted of the activity process chain for theexplorer and node agent, the agent manager, the tuple-space database (supporting two- and three-dimensionaltuples with integer type values), and the communicationunit.

This case study showed firstly the suitability of the multi-agent-based approach for feature detection in large scalesensor networks, for example used in real-time structuralhealth monitoring for sensor data filtering, and secondlythe suitability of the proposed agent modelling and syn-thesis approach for single System-on-Chip microchip-levelimplementations.

Ex. 1: Excerpt of the AAPL specification for agent classExplore implementing a feature extraction agent with dis-tributed directed diffusion and self-organizing behavior.

1 type keys={ADC,FEATURE,H,MARK};direction={..}2 signal WAKEUP,TIMEOUT; val RADIUS := 4; ...3 agent explore(dir:direction,4 radius: integer[1..16]) =5 var dx,dy:integer[-100..100];6 live:integer[0..15]; ......7 var* s: integer[0..1023]; ......8 activity start =9 dx := 0; dy := 0; h:= 0;10 if dir <> ORIGIN then11 moveto(dir);12 case dir of13 | NORTH -> backdir := SOUTH14 | SOUTH -> ......15 else


16 live := MAXLIVE; backdir := ORIGIN17 group := random(integer[0..1023]);18 transition*(move,percept_neighbor);19 out(H,id(self),0); rd(ADC,s0?)20 activity move =21 case dir of22 | NORTH -> backdir := SOUTH; incr(dy)23 | SOUTH -> backdir := NORTH; decr(dy)24 | WEST -> ....25 moveto(dir)26 activity diffuse =27 decr(live); rm(H,id(self),?);28 if live > 0 then29 case backdir of30 | NORTH -> dir :=31 random({SOUTH,EAST,WEST})32 | SOUTH -> ....33 else kill(ME)34 activity reproduce =35 var n:integer;36 decr(live);37 if live > 0 then38 for nextdir in direction do39 if nextdir <> backdir and39 link?(nextdir) then40 fork(nextdir,radius)41 transition*(reproduce,stay)42 activity percept = – Master perception –43 enoughinput := 0; transition*(percept,move);44 for nextdir in direction do45 if nextdir <> backdir and.. link?(nextdir)then46 incr(enoughinput);fork(nextdir,radius)47 transition*(percept,diffuse, (h<ETAMIN or48 h > ETAMAX) and enoughinput < 1);49 transition+(percept,reproduce,h>=ETAMIN and50 h <= ETAMAX and enoughinput < 1);51 timer+(TMO,TIMEOUT)52 activity percept_neighbor =53 if not exist?(MARK,group) then54 mark(TMO,MARK,group); enoughinput:= 0;55 rd(ADC,s?); out(H,id(self),calc());56 transition*(percept_neighbor,move);57 for nextdir in direction do58 if nextdir <> backdir and.. inbound(nextdir) and59 link?(nextdir) then60 incr(enoughinput);fork(nextdir,radius)61 transition*(percept_neighbor,goback,62 enoughinput < 1);63 timer+(TMO,TIMEOUT)64 else65 transition*(percept_neighbor,goback) end66 activity goback =67 h := 0; try_in(0,H,id(self),h?);68 moveto(backdir);69 activity deliver =70 var v:integer;71 in(H,id(parent),v?); out(H,id(parent),h+v);72 send(id(parent),WAKEUP); kill(ME)73 activity stay =74 rm(H,id(self),?);75 n :=0; try_in(0,FEATURE,n?);

76 out(FEATURE,n+1)77 handler WAKEUP =78 decr(enoughinput); try_rd(0,H,id(self),h?);79 if enoughinput < 1 then timer-(TIMEOUT)end80 handler TIMEOUT =81 enoughinput := 0; again := true82 function calc():integer=83 if abs(s-s0) <= DELTA then return 184 else return 085 function inbound(nextdir:direction):bool=86 case nextdir of87 | NORTH -> return (dy < RADIUS)88 | SOUTH -> ......89 transitions =90 start -> percept; percept -> move;91 move -> percept_neighbor;

VI. CONCLUSION

A novel design approach using mobile agents for reli-able distributed and parallel data processing in low-resourcenetworks with embedded hardware nodes was introduced.A multi-agent programming language AAPL provides com-putational statements and statements for agent creation, inher-itance, mobility, interaction, reconfiguration, and informationexchange, based on the agent behavior partitioning in an activ-ity graph, which can be directly synthesized to the microchiplevel by using a high-level synthesis approach and finite statemachines on RT level.

Agent interaction is delivered by a simple but powerful tupledatabase approach. The tuple-space is a central part of theagent’s belief, and contributes to the decision making processof agents. Agents can be created dynamically at runtime byother agents.

This proposed agent processing architecture implementsa resource and speed optimized virtual machine consistingof a reconfigurable pipelined communicating process chain.Only one virtual machine is required for each agent class,which should be supported on a particular network node. Thepipeline approach enables concurrent agent processing andadvanced resource sharing. Replication of activity processescan increase the computational performance significantly, forexample, based on timed Petri-Net analysis.

Unique identification of agents does not require uniqueabsolute node identifiers or network addresses, a prerequisitefor loosely coupled and dynamic networks (due to failures,reconfiguration,or expansion).

Reconfiguration of the activity transition network supportedon programming level offers agent behavior adaptation atruntime based on the data state of the agent resulting fromenvironmental changes like partial hardware or interconnectfailures or based on learning and improved knowledge base.The transitional configuration can be inherited by child agents.Finally, improved resource sharing for parallel processing isoffered.

A case study implementing a self-organizing multi-agentsystem in a sensor network demonstrated the suitability ofthe proposed programming model, processing architecture,and synthesis approach. Migration of agents requires onlythe transfer of the control and data space of an agent using


messages. The agent behavior is fixed and bound to each node.The high-level synthesis tool enables the synthesis of differentoutput models from a common programming source, includ-ing hardware, software, and simulation models delivering anadvanced design methodology for functional testing.

REFERENCES

[1] Y. Meng, “An agent-based reconfigurable system-on-chip architecturefor real-time systems,” in Proc. 2nd ICESS, Dec. 2005, pp. 166–173.

[2] M. Guijarro, R. Fuentes-Fernandez, and G. Pajares, “A multi-agent system architecture for sensor networks,” in Multi-AgentSystems—Modeling, Control, Programming, Simulations and Applica-tions, F. Alkhateeb, Ed. Rijeka, Croatia: InTech, 2011.

[3] M. Lückenhaus and W. Eckstein, “A multi-agent based system forparallel image processing,” Proc. SPIE, vol. 3166, pp. 21–30, Sep. 1997.

[4] S. Bosse and F. Pantke, “Distributed computing and reliable communi-cation in sensor networks using multi-agent systems,” Prod. Eng., vol. 7,no. 1, pp. 43–51, Jan. 2013.

[5] X. Zhao, S. Yuan, Z. Yu, W. Ye, and J. Cao, “Designing strategy formulti-agent system based large structural health monitoring,” ExpertSyst. Appl., vol. 34, no. 2, pp. 1154–1168, Feb. 2008.

[6] F. Pantke, S. Bosse, D. Lehmhus, and M. Lawo, “An artificial intel-ligence approach towards sensorial materials,” in Proc. 3rd Int. Conf.Future Comput. Technol. Appl., Sep. 2011.

[7] H. Peine and T. Stolpmann, “The architecture of the ara platform formobile agents,” in Mobile Agents (Lecture Notes in Computer Science).New York, NY, USA: Springer-Verlag, 1997.

[8] A. I. Wang, C. F. Sørensen, and E. Indal, “A mobile agent architecture forheterogeneous devices,” in Proc. Wireless Opt. Commun., 2003, pp. 1–7.

[9] F. Klügel, “SeSAm: Visual programming and participatory simulationfor agent-based models,” in Multi-Agent Systems—Simulation and Appli-cations, A. M. Uhrmacher and D. Weyns, Eds. Boca Raton, FL, USA:CRC Press, 2009.

[10] S. Bosse, “Hardware-software-co-design of parallel and distrib-uted systems using a unique behavioural programming and multi-process model with high-level synthesis,” Proc. SPIE, vol. 8067,pp. 80670G-1–80670G-13, Apr. 2011.

[11] S. Napagao, B. Auffarth, and N. Ramirez. (2007). AgentLanguage Analysis:3-APL [Online]. Available: http://www-lehre.inf.uos.de/∼bauffart/mas_3apl.pdf

[12] M. Ebrahimi, M. Daneshtalab, P. Liljeberg, J. Plosila, and H. Tenhunen,“Agent-based on-chip network using efficient selection method,” in Proc.IEEE/IFIP 19th Int. Conf. VLSI-SoC, Oct. 2011, pp. 284–289.

[13] F. G. McCabe and K. L. Clark, “APRIL—Agent process interactionlanguage,” in Intelligent Agents (Lecture Notes in Computer Science),vol. 890. M. Wooldridge and N. R. Jennings, Eds. New York, NY, USA:Springer-Verlag, 1995.

[14] I. del Campo, K. Basterretxea, J. Echanobe, G. Bosque, and F. Doctor,“A system-on-chip development of a neuro–fuzzy embedded agent forambient-intelligence environments,” IEEE Trans. Syst., Man, Cybern.,B, Cybern., vol. 42, no. 2, pp. 501–512, Apr. 2012.

[15] W. Lang, F. Jakobs, E. Tolstosheeva, H. Sturm, A. Ibragimov, A. Kesel,et al., “From embedded sensors to sensorial materials—The road tofunction scale integration,” Sens. Actuators A, Phys., vol. 171, no. 1,pp. 3–11, 2011.

[16] S. Bosse, F. Pantke, and S. Edelkamp, “Robot manipulator with emergentbehaviour supported by a smart sensorial material and agent systems,”in Proc. SSI Conf., Mar. 2013.

[17] J. Liu, Autonomous Agents and Multi-Agent Systems. Singapore: WorldScientific, 2001.

[18] C. Muldoon, G. O’Hare, M. O’Grady, and R. Tyan, “Agent migra-tion and communication in WSNs,” in Proc. 9th PDCAT, Dec. 2008,pp. 425–430.

[19] R. Tynan, D. Marsh, D. O’Kane, and G. O’Hare, “Agents for wire-less sensor network power management,” in Proc. ICPP Workshops,Jun. 2005, pp. 413–418.

[20] H. Naji, “Creating an adaptive embedded system by applying multi-agent techniques to reconfigurable hardware,” Future Generat. Comput.Syst., vol. 20, no. 6, pp. 1055–1081, Aug. 2004.

Stefan Bosse studied physics at the University ofBremen. He received the Ph.D. degree in physicsfrom the University of Bremen, in 2002.

In 2004, he joined the Department of Mathemat-ics and Computer Science and the working grouprobotics. Since 2002, he has been involved in paralleland distributed systems, sensorial materials, circuitdesign, computer aided design, and artificial intel-ligence. Since 2008, he conducts and contributesto different projects in the ISIS Sensorial MaterialsScientific Centre pushing interdisciplinary research,

and recently joining the ISIS Council.He acts as a Reviewer for several international journals (ACM TODAES,

IEEE Sensors), is a Guest Editor of journals (IEEE Sensors, Elsevier Mecha-tronics), and a member of the international conference program and organizingcommittees (SysInt).

distributed agent based computing in material-embedded sensor network systems with the agent-on-chip...

Documents

agent processing architecture

agent interaction

agent processing system

parallel processing

overview embedded systems

processing constraints

parallel data processing

new data processing