EURASIP Journal on
Embedded Systems
Brinkschulte EURASIP Journal on Embedded Systems
(2017) 2017:23
DOI 10.1186/s13639-016-0066-2
RESEARCH Open Access
Prototypic implementation and
evaluation of an artificial DNA for
self-descripting and self-building embedded
systems
Uwe Brinkschulte
Abstract
Embedded systems are growing more and more complex because of the increasing chip integration density, larger
number of chips in distributed applications, and demanding application fields (e.g., in cars and in households).
Bio-inspired techniques like self-organization are a key feature to handle this complexity. However, self-organization
needs a guideline for setting up and managing the system. In biology the structure and organization of a system is
coded in its DNA. In this paper we present an approach to use an artificial DNA for that purpose. Since many
embedded systems can be composed from a limited number of basic elements, the structure and parameters of such
systems can be stored in a compact way representing an artificial DNA deposited in each processor core. This leads to
a self-describing system. Based on the DNA, the self-organization mechanisms can build the system autonomously
providing a self-building system. System repair and optimization at runtime are also possible, leading to higher
robustness, dependability, and flexibility. We present a prototypic implementation and conduct a real-time evaluation
using a flexible robot vehicle. Depending on the DNA, this vehicle acts as a self-balancing vehicle, an autonomous
guided vehicle, a follower, or a combination of these.
Keywords: Artificial DNA, Prototypic implementation, Evaluation, Real-time, Self-organization, Self-building,
Self-description
1 Introduction
Embedded systems are growing more and more complex
because of the increasing chip integration density, larger
number of chips in distributed applications, and demand-
ing application fields (e.g., in cars and in households).
In the near future, it will become reality to have thou-
sands of computing nodes within an embedded system.
Bio-inspired techniques like self-organization are a key
feature to handle this complexity. We have developed the
Artificial Hormone System (AHS) as a decentralized, self-
organizing, self-healing, and self-optimizing mechanism
to assign tasks to computing nodes of an embedded real-
time system. The AHS is able to handle task assignment
Correspondence: brinks@es.cs.uni-frankfurt.de
Institut für Informatik, Johann Wolfgang Goethe Universität Frankfurt,
Frankfurt, Germany
in complex embedded systems with a large number of
processor cores.
However, to do so the AHS needs a blueprint of the
structure and organization of the embedded application.
This covers the segmentation of the application into tasks,
the cooperation and communication between these tasks,
the suitability of the processor cores for each of these
tasks, etc. Currently, these assignments are done manu-
ally by the system developer, but in the future this is no
longer feasible for large embedded systems having a large
number of cores and tasks.
The idea is to follow again a bio-inspired principle.
In biology the structure and organization of a system is
codedinitsDNA.Thiscanbeadoptedtoembedded
systems. The blueprint of the structure and organiza-
tion of the embedded system will be represented by an
artificial DNA. The artificial DNA can be held compact
and stored in every processor core of the system (like
© The Author(s). 2017 Open Access This article is distributed under the terms of the Creative Commons Attribution 4.0
International License (http://creativecommons.org/licenses/by/4.0/), which permits unrestricted use, distribution, and
reproduction in any medium, provided you give appropriate credit to the original author(s) and the source, provide a link to the
Creative Commons license, and indicate if changes were made.
Brinkschulte EURASIP Journal on Embedded Systems
(2017) 2017:23
Page 2 of 16
the biological DNA is stored in every cell of an organ-
ism). This makes the system self-descripting and enables
a maximum amount of robustness and flexibility. Now, a
mechanism like the AHS can transcribe the artificial DNA
to set up and operate the embedded system accordingly.
All the needed information for such a process like task
structure, cooperation, communication, and core suitabil-
ity can be derived from the artificial DNA. Therefore, the
system becomes self-building based on its DNA.
In our previous work [1], we have developed a DNA
simulator as a proof of concept. Now we present a pro-
totypic implementation which enables real applications.
Furthermore, we conduct an evaluation of real-time prop-
erties, robustness, and communication and memory use
based on a flexible robotic vehicle platform. Depending on
the DNA, this vehicle acts as a self-balancing vehicle, an
autonomous guided vehicle, a follower, or a combination
of these.
The paper is structured as follows: After the intro-
duction and motivation, related work is presented in
Section 2. Section 3 describes the basic ideas and concep-
tion of the artificial DNA. The prototypic implementation
is described in Section 4; Section 5 presents the evaluation
results while Section 6 concludes this paper.
2 Related work
Self-organization has been a research focus for several
years. Publications like [2] or [3] deal with basic princi-
ples of self-organizing systems, e.g., emergent behavior,
reproduction, etc. Regarding self-organization in com-
puter science, several projects and initiatives can be listed.
IBM’s and DARPAS’s Autonomic Computing project
[4, 5] deals with self-organization of IT servers in
networks. Several so-called self-X properties like self-
optimization, self-stabilization, self-configuration, self-
protection, and self-healing have been postulated. The
MAPE cycle consisting of Monitor, Analyze, Plan, and
Execute was defined to realize these properties. It is exe-
cuted in the background and in parallel to normal server
activities similar to the autonomic nervous system.
The German Organic Computing Initiative was founded
in 2003. Its basic aim is to improve the controllability of
complex embedded systems by using principles found in
organic entities [6, 7]. Organization principles which are
successful in biology are adapted to embedded comput-
ing systems. The DFG priority programme 1183 “Organic
Computing” [8] has been established to deepen research
on this topic.
Self-organizing and organic computing is also followed
on an international level by a task force of the IEEE Com-
putational Intelligence Society (IEEE CIS ETTC OCTF)
[9]. Several other international research programs have
also addressed self-organization aspects for computing
systems, e.g., [10, 11].
Self-organization for embedded systems has been
addressed especially at the ESOS workshop [12]. Further-
more, there are several projects related to this topic like
ASOC [13, 14], CARSoC [15, 16] or DoDOrg [17]. In
the frame of the DoDOrg project, the Artificial Hormone
System (AHS) was introduced [17, 18]. Another hormone-
based approach has been proposed in [19]. Nicolescu and
Mosterman [20] describe self-organization in automotive
embedded system. None of these approaches deal with
self-description or self-building using DNA-like struc-
tures.
DNA computing [21] uses molecular biology instead
of silicon-based chips for computation purposes. In [22],
e.g., the traveling salesman problem is solved by DNA
molecules. Our approach relies on classical computing
hardware using DNA-like structures for the description
and building of the system. This enhances the self-
organization and self-healing features of embedded sys-
tems, especially when these systems are getting more and
more complex and difficult to handle using conventional
techniques. Our approach is also different from generative
descriptions [23], where production rules are used to pro-
duce different arbitrary entities (e.g., robots) while we are
using DNA as a building plan for a dedicated embedded
system.
TorealizeDNA-likestructures,wehavetodescribe
the building plan of an embedded system in a compact
way so it can be stored in each processor core. There-
fore, we have adapted well-known techniques like netlists
and data flow models (e.g., the actor model [24]) to
achieve this description. However, in contrast to such clas-
sical techniques, our approach uses this description to
build the embedded system dynamically at run-time in
a self-organizing way. The description acts like a DNA
in biological systems. It shapes the system autonomously
to the available distributed multi/many-core hardware
platform and re-shapes it in case of platform and environ-
ment changes (e.g., core failures, temperature hotspots,
reconfigurations like adding new cores, removing cores,
changing core connections, etc.). This is also a major
difference to model-based [25] or platform-based design
[26], where the mapping of the desired system to the
hardware platform is done by tools at design time (e.g.,
a Matlab model). Our approach allows very high flexi-
bility and robustness due to self-organization and self-
configuration at run-time while still providing real-time
capabilities.
3 Conception of the artificial DNA
In the following, the basic conception of the proposed
approach is explained in detail. It consists of the system
composition model, the structure of the artificial DNA,
and how a system is built from its artificial DNA.
Brinkschulte EURASIP Journal on Embedded Systems
(2017) 2017:23
Page 3 of 16
3.1 System composition model
The approach presented here is based on the observation
that in many cases embedded systems are composed of a
limited number of basic elements, e.g., controllers, filters,
arithmetic/logic units, etc. This is a well-known concept
in embedded systems design. If a sufficient set of these
basic elements is provided, many embedded real-time
systems could be completely built by simply combining
and parameterizing these elements. This fact is also
exploited in model-driven design, e.g., by constructing a
Matlab model. In our approach, we use it to generate a
compact description of the targeted embedded system
which can be stored in each processor core to serve as
a digital artificial DNA. As we show later, this enables
the self-building of the system at run-time including an
autonomous reaction to failures and changes in the envi-
ronment. Figure 1 shows the general structure of such a
basic element. This structure is influenced by the way
a middleware like the AHS handles tasks and provides
maximum flexibility as it allows active and reactive, data-
driven, and control-driven, uni- and bidirectional flow.
A task is basically a service having two possible types of
links to other services. The Sourcelink is a reactive link,
where the task reacts to incoming requests. It consists of
the two functions:
Sourcelink (the task acts as server)
GetRequest Looking for an incoming request
from others
SendResponse Sending a response to the requester
The Destinationlink is an active link, where the task
sends requests to other tasks. It consists of the two func-
tions:
Destinationlink (the task acts as client)
SendRequest Sending a request to others
GetResponse Looking for a response to the request
Each basic element is identified by a unique Id and a set
of parameters. The sourcelink and the destinationlink of
a basic element are compatible to all other basic elements
and may have multiple channels. Both links can be bidi-
rectional (in Fig. 1 the filled arrowhead indicates the active
Basic Element
Id
Parameters
Sourcelink
1 … n
Channels
Destinationlink
Channels
1 … m
Fig. 1 Structure of a basic element for system description
direction) or unidirectional. For elements with unidirec-
tional links an incoming request on the sourcelink has no
direct response but triggers an outgoing request on the
destinationlink. In that case the direction is the one given
by the filled arrowhead only. Figure 2 gives some examples
which all provide a unidirectional dataflow. The Id num-
bers are arbitrarily chosen here, it is important only that
they are unique. So, we see an arithmetic logic unit (ALU)
element with the Id = 1 and the parameter defining the
requested operation (minus, plus, mult, div, greater, ...).
The two input operands are given by channels 1 and 2 of
the sourcelink whereas the result is provided via a single-
channel destinationlink. Such an element is needed for
calculations in a dataflow, e.g., a setpoint comparison in a
closed control loop. Another element often used in closed
control loops is a PID controller. Here, this element has
the unique Id = 10 and the parameter values for P, I, D,
and the control period. Furthermore, it has a single uni-
directional sourcelink and destinationlink channel. Other
popular elements in embedded systems have a unidirec-
tional sourcelink or destinationlink only. Examples are
ALU
(Id = 1,parameter = op)
Sourcelink
Destinationlink
Arithmetic Logic Unit
PID
(Id = 10, parameters =
P,I,D, period
)
Sourcelink
PID Controller
Destinationlink
Sensor
(Id = 500, parameter =
resource, period)
Sensor Interface
Destinationlink
Actor
(Id = 600, parameter =
resource)
Sourcelink
Actor Interface
Constant
(Id = 70, parameter =
constant value, period)
Destinationlink
Constant Value Generator
1 … 2
1
1
1
1
1
1
Fig. 2 Sample basic elements with unidirectional links
Brinkschulte EURASIP Journal on Embedded Systems
(2017) 2017:23
Page 4 of 16
interfaces to sensors (Id = 500, the parameter resource and
period define the specific sensor and its sample period)
and actors (Id = 600, resource specifies the specific actor)
or a constant value generator (Id = 70, the parameters are
the output value produced and its period).
Embedded systems can be composed by using these
basic elements as building blocks. Figure 3 shows a very
simple example of a closed control loop based on the
basic elements mentioned above. An actor (defined by its
resource id, e.g., a motor) is controlled by a sensor (also
defined by its resource id, e.g., a speed sensor) applying a
constant setpoint value.
3.2 Artificial DNA
If a sufficient set of standardized basic elements with
unique Ids is available, an embedded system will no longer
be programmed, but composed by connecting and param-
eterizing these elements. An example extract of such a
set can be found in Section 4. In general, some hundreds
of these elements are usually adequate to compose many
kinds of embedded real-time systems. Typical elements
for different application fields are, e.g., known or can be
adapted from model-driven design approaches.
Using such a blueprint, the composition of an embed-
ded system can be stored in a very compact way
representing a kind of digital artificial DNA, since it can
be used to completely build up the system at run-time.
Furthermore, this DNA will be even small enough for
complexsystems(seeSection5)tobestoredineachpro-
cessor core like the biological DNA is stored in each cell.
In this way the embedded system becomes self-describing.
To create the artificial DNA, the blueprint is transformed
into a netlist of basic elements. Each line of the artificial
DNA contains the Id of a basic element, its connection
to other basic elements (by defining the corresponding
destinationlinks for each sourcelink of the basic element)
and its parameters:
Artificial DNA line = [Id Destinationlink Parameters]
The destinationlink description in an artificial DNA
line can be defined as the following set:
(Destinationlinkchannel:Destination.Sourcelinkchannel...)
Here, Destinationlinkchannel gives the channel num-
ber of the destinationlink, Destination refers to the line
of the basic element the destinationlink channel is con-
nected to and Sourcelinkchannel is the channel number
of the sourcelink channel of the destination element. As
an example, the destinationlink description (1:10.1 1:9.2
2:7.1) defines that channel 1 of the destinationlink is con-
nected to the sourcelink channel 1 of the basic element in
line 10 of the DNA (1:10.1) and to the sourcelink channel
2 of the basic element in line 9 (1:9.2) while channel 2 of
the destinationlink is connected to the sourcelink chan-
nel 1 of the basic element in line 7 (2:7.1). Figure 4 shows
the DNA of the system from Fig. 3 enriched with com-
ments (defined by //). More examples and a very memory
efficient format to store a DNA can be found in [1].
Even in case of a very special embedded system not
beingabletobecomposedfromthesetofstandardized
basic elements, special Ids for user/application specific
elements can be defined to solve this issue.
3.3 Building the system from its artificial DNA
Using the artificial DNA, the system now becomes self-
building at run-time. The DNA serves as the basis for the
middleware layer of the distributed embedded system to
setup and connect the system tasks. Figure 5 shows the
system architecture using a DNA builder and the AHS as
middleware layer. There, we call the processor cores of
the distributed system DNA processors. First, the DNA
builder parses the DNA and segments the system into
tasks. Each instance of a basic element becomes a task
in the embedded system. Second, the AHS tries to assign
tasks to the most suitable processor cores. Core suitabil-
ity is indicated by specific hormone levels [18]. With the
artificial DNA, the suitability of a processor core for a task
can be derived automatically by the DNA builder from the
ALU
(Id = 1, parameter = Minus)
PID
(Id = 10, parameters = P,I,D,
period)
Sensor
(Id = 500, parameters =
resource, period)
Actor
(Id = 600, parameter =
resource)
Constant
(Id = 70, parameter =
constant value, period)
1
1
1
1
1
1
1 2
Fig. 3 A closed control loop consisting of basic elements
Brinkschulte EURASIP Journal on Embedded Systems
(2017) 2017:23
Page 5 of 16
Fig. 4 DNA structure of the sample system
Id of the basic element representing the task and the fea-
tures of the processor core. As an example, a basic element
with Id = 10 (PID controller) performs better on a proces-
sorcorewithbetterarithmeticfeatureswhilememoryis
less important. So the appropriate hormone levels can be
calculated automatically by the DNA builder and assigned
to the AHS. Third, task relationship is also considered
for task assignment. The AHS tries to locate cooperat-
ing tasks in the neighborhood to minimize communica-
tion distances. This has to be indicated also by hormone
levels [18]. Using the artificial DNA, task relationship can
be derived automatically by the DNA builder from ana-
lyzing the destinationlink fields of the DNA lines. This
allows to set up the communication links between tasks
and to determine cooperating tasks. So the appropriate
hormone levels can be generated automatically. All steps
of this building process are linear in time with relation
to the number of basic elements n, so the overall time
complexity is
O(n).
Overall, the artificial DNA represents the blueprint that
enables the self-building of a system. In case of failures
1
or changes, the system can be autonomously restored or
readapted by the DNA which is present in each DNA
processor. This increases system robustness and depend-
ability. The time complexity for restoring or readapting
the system is also
O(n),wheren isthenumberofaffected
basic elements (e.g., the number of basic elements lost by
a crash of a DNA processor). The program code for the
basic elements used in the DNA can be stored in code
Local copy of
DNA
…
Local
instance of
AHS
DNA Processor
Task
1
Task
m
. . .
Local
instance of
DNA Builder
Local copy of
DNA
…
Local
instance of
AHS
DNA Processor
Task
1
Task
m
Local
instance of
DNA Builder
Fig. 5 System architecture
repositories distributed in the system. Even changes in the
DNA representing changes in the system composition or
parameters are possible at run-time providing maximum
flexibility.
4 Prototypic implementation
As a proof of concept, we first have implemented a simula-
tor for the DNA concept. The results have been published
in [1]. This simulator was focused on the ability of self-
building a system from its DNA and reconstructing it in
case of component failures. So the basic elements were
simply dummies in the DNA simulator which are allo-
cated to processor cores, interconnected, and visualized.
They provided no real functionality. However, simulation
results showed that these basic elements were properly
allocated and interconnected by the DNA so self-building
and self-repairing is possible.
Encouraged by these promising results, we have decided
to implement a real prototype of the DNA concept. In
this prototype, the basic elements provide real function-
ality (e.g., an ALU, a PID controller, etc.) and interaction
schemes, so working systems can emerge from a DNA.
This allows for a far better evaluation than the simulator
does. Communication and memory needs as well as real-
time properties can be investigated on a real application
example, see Section 5.
Figure 6 shows the detailed architecture of a real DNA
processor within the overall system architecture already
presented in Fig. 5. The currently active DNA is read
from a file by the processor front end consisting of the
DNA Processor Library and the DNA Processor Basic
Library. While the first one contains all processor and
OS-specific parts, the latter is platform independent and
provides generic processor-based functions like retrieving
hormone values for basic elements on a given processor
core (e.g., an ALU works better on a processor core with
strong arithmetic features and therefore deserves higher
hormone values to attract this basic element). This is
done in cooperation with the DNA Class Library which
implements all the basic elements. Table 1 shows the
basic elements realized in the prototypic implementation
of the class library. In addition to the elements already
mentioned in the previous section, there are elements to
multiplex and demultiplex data values, to limit data val-
ues, to define thresholds, switching levels and hysteresis
for data values. A complementary filter allows data fusion