A hybrid approach for Structural Monitoring with self-organizing
multi-agent systems and inverse numerical methods in
material-embedded sensor networks
Stefan Bosse
, Armin Lechleiter
University of Bremen, Dept. of Mathematics & Computer Science, Robert Hooke Str. 5, 28359 Bremen, Germany
article info
Article history:
Received 17 November 2014
Revised 24 July 2015
Accepted 23 August 2015
Available online 28 October 2015
Structural health monitoring
Sensor network
Mobile agent
Heterogeneous networks
Embedded systems
Inverse numerical computation
One of the major challenges in Structural Monitoring of mechanical structures is the derivation of mean-
ingful information from sensor data. This work investigates a hybrid data processing approach for
material-integrated structural health and load monitoring systems by using self-organizing mobile
multi-agent systems (MAS), and inverse numerical methods providing the spatial resolved load informa-
tion from a set of sensors embedded in the technical structure with low-resource agent processing plat-
forms scalable to microchip level, enabling material-integrated real-time sensor systems. The MAS is
deployed in a heterogeneous environment and offers event-based sensor preprocessing, distribution,
and pre-computation. Inverse numerical approaches usually require a large amount of computational
power and storage resources, not suitable for resource constrained sensor node implementations.
Instead, the computation is partitioned into spatial off-line (outside the network) and on-line parts, with
on-line sensor processing performed by the agent system. A unified multi-domain simulation framework
is used to profile and validate the proposed approach.
Ó 2015 Elsevier Ltd. All rights reserved.
1. Introduction
Structural Monitoring of mechanical structures allows to derive
not just loads by using Load Monitoring (LM), but also their effects
to the structure, its safety, and its functioning from sensor data,
offering some kind of Structural Health Monitoring (SHM). A load
monitoring system is a basic component of a SHM system, which
provides spatial resolved information about loads (forces,
moments, etc.) applied to a technical structure, with applications
ranging from robotics to building monitoring.
One of the major challenges in SHM and LM is the derivation of
meaningful information from sensor input. The sensor output of a
SHM or LM system reflects the lowest level of information. Beside
technical aspects of sensor integration the main issue in those
applications is the derivation of a information mapping function
Map(s, E): s E ? i that basically maps the raw sensor data input
s,an-dimensional vector consisting of n sensor values, on the
desired information i,am-dimensional result vector. The result
of the computed information commonly depends on some abstract
environmental setting E (see Fig. 1) arising in all technical systems,
i.e., the disturbance of data caused by communication, data
processing, energy supply, or temporal and spatial data
distribution. The goal of the mapping function it to reduce the data
dimension significantly, i.e., m n.
This work investigates a hybrid data processing approach for
material-integrated LM systems by using self-organizing and
event-driven mobile multi-agent system (MAS), with agent
processing platforms scaled to microchip level which offer
material-integrated real-time sensor systems, and inverse numer-
ical methods providing the spatially resolved load information
from a set of sensors embedded in the technical structure. Such
inverse approaches usually require a considerable amount of com-
putational power and storage resources, not very well matching
resource constrained sensor node implementations. Instead, off-
line computation is performed, with on-line sensor processing by
the agent system. Commonly off-line computation operates on a
continuous data stream requested by the off-line processing sys-
tem delivering sensor data continuously in fixed acquisition inter-
vals, resulting in high communication and computational costs. In
this work, the sensor preprocessing MAS delivers sensor data
event-based if a change of the load was detected (feature extrac-
tion), reducing network activity and energy consumption signifi-
cantly. Inverse numerical algorithms use matrix computations
extensively, so it is in principle possible to distribute and perform
0957-4158/Ó 2015 Elsevier Ltd. All rights reserved.
Corresponding author.
Mechatronics 34 (2016) 12–37
Contents lists available at ScienceDirect
journal homepage: www.elsevier.com/locate/mechatronics
some of the matrix computations in the sensor network offering an
on-line pre-computation by the MAS. This is a main advantage over
Machine Learning methods used in LM and SHM systems [1–3],
which are more difficult to distribute efficiently due to long dis-
tance data dependencies.
Basically there are two different information extraction
approaches for material-integrated LM systems and a possible
optimization of sensor positions: (I) Those methods based on a
mechanical and numerical model of the technical structure, the
Device under Test (DUT), and the sensor; (II) Those without any
or with a partial physical model. The latter class can profit from
artificial intelligence, which is usually based on classification algo-
rithms derived from supervised machine learning or pattern recog-
nition using, for example, self-organizing systems like multi-agent
systems with less or no a priori knowledge of the environment.
One common approach in SHM is the correlation of measured
data resulting from an induced stimuli at run-time (system
response) with data sets retrieved from an initial (first-hand)
observation, which makes it difficult to select damage relevant
features from the measurement results. Other variants are based
on statistical methods, data analysis using Fourier- or wavelet-
techniques, or neural network approaches. We refer to [4–8]
(Chapter 12) posing examples illustrating the variety of possible
Inverse methods generally belong to the first class of
approaches since they are based on a mechanical model T of the
technical structure mapping loads to sensor signals. In this study,
we consider measurements of surface strains and aim to compute
the associated spatially varying (discretized) loads l on the struc-
ture. The mechanical model T is gained from linear elasticity and
can, in a discretized setting, be represented by a matrix. Given a
sensor signal vector s (serialization of a two-dimensional sensor
matrix S, which is a approximately linear depending on the mea-
sured strain), inverse methods try to stably ‘‘invert”; the mapping
T, that is, to find a stable solution l to the problem Tl = s. Since mea-
sured signals and the underlying physical model always contain
numerical and modelling errors, inverse methods do not attempt
to find an exact solution to the latter equation. Indeed, inversion
problems, in particular those with incomplete data, are usually
extremely ill-conditioned, meaning that small errors in the signals
or the model lead to huge errors in any ‘‘solution”; gained by such a
naive approach. Instead, inverse methods try to stabilize the inver-
sion process, using, e.g., one of the following techniques:
A classical and well-known inversion method is Tikhonov regu-
larization. Pick amongst all approximated solutions to Tl = s the
one that minimizes a certain functional the simplest func-
tional to minimize would be the Tikhonov functional
l # Tl s
; ð1Þ
where a > 0 and kk
is the 2-norm of a vector defined by Eq.
(2), but different and more complicated variants exist and might
also be convenient choices. The latter vector norm is defined for
any dimension n 2 N and any vector
v ¼ðv
; ...; v
2 R
: ð2Þ
Alternatively, consider any iterative method that minimizes the
residual Tl s and stabilize the inversion by stopping the itera-
tion when the norm of the residual is about the magnitude of
the expected signal and modelling error. Examples for such iter-
ative techniques include the Landweber iteration, the conjugate
gradient iteration, but also recent soft shrinkage techniques, see
If the mechanical model T is linear, then the best known inver-
sion method in the first class is the Tikhonov regularization mini-
mizing the quadratic functional (Eq. (1)) by solving the equivalent
linear system (T
T +
)l = T
s, where T
denotes the transpose
matrix of T. The most powerful algorithm in the second class is,
arguably, the conjugate gradient iteration. The disadvantage of
inverse methods with regard to applications based on sensor net-
works usually is their cost in terms of computing time and memory
requirements which definitely is a drawback for material-
integrated SHM and LM systems. The possibly high computing
Fig. 1. Initially unknown external forces acting on a mechanical structure lead to an deformation of the material based on the internal forces. A material-integrated active
sensor network [22] composed of sensors, electronics, data processing, and communication, together with mobile agents can be used to monitor relevant sensor changes with
an advanced event-based information delivery behaviour. Inverse numerical methods can compute finally the material response. The unknown system response for
externally applied load l is measured by the strain sensor stimuli response s’ (a function of s), and finally inverse numerical methods compute an approximation l’ to the
applied load.
S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37
time and memory requirements for pre-computations before actu-
ally launching the monitoring device due to the physical and
numerical model are nowadays becoming less important due to
advanced numerical simulation methods and increasing computa-
tional power.
Reliable distributed data processing in sensor networks using
multi-agent systems (MAS) were recently reported in [11] and
employed for SHM applications in [12]. An adaptive and learning
behaviour of MAS, which is a fundamental principle in the agent
model, can aid to overcome technical unreliability and limitations
[13]. Artificial intelligence and machine learning can be used in
sensorial materials without a predictive mechanical model at hand
[1], which is a definite advantage for complex materials.
Multi-agent systems can be used for a decentralized and self-
organizing approach of data processing in a distributed system like
a sensor network (that is already applied in macro-scale applica-
tions, e.g., in [14]), enabling information extraction, for example,
based on pattern recognition [15], by decomposing complex tasks
in simpler cooperative agents.
In this work the behaviour of mobile agents is related to a state
and is modelled with an activity-transition graph (ATG) which is
implemented with the Activity-based Agent Programming Lan-
guage AAPL [16]. An activity is related with a state and actions per-
formed by activating an activity by a transition.
AAPL models can be compiled to various agent processing plat-
form architectures including programmable code-based stack
machines [17] and non-programmable, part of each sensor node.
The non-programmable agent processing platform implements
the ATG behaviour directly [16], enabling very low-resource single
microsystem platforms. In the case of the programmable agent
platform the program code implements the agent behaviour
entirely. The ATG can be modified at run-time by the agent itself
using dedicated AAPL transformation statements [18]. By using
program code that is executed on a Virtual Machine (VM) this is
performed by code morphing techniques provided by the VM.
Agents carrying the code, data, and already applied modifications,
are capable to migrate in the network between nodes [18]. Both
processing platform architectures use token-based and pipelined
agent processing for optimized resource sharing and parallel
The programmable agent processing platform used for the exe-
cution of agents is a pipelined stack-based virtual machine, with
support for code morphing and code migration. This VM approach
offers small sized agent program code, low system complexity,
high data processing performance, and enables the support of
heterogeneous network ranging from microchips to the internet.
The agent platform VM can be implemented directly in hardware
with a System-on-Chip design. Agents processed on one particular
node can interact by using a tuple-space server provided by each
sensor node. Remote interaction is provided by signals carrying
data which can cross sensor node boundaries.
This approach provides a high degree of computational inde-
pendency from the underlying platform and other agents, and
enhanced robustness of the entire heterogeneous environment in
the presence of node, sensor, link, data processing, and communi-
cation failures. Support for heterogeneous networks considering
hardware (System-on-Chip designs) and software (microproces-
sor) platforms is covered by one design and synthesis flow includ-
ing functional behavioural simulation. For material-integration,
there is an application specific agent processing platform that
implements the agent behaviour on-chip, offering the lowest
resource and chip area requirements.
The mechanical model of the structure under investigation
allows in particular the pre-computation of a sufficiently accurate
discretization of the forward mapping T linking loads with mea-
sured signals. Moreover, this pre-computation allows to associate
to each sensor an individual signal level that might potentially
be critical for the entire structure.
Hence, when a load change that is potentially critical is detected
by one the material-integrated sensors, the signals measured by all
sensors are propagated to an exterior CPU. An alternative way is
that merely those sensors noting a critical load change start to
propagate their signals to the exterior CPU. The propagated signals
are then fed into a regularization scheme that is able to stably
invert signals into loads.
As discussed above, Tikhonov regularization is a feasible regu-
larization scheme, computing an approximation to the true load
as solution to the linear system
T þ
Þl ¼ T
s þ
; ð3Þ
where T
denotes the transpose of T. The solution to this system is
hence computed rapidly with low cost if one is able to pre-compute
a singular value decomposition of the matrix T. The disadvantage of
this inversion scheme is that reconstructions of discontinuous
loads, in particular with small support, are smoothed out which
makes the precise location of the support of a load difficult. Several
iterative inversion techniques such as the steepest descent method
or the conjugate gradient method applied to T
Tl = T
g avoid this
disadvantage. Further, they merely require the ability to compute
matrix–vector products and a (cheap stopping) rule to stabilize
the inversion. The class of iterative inversion methods also includes
the so-called Landweber iteration and its variant, the so-called iter-
ative soft shrinkage. The disadvantage of the latter two techniques
is their slow convergence, and the huge number of iterations are
necessary to compute accurate inversions [9,19].
Combining Self-organizing Multi-Agent Systems (SoMAS) and
event-based sensor data distribution with inverse numerical meth-
ods into a hybrid data processing approach has several advantages:
First, the (possibly distinct) critical level for an individual sensor
signal can be pre-computed for each sensor position individually.
Second, depending on the a priori knowledge on the expected loads
on the structure, a suitable regularization technique can be chosen
as inversion method, promoting specific features of the expected
loads. Third, the sensor positions themselves might well be opti-
mized with respect to the last two points, aiming for sensor posi-
tions that maximize the detectability of critical loads and/or
sensor positions that maximize the quality of load reconstructions
from sensor signals.
This work introduces some novelties compared to other data
processing and agent platform approaches and previously pub-
lished work [16,18,17,20]:
Complete multi-domain simulation of large-scale multi-agent
systems, sensor networks, and numerical computation with a
unified database centric simulation environment.
Sensor signal preprocessing at run-time inside the sensor net-
work by using multi-agent systems. Event-based sensor data
distribution and pre-computation with agents reduces commu-
nication and overall network activity resulting in reduced
energy consumption.
Agent mobility crossing different execution platforms in mesh-
like networks and agent interaction by using tuple-space data-
bases and global signal propagation aid solving data distribu-
tion and synchronization issues in the design of distributed
sensor networks connected to generic computer networks and
the Internet.
Enhanced inverse numeric improving stability and accuracy is
used to compute the load for a structure from noisy and incom-
plete sensor data.
An advanced on- and off-line processing with off-line inverse
numerical computation of mechanical loads form on-line pre-
processed sensor data allows the determination of the system
14 S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37
response. FEM simulation is used to 1. Retrieve the inverse
numeric for real-world sensing system; and 2. For the creation
of synthetic sensor data of the technical structure in simulation.
Rigorous analysis and evaluation of the load computation for a
structure with temporal and spatial disturbed or incomplete
sensor input data. Temporal disturbance is caused by data dis-
tribution latencies, and spatial disturbance is caused by techni-
cal failures in the sensor network (e.g., communication failures).
The next sections summarize the activity-based agent process-
ing model, available mobility and interaction, and the used agent
processing platform architecture related to the programming
model. A summarized description of the sensor signal processing
algorithms and a rigorous description of the proposed inverse
numerical methods for load computations are following, which
are profiled and validated with an extensive simulation framework.
2. Agent behaviour model
The agent behaviour is composed and modelled with an activity
graph, with activities representing the control state of the agent rea-
soning engine, and conditional transitions connecting and enabling
activities, shown in Fig. 2 (detailed description in [16,20]). Activities
provide a procedural agent processing by sequential execution of
imperative data processing and control statements.
The activity-graph based agent model is attractive due to the
proximity to the finite-state machine model, which simplifies the
hardware implementation, but still enabling efficient software
An activity is activated by a transition which can depend on a
predicate as a result of the evaluation of (private) agent data
related to a part of the agents belief in terms of Belief-
Desire-Intention (BDI) architecture. An agent belongs to a specific
parameterizable agent class AC, specifying the behaviour, local
agent data (only visible for the agent itself), types, signals, activi-
ties, signal handlers, and transitions.
The class AC can be composed of sub-classes, which can be inde-
pendently selected. Plans are related to AAPL activities and transi-
tions close to conditional triggering of plans.
This reactive behaviour can be summarized to the following
operational semantic:
Procedural data processing takes place in activities computing
and changing private and global data.
Transitions between activities represent the progress and the
external visible change of the control state of an agent. Transi-
tions can be conditional depending on the evaluation of agent
Body variables of an agent are private data only visible to the
specific agent. The data content of body variables are mobile
and can be inherited by forked child agents.
Each agent owns a public set of agent parameters initialized on
agent creation.
Global data is exchanged by using a tuple database and syn-
chronized and atomic read, test, remove, and write operations.
Agents can migrate between different physical and spatially dis-
tinguished execution platforms by preserving and transferring
the control and data state of the agent.
The agent behaviour can be either implemented directly by the
processing platform (application specific and static platform
class) or can be implemented with program code executed by
a generic agent processing platform (dynamic platform class).
Agents can be created at run-time, regardless of the platform
class. Agents can inherit the control and data state from parent
agents (forking behaviour).
Agents can communicate and synchronize peer-to-peer by using
signals, which can be delivered to remote execution nodes, too.
Fig. 2. Agent behaviour programming level with activities and transitions (AAPL, left); agent class model and activity-transition graphs (top); agent instantiation, processing,
and agent interaction on the network node level (right) [17].
S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37
A short notation of AAPL used to specify the agent behaviour in
this work is presented in Appendix A.
3. Agent processing platform
There are two different agent processing platforms capable of
processing of the mobile agents used in this work: a non-
programmable and a programmable platform architecture. The
non-programmable platform implements the agent behaviour for
different agent classes directly, whereas the programmable plat-
form provides generic agent processing of program code supplied
externally which implements the agent behaviour of a particular
agent class. Both platforms can be implemented entirely on hard-
ware (SoC), or software, or simulation model level. All implemen-
tations of each platform class can be deployed and connected in
a heterogeneous network environment, shown in Fig. 3. They are
compatible on operational and interface level. That means agents
can migrate between different platform implementations and dif-
ferent host environments. The simulation of MAS can be based
on a pure behavioural model (BSIM) by simulating the agents itself
or based on an architectural model by simulating the agent pro-
cessing platform (PSIM) using agents.
Table 1 compares the characteristics and the advantages/disad-
vantages of both platform architectures. Fig. 3 shows the modelling
and synthesis of agent platforms from a common model and pro-
gramming sources.
4. Sensing with multi-agent systems
Large scale sensor networks with hundreds and thousands of
sensor nodes require smart data processing concepts far beyond
the traditional centralized approaches. Multi-Agent systems can
be used to implement smart and optimized sensor data processing
in these distributed sensor networks.
In this work, three different data processing and distribution
approaches are used and implemented with agents, leading to a sig-
nificant decrease of network processing and communication activity
and a significant increase of reliability and the Quality-of-Service:
1. An event-based sensor distribution behaviour is used to deliver
sensor information from source sensor to computation nodes.
2. Adaptive path finding (routing) supports agent migration in
unreliable networks with missing links or nodes by using a
hybrid approach of random and attractive walk behaviour.
3. Self-organizing agent systems with exploration, distribution,
replication, and interval voting behaviours based on feature
marking are used to identify a region of interest (ROI, a collec-
tion of stimulated sensors) and to distinguish sensor failures
(noise) from correlated sensor activity within this ROI.
It is assumed that sensor nodes arranged in a two-dimensional
grid network (as shown in Fig. 4) providing spatially resolved and
distributed sensing information of the surrounding technical struc-
ture, for example, a metal plate. Each sensor node shall sense
mechanical properties of the technical structure nearby the node
location, for example, by using strain gauge sensors. Usually a sin-
gle sensor cannot provide any meaningful information of the
mechanical structures. A connected area of sensors (complete sen-
sor matrix or a part of it) is required to calculate the response of the
material due to applied forces. The computation of the material
response requires high computational power of the processing
unit, which cannot offered by down-scaled single micro-chip plat-
forms. For these reasons, sensor nodes use mobile agents to deliver
their sensor data to dedicated computational nodes located at the
edges of the sensor network, shown in Fig. 4, discussed in detail in
the following sub-sections. The computational nodes arranged at
the outside of the network are further divided in pre-
computation and the final computation nodes (the four nodes
located at the corners of the network). The pre-computational
nodes can be embedded PCs or single micro-chips, and the compu-
tational nodes can be workstations or servers physically displaced
from the material-embedded sensor network. Only the inner sen-
sor nodes are micro-chip platforms embedded in the technical
structure material, for example, using thinned silicon technologies.
4.1. Event-based sensor data processing with agents
The computation of the system response information requires
basically the complete sensor signal matrix S. In traditional sensor
signal processing networks this sensor matrix is updated in regular
time intervals, resulting in a high network communication and
sensor node activities. In this approach presented here the ele-
ments of the sensor matrix are only updated if a significant change
of specific sensors occurred. Only the four corner computational
nodes store the complete sensor matrix and perform the inverse
numerical computations, explained in Section 6.
The sensor processing uses both stationary (non-mobile) and
mobile agents carrying data, illustrated in Fig. 5 on the left side.
Fig. 3. Different agent processing platform architectures and implementations, but a common agent behaviour model and programming sources. (PCSP: Pipelined
Communicating Sequential Processes, PAVM: Pipelined Agent Forth Virtual Machine, ATG: Activity-Transition Graph, AAPL: Agent Programming Language, HWS: Hardware
Synthesis, SWS: Software Synthesis, PSIM: Platform Simulation, BSIM: Behavioural Agent Simulation).
16 S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37
There are two different stationary (non-mobile) agents operating
on each sensor node: the sampling agent which collects sensor
data, and the sensing agent, which pre-processes and interprets
the acquired sensor data. If the sensing agent detects a relevant
change in the sensor data, it sent out four mobile event agents,
each in another direction. The event agent carries the sensor data
and delivers it to the pre-computation nodes at the boundary of
the sensor network. The agent behaviour is specified in Algorithm
2 in Appendix A, and an overview of the agent behaviour and the
ATG can be found in Fig. 5 on the right side.
An event agent has a pre-defined path in the direction dir which
is followed by the move activity as long as there is connectivity to
the next neighbour node in this direction. Normally the agent trav-
els to the outside of the network on the given direction by applying
the route_normal routing strategy successfully. If it is not possi-
ble to migrate in the pre-defined direction, an alternative path is
chosen by using the route_opposite routing strategy, which
chooses a path away from the original destination to bypass not
connected nodes and missing communication links. Using the
route_relax routing strategy the agent is directed again to the
original planned path. Making routing decisions and migration
are performed in the move activity of the agent, followed by the
check activity which collects sensor data from the current node
and checks the destination node goal, and if reached delivering
the sensor values in the deliver activity.
Each pre-computation node stores a row or a columns of the
sensor matrix S. If their data changes, the pre-computation nodes
will sent out two mobile distribution agents in opposite directions,
delivering a row or column of S to the final computation nodes,
located at the edges of the sensor network.
4.2. Self-organizing MAS and feature recognition
The event-based sensor data distribution relies on well operating
sensors and trustful sensor values. Faulty or noisy sensors can
disturb the further data processing algorithms (inverse numeric)
significantly and should not delivered to the computational nodes.
Usually sensor values are correlated within a spatially bounded
region. The goal of the following MAS is to find the outline of
extended correlated regions of increased sensor stimuli which can
be distinguished from the neighbourhood. For example, strain
gauge sensors which deliver information about mechanical distor-
tion of a material resulting from externally applied load forces. A
single stimulated sensor cannot be a result from a mechanical load.
To find such a correlated stimulated sensor region, a distributed
directed diffusion behaviour and self-organization (see Fig. 6) are
used, derived from the image feature extraction approach
(proposed by [15]). A single sporadic sensor activity not correlated
with the surrounding neighbourhood should be distinguished from
an extended correlated region by marking nodes nearby the bound-
ary of the region, which is the feature to be detected (edge detector).
Sensor nodes detecting a significant change of their sensor val-
ues send out explorer agents which perform the feature detection
and marking. Sensors nodes sending out the feature recognition
agents but get no markings can decrease a trust probability for
their sensor values for further assessment and activity planning.
The feature detection is performed by the mobile exploration
agent, which supports three main different behaviours: explo-
ration, diffusion, and reproduction. The diffusion behaviour is used
to move into a region, mainly limited by the lifetime of the agent,
and to detect the feature, here the region with increased
mechanical distortion (more precisely the edge of such an area).
The detection of the feature enables the reproduction behaviour,
which induces the agent to stay at the current node, setting a
feature marking and sending out more exploration agents in the
neighbourhood. The local stimuli H(i
, j) for an exploration agent
to mark a specific node with the coordinate (i, j) is given by Eq. (4).
Hði; jÞ¼
v ¼R
f sði þ u; j þ
Þsði; jÞ
6 dg
s : SensorSignalStrength
R : SquareRegionaroundði; jÞ
Table 1
Comparison of both agent processing platform architectures and their implementations (PCSP: Pipelined Communicating Sequential Processes, PAVM: Pipelined Agent Forth
Virtual Machine).
Programmable PAVM Non-programmable PCSP
Approach Program code based approach
Data is embedded in code
Zero-operand instruction format
Stack memory centric data processing model
Platform is generic
Code embeds instructions, configuration (control state), and data
Migration: code transfer
Application-specific approach
Platform is application-specific
Activities of the ATG are mapped to processes
Token-based agent processing
ATG reconfiguration by switching token channel paths
Migration: data and control state transfer (including configuration
Hardware Optimized Multi Stack Machine
Each stack processor is attached to a local code segment and two stacks
shared by all agents. There is no data segment!
Single SoC Design
Multiprocessor architecture with distributed and global shared code
Multi-FSM RTL hardware architecture
Automatic Token-based agent process scheduling and processing
Code morphing capability to modify agent behaviour and program code
(ATG modification)
Data- and code word sizes can be parameterized
Pipelined Communicating Processes Architecture composition imple-
menting ATG and token-based agent processing
Single SoC Design
Optimized resource sharing only one PCSP for each agent class
implementation required
Activity process replication for enhanced parallel agent processing
For each agent class there is one PCSP with attached data memory
(agent data)
Single SoC Design
LUT configuration matrix approach for ATG reconfiguration
Software Multi-Threading or Multi-Process software architecture
Inter-process communication: queues
Software model independent from programming language
VM sources for various programming languages: C, ML, Javascript, ...
Can be embedded in existing software
Multi-Threading software architecture
Optimization: Functional composition and implementation of ATG
behaviour instead PCSP
Interprocess-communication: queues
Software model independent from programming language
Source code for various programming languages: C
, ML, ...
Can be embedded in existing software
Simulation Agent-based Platform simulation
Generic simulation model can execute machine code directly
Processor components and managers are simulated with agents
Agent-based platform simulation
Application-specific simulation model
ATG activity processes are simulated with agents
S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37