Component Ensemble-based UML/MARTE Extensions for the Design of

Dynamic Cyber-Physical Systems

Nissaf Fredj

, Yessine Hadj Kacem

, Olfa Kanoun

and Mohamed Abid

CES Laboratory, ENIS, University of Sfax, Tunisia

Chair of Measurement and Sensor Technology, Chemnitz University of Technology, Germany

Keywords:

Open-ended CPS, MARTE, Component Ensemble, Closed-loop.

Abstract:

Cyber-Physical Systems (CPS) are open-ended distributed systems which incorporate autonomous compo-

nents that interact with clear responsibilities to fulﬁll a deﬁned objective. They are subject to several issues

related to the interaction between components and dynamic behavior of their status as well as real-time con-

straints. Their design requires effective modeling formalisms for functional veriﬁcation and real-time analysis

of CPS at early stages of development. Uniﬁed Modeling languages and especially the Modeling Analysis

of Real-Time and Embedded systems (MARTE) proﬁle fail to capture the dynamics of CPS. They focus on

individual components and are unable to provide such QoS guarantees. Moreover, they again assume static

component architectures, which effectively hinder their direct application in open-ended systems. In this re-

spect, we proposed to extend MARTE proﬁle with the concept of ensemble semantics for the design of a

dynamic grouping of CPS components. The objective is to save resources consumption such as battery life

and allow for scalable QoS guaranties. Moreover, the present approach proposes designs patterns for the spec-

iﬁcation of CPS closed-loop concerns which addresses the components composition, adaptation as well as the

veriﬁcation of system constraints.

1 INTRODUCTION

Cyber-physical systems consist of a large number of

devices that monitor and react to their environment

and interact with each other through input-output in-

terfaces. They are complex and subject to numerous

constraints due to their environment mobility and re-

sources ﬂuctuation (Bradai et al., 2020). As a result,

there is a necessity to evaluate system output qual-

ity at an early stage of development to obtain reli-

able systems which permit an efﬁcient and fast re-

action to the environment ﬂuctuations. Lightening

the task of CPS designers and raising the abstraction

level have become prominent solutions to cope with

their complexity and avoid executions problems. To

do so, several research studies tried to exploit mainly

the modeling languages such as the UML/MARTE

proﬁle and component-based methods to specify and

develop open-ended dynamic CPS. However, stan-

dard techniques (Fredj et al., 2020) do not address

the dynamic and cooperative aspects of CPS compo-

nents. Such works which deal with high-level speciﬁ-

cations of adaptation of real-time and embedded sys-

tems (FREDJ et al., 2018), do not support the interac-

tion between dynamic components which is essential

in open-ended applications. On the other hand, com-

ponent ensemble-based works (Masrur et al., 2017)

(Crnkovic et al., 2011), which allow modeling large-

scale dynamic systems by a set of interacting compo-

nents, do not provide a basis for specifying the adap-

tation and runtime requirements. Besides, they fail to

capture the dynamic CPS at a high-level of abstrac-

tion and provide reusable and generic solutions. To

address the above issues, we propose an extension in

MARTE proﬁle to support the concepts of component

ensemble which are required to specify the interaction

between dynamic components of CPS. This innova-

tive extension enhance MARTE proﬁle to support the

design of dynamic open-ended CPS at a high-level

of abstraction. Moreover, the present work aims at

specifying the closed-loop concerns for dynamic sys-

tems based on proposed design patterns as generic

and reusable solutions to enhance the separation of

concerns and improve system modularity. The pro-

posed patterns cope with the composition between

components, monitoring and adaptation logic which

are responsible for specifying dynamic open-ended

CPS.

The present proposal is evaluated through an Intelli-

gent Crossroad System (ICS). Section 2 surveys the

related works about the high-level design and compo-

nent ensemble-based approaches for the speciﬁcation

158

Fredj, N., Kacem, Y., Kanoun, O. and Abid, M.

Component Ensemble-based UML/MARTE Extensions for the Design of Dynamic Cyber-Physical Systems.

DOI: 10.5220/0010546401580166

In Proceedings of the 16th International Conference on Software Technologies (ICSOFT 2021), pages 158-166

ISBN: 978-989-758-523-4

of dynamic open-ended CPS and the evaluation of

system performance. Section 3 presents the proposed

extensions and the closed-loop patterns. In section

4, an illustration of the proposal through the ICS ex-

ample is described. Finally, section 5 concludes this

work.

2 RELATED WORKS

We classify the state-of-the-art studies about the high-

level methods, which emerged in the context of dy-

namic Cyber Physical Systems (CPS) design. In par-

ticular, we discuss their support for cooperative and

adaptive architecture as well as real-time analysis.

2.1 Component Ensemble-based

Approaches for Developing

Dynamic Open-ended Systems

Most of works in (Bures et al., 2013) (Crnkovic et al.,

2011) were built based on the concept of compo-

nent ensemble. They deﬁne an ensemble as the se-

mantic interaction between components and consti-

tute their composition. The DEECo (Crnkovic et al.,

2011) framework allows modeling closed-loop-based

dynamic systems and provides mechanisms to de-

scribe interactions between them. The components

dynamically join an ensemble at runtime, which de-

scribes the components on the basis of their roles, as

one component has a coordinator role and other are

members. They consist of knowledge which reﬂects

its current state and have a set of processes that ma-

nipulate their knowledge. Then, the dynamic interac-

tion between the coordinator and members consists

in exchanging attribute values according to knowl-

edge description. Thereby, the work of (Masrur et al.,

2017) proposed a design methodology based on the

concept of ensemble and focus on the autonomous be-

havior, adaptation and components collaboration. In

fact, they extended the DEECO framework (Crnkovic

et al., 2011) to guarantee real-time behavior and con-

straints analysis. Previous works (Crnkovic et al.,

2011) (Bures et al., 2013) (Masrur et al., 2017) have

allowed reasoning about real-time requirements and

provided deterministic semantics for real-time anal-

ysis and distributed collaboration of CPS. However,

they present a set of challenges. First, DEECO closed

loop concerns are either mixed with the system func-

tional logic, thus add complexity to the knowledge

adaptation process and lucks reusability. Besides, the

adaptation of components knowledge and real-time

analysis were supported at a low-level and dependent

on the target system. Finally, previous component-

based designs methods have failed to capture the dy-

namic CPS at a high-level of abstraction. They do

not provide reusable and generic solutions which are

independent from any system. Therefore, developing

such complex systems using approaches that handle

technical details at low-level, is no more an efﬁcient

solution.

2.2 High-level-based Approaches for the

Design of Dynamic Real-time

Systems

Recently, there is a clear trend to use high-level mod-

els for the design and development of complex dy-

namics systems. Several research studies adopted

the system abstraction as an optimal way to improve

adaptive and distributed systems design (Beux, 2007)

by using model-based methods and UML proﬁles.

An UML extension has been implemented in the

form of MAFRTE proﬁle, which is often the most

adapted to the design of real-time and embedded sys-

tems (Fredj et al., 2020). A model-based process

for dynamic reconﬁguration in distributed real-time

systems was proposed in (Krichen et al., ). The so-

lution is based on a non-predeﬁned set of conﬁgu-

rations speciﬁed by new extensions in MARTE and

meta-models. The dynamic reconﬁgurable system is

modeled by a set of modes each of which is associ-

ated with a conﬁguration described by a set of com-

ponents and connections between them. In (Corsaro

et al., 2002), the author proposed a virtual compo-

nent pattern, which permits the adaptation of a dis-

tributed application to the embedded systems’ mem-

ory constraints. The work in (IGLESIA and WEYNS,

2015) proposed a formal speciﬁcation-based template

of distributed self-adaptive mobile learning applica-

tion which makes the system robust to the GPS ac-

curacy degrading. The self-adaptation is based on a

MAPE (Monitor, Analyzer, Planner, and Executer)

control loop for distributed mobile applications. The

weakness of this work is that the veriﬁcation tem-

plate is speciﬁc to the functionality of the proposed

use case. In (Arcaini et al., 2015), the authors pre-

sented a framework to formally model and verify the

distributed self-adaptive systems using the concept of

multi-agent ASM (Abstract State Machines). Their

work supports techniques for the validation and veri-

ﬁcation of adaptation scenarios, as well as the correct-

ness of the adaptation logic. The authors in (FREDJ

et al., 2018) proposed an extension in MARTE pro-

ﬁle to design the runtime behavior of adaptive real-

time systems. It offers a well-structured support to

extend the UML/MARTE proﬁle with runtime and

Component Ensemble-based UML/MARTE Extensions for the Design of Dynamic Cyber-Physical Systems

159

reconﬁguration semantics and nonfunctional proper-

ties. This work was extended in (Fredj et al., 2020)

where the proposed extensions were integrated in a

model-based development process for the analysis of

adaptive real-time system behavior and system con-

straints (energy consumption and task deadlines). Un-

fortunately, MARTE extensions-based works (FREDJ

et al., 2018) (Fredj et al., 2020) assume closed compo-

nent architectures, which effectively prevent their ap-

plication in case of dynamic CPS development. Fur-

thermore, previous works fail to target open-ended

CPS requirements where components interact one an-

other and their architecture changes continuously at

runtime.

We derived from the state-of-the-art studies the weak-

ness of the existing methods for the design and the

analysis of dynamic cyber-physical systems. Most

of studied approaches (Crnkovic et al., 2011) (Mas-

rur et al., 2017) proposed component-based solu-

tions to address cyber-physical applications require-

ments and support dynamic interaction between com-

ponents. These solutions are not abstract enough and

fail to address adaptation and communication require-

ments as well as real-time analysis at an abstract level

for an early veriﬁcation of the system. In this respect,

the approaches of (FREDJ et al., 2018) (Arcaini et al.,

2015) (IGLESIA and WEYNS, 2015) (Fredj et al.,

2020) provided promising solutions to raise the ab-

straction level and cope with the complexity of low-

level adaptation tools. Unfortunately, they proposed

solutions which largely fail to address the require-

ments of distributed adaptive systems. This is mostly

because they are unable to model an open-ended sys-

tem, in which cooperative components interact with

one another to adapt to the current state of its envi-

ronment.

3 OUR PROPOSAL

We derived from the state-of-the-art studies the weak-

ness of the existing methods and tools for the design

and the analysis of dynamic cyber-physical systems.

They do not operate at a high-level of abstraction and

provide sufﬁcient means to model interracting com-

ponents behavior, adaptation logic, and real-time con-

straints. To address the above issue, we propose to ex-

tend MARTE proﬁle by the concepts of ensemble to

support the interaction between system components

and allow reasoning about dynamic systems behavior

and runtime semantic of CPS. Moreover, we propose

two design patterns as generic and reusable solutions

for the speciﬁcation of DEECO closed-loop concerns

for the interaction between dynamic components of

CPS. This helps to separate both the adaptation logic

and components composition features from functional

system logic. The ﬁrst design pattern focuses on mon-

itoring of components adaptation changes. The sec-

ond pattern describes the composition between com-

ponents based on the concept of ensemble. and the as-

sessment of closed-loop parameters (such as ensem-

ble evaluation and computation delays) based on a set

of metrics. The patterns are independent from target

low-level tools to enhance the separation of concerns

and improve system modularity. More precisely, they

focused on the adaptation behavior and interaction of

systems components as well as the analysis of real-

time constrains.

In what follows, we will present the proposed exten-

sions in MARTE proﬁle for designing dynamic and

adaptive CPS. Afterwards, we will introduce the spec-

iﬁcation of the closed-loop based design patterns. Fi-

nally, we will illustrate the proposed extensions and

closed-loop patterns through ICS case study.

3.1 Component Ensemble Extensions in

MARTE Proﬁle for the Design of

CPS

The proposed extension was introduced as a

new package which extends the Software Re-

source Modeling (SRM) package of MARTE and

uses stereotypes from the MARTE:RuntimeContext,

MARTE:Timed Element, Causality package and

MARTE:Communication package. More precisely,

we need four sub-proﬁles of MARTE. First, since we

are interested in cyber-physical systems composed of

adaptive components which are managed by real-time

tasks named process, we use concepts from the SRM

(Software Resource Modeling) package of MARTE.

SRM is a specialization of the Generic Resource

Modeling (GRM) package to describe the structure

of the system which is composed of software multi-

tasking. Second, in order to follow the system behav-

ior changes at runtime, we need a behavioral mod-

eling and runtime semantics concepts provided re-

spectively by the CommonBehavior as well as the

RuntimeContext sub-packages. Finally, we need to

use the timing concepts offered by the TimedElement

package to deﬁne the components resource execu-

tion period. In addition, we use some concepts from

Communication package to support requests between

adaptive components.

Figure 1 illustrates the proposed package, in which

we have distinguished the standard stereotypes of

MARTE from the proposed ones by the green color.

Ensemble stereotype:

It inherits implementation and attributes of RtUnit

ICSOFT 2021 - 16th International Conference on Software Technologies

160

Figure 1: Component ensemble-based extensions in UML/MARTE proﬁle.

from HLAM sub-package of MARTE. RtUnit stereo-

type speciﬁes active and schedulable resources.

• Generalization: 1) MARTE::RtUnit. 2)

MARTE::Instance stereotype: A system can

establish a set of ensemble instances at runtime.

Thus, the Ensemble stereotype inherits from the

MARTE::Instance stereotype which speciﬁes

runtime instances.

• Associations: 1) UML Component meta-class:

Ensemble is a composition of system components

thus, it is associated to the UML Component

meta-class. 2) MARTE::NFP Constraint: Ensem-

ble is associated to NFP Constraint stereotype of

MARTE that is a boolean condition to determine

whether two components should form an ensem-

ble.

• Attributes: 1) eId: identify the ensemble. 2) ePe-

riod: period of an ensemble 3) eType: type of en-

semble. 4) Pens: delay of ensemble instance eval-

uation. 5) maxPens: max delay of an ensemble in-

stance evaluation. 6) Cmax: sum of computation

delay of all processes in an ensemble. 7) Rmax:

sum of reaction time delay of all processes in an

ensemble. 8) maxPprop: max delay of knowledge

propagation in an ensemble.

• Semantics: An ensemble deﬁnes a semantic con-

nector between components and constitutes their

composition. It can be considered as real-time

task which is externalized from the component it-

self.

Coordinator Member stereotypes: They

inherit the implementation and attributes of

UML::Component meta-class.

• Generalization: UML::Component meta-class

• Associations: Request: communication between

coordinator and member is based on a set of re-

quests. Thus  Coordinator and Member

stereotypes are associated to the Request stereo-

type of MARTE::Communication package.

• Semantics: When specifying an ensemble,

prospective components are described by roles.

One component in the ensemble has a coordina-

tor role, whereas the remaining components are

members of the ensemble.

 Knowledge  stereotypes: It inherits the attribut

of MARTE::NFP stereotype.

• Generalization: MARTE::NFP

• Associations: 1) UML::Component: System

component is speciﬁed by a set of knowledge.

2) Version stereotype: Each knowledge has a

set of versions which should be tracked and

stored for future adaptation decisions. Knowl-

edge stereotype is associated to Version stereo-

type which was proposed in (FREDJ et al., 2018).

A Version stereotype has a VI (version iden-

tiﬁer) attribute and timestamp and duration at-

tributes which have a multiplicity of [0..*]. Ver-

sion stereotype is associated with the TimedDu-

rationObservation and TimedInstantObservation

stereotypes of TimedElement package to deﬁne

the lifetime and instant of each version respec-

tively (FREDJ et al., 2018).

• Semantics: Knowledge is measurable data that

characterize components. It is a state variable that

may change their values at runtime. Knowledge

can be a QoS attribute or an NFP property (such as

CPU utilization, memory usage, power consump-

tion, network bandwidth).

 Process Stereotype: It inherits the implementa-

tion and attributes of RtUnit stereotype, which spec-

iﬁes active and schedulable objects (resources). Pro-

cess is an adaptive object that inherits from Adaptive-

Instance stereotype. The latter was deﬁned in (FREDJ

Component Ensemble-based UML/MARTE Extensions for the Design of Dynamic Cyber-Physical Systems

161

et al., 2018) to extend MARTE proﬁle for supporting

the speciﬁcation of adaptive resource at runtime.

• Generalization: 1) MARTE::RtUnit. 2)

MARTE::AdaptiveInstance.

• Associations: 1) MARTE::ResourceUsage:

Process stereotype is associated to the Re-

sourceUsage stereotype of MARTE which

deﬁne the amount of consumed resource. 2)

Knowledge: Knowledge values represent in-

puts to process. 3) UML::Component: System

component is composed of a set of process. 4)

MARTE::BehaviorExecution: Processes have

runtime behaviors speciﬁed by the BehaviorEx-

ecution stereotype of MARTE::RuntimeContext

package.

• Attributes: 1) WCRT: worst case response time of

a process. 2) rTime: response time of a process.

• Semantics: Process is a real-time and adaptive

unit, which responsible to manage component

knowledge values.

 Request Stereotype: It inherits implementa-

tion and attributes of MARTE::Instance stereotype of

MARTE.

• Generalization: MARTE:: Instance

• Associations: 1) Coordinator: Coordinator com-

ponent sends request to members. 2) Member:

Member component receives request from coor-

dinator.

• Attributes: 1) dateTime: timestamp of a request

instance. 2) rPeriod: period of a request. 3) rProp:

delay of a request instance propagation.

• Semantics: Request is a standard stereotype of

MARTE which represents an instance of com-

munication and speciﬁes data that are passed be-

tween coordinator and member. We deﬁne new

attribute rProp with [0..*] multiplicities to denote

that a request may has several instances in a pe-

riod of time, each of which has a propagation time

(rProp) value.

The system modeling based mainly on the proposed

extensions have to go through a model-based devel-

opment process for the automatic generation of the

dynamic CPS from a high-level speciﬁcation as well

as the evaluation of the real-time constraints.

3.2 Design Patterns for the Speciﬁcation

of DEECo Closed-loop

The second contributions of this work is to separately

specify the behavior of closed-loop using design pat-

terns. In fact, it should be noted that for most of ex-

isting approaches, the adaptation logic as well as the

components membership evaluation are either mixed

with the system functional logic. To overcome this

problem, we propose two design patterns which in-

teract one another to perform a component ensemble

evaluation and knowledge changes monitoring and

adaptation.

3.2.1 Ensemble Evaluator Pattern

The Ensemble evaluator pattern is based on the con-

cept of ensemble. It constitutes a generic solution that

can be applied to any distributed dynamic system. In

fact, it is required to determine whether two compo-

nents (a coordinator and a member) should form an

ensemble. This pattern is responsible for checking the

membership condition between components which is

expressed as a logic predicate formulated upon coor-

dinators and member’s knowledge. The exchanging

of attribute values between coordinator and member

is performed according to the description given in the

knowledge exchange speciﬁcation. Additionally, this

pattern evaluates the closed-loop performance (en-

semble evaluation delay, reaction time and propaga-

tion time) each unit of time by calculating metrics.

The description of the proposed pattern follows the

template in (Buschmann et al., 1996) which presents

a set of rubrics to describe a design pattern such as

problem, context, intent, and solution.

• Problem: Evaluator pattern deals with the issue

of distributed systems components composition

and the issue of closed-loop cost-effectiveness. It

treats the question of with whom to interact and

how well interact do.

• Context: This pattern is used when there is a need

of components composition to exchange knowl-

edge between distributed systems components.

• Intent: This pattern is responsible for checking the

membership condition between two components

to form an ensemble of and to evaluate the closed-

loop performance.

• Solution

Structural view: The structural view of a design

pattern is represented by a class diagram in Fig-

ure 2 which contains: 1) Evaluator class repre-

sents a real-time task, which identiﬁes compo-

nents roles and evaluate their relationship based

on a logical condition. It takes as input compo-

nent knowledge attributes values and generates as

output an ensemble exchange description. Evalu-

ator class is annotated by the Ensemble stereotype

from the proposed package in Figure 1. It assesses

closed-loop performance and adjusts such con-

trol parameters to ameliorate the closed-loop cost-

effectiveness. 2) ControlParameter represents a

ICSOFT 2021 - 16th International Conference on Software Technologies

162

Figure 2: Ensemble pattern structure.

closed-loop parameter which can be adjusted to

new context variations. For instance, it can be

the ensemble evaluation period or thresholds. 3)

Condition class represents a logical expression to

check membership between components. Con-

dition satisfaction is managed by evaluator. 4)

Description class represents the speciﬁcation of

knowledge attributes exchange which is generated

after membership condition checking. 5) Metric

class speciﬁes measurement which are established

by Evaluator to assess closed-loop performance.

6) TraceLog is a repository that serves to store

knowledge values changes and ensemble evalua-

tion metrics Stored data are represented by traces.

Each trace is associated with a version identiﬁer

and has a speciﬁc value at a speciﬁc timestamp.

Behavioral view: A behavioral view illustrates

the pattern behavior through the invocations of

methods between objetcs. The Evaluator starts

by checking the membership condition (method

check ()) satisfaction. Once condition is cheeked,

Evaluator recovers the Boolean value. If the mem-

bership condition is satisﬁed, Evaluator identi-

ﬁes the role of the considered component as a

member. These steps are repeated each unit of

time during ensemble period (ePeriod). The Eval-

uator calculates close-loop performance metrics

(methods calculate ()) and analyzes the history

(TraceLog) to make statistics. Building on these

calculations, and via its adjust () method, it gen-

erate a decision to adjust the closed-loop perfor-

mance by acting on some ControlParameters.

3.2.2 Adaptation Pattern

In the present work, the speciﬁcation of adaptation

logic is performed using design pattern as generic so-

lution to increase the productivity and reusability.

• Problem: The adaptation pattern deals with the is-

sue of dynamic adaptation as a reccurent problem

(IGLESIA and WEYNS, 2015). It treats the ques-

tion of what and how to adapt?

Figure 3: Adaptation pattern structure.

• Context: This pattern is used when a state variable

is changed and attached to an adaptive process.

• Intent: This pattern is responsible for monitoring

and adaptation of the component knowledge val-

ues and storing adaptation traces in the history.

• Solution

Structural view : The static view of adaptation

pattern is illustrated in Figure 3 which contains:

1) AdaptationEngine class represents a real-time

unit that observes the state variable status and de-

cides if a variation has occurred or a threshold

(Threshold class) has been exceeded. It adapts

state variable values in order to meet system con-

straints. It is speciﬁed by the RtUnit and Re-

sourceUsage stereotypes of MARTE. 2) State-

Variable class represents component knowledge

that may change their values under different in-

stants. Thus, they are annotated by the proposed

Version stereotype. Thanks to VI attribute of Ver-

sion stereotype, designers are able to load the

required version from the history. 3) Change-

ableElement class represents the component that

has to be adapted. 4) AdaptationAction class rep-

resents adaptation actions which are applied by

the adaptation engine to the changeable element

in the system. 5) The TraceLog is a repository of

adaptation decisions previously generated by the

adaptation engine. It may serve to store the state

variables changes which are represented by traces.

Behavioral view: The monitoring action begins

with sensors which periodically conveys a new status

measure of the supervised state variable then it noti-

ﬁes the adaptation engine. The AdaptationEngine re-

ceives the new measure and updates the state variable

with the new status value and stores old value in the

history (TraceLog). Afterwards, it inspects the new

status to decide about the change relevance. It can use

thresholds to prove whether the measure is in the in-

terval delimited by min and max values. The negative

case indicates an irregular state causing the Adapta-

tionEngine to generate an adaptation action and up-

date the changeable element.

Component Ensemble-based UML/MARTE Extensions for the Design of Dynamic Cyber-Physical Systems

163

4 ICS EXAMPLE ILLUSTRATION

In order to illustrate the proposed extensions, we rely

on an Intelligent Crossroad System (ICS). More pre-

cisely, the illustration focuses on the speciﬁcation of

input model of the considered system based on the

proposed extensions and the closed-loop patterns. In

fact, the architecture of the ICS system is composed

of two components/nodes which are the car and the

ICS. Vehicles arrive and leave the intersection region

where their priorities changes at different instants ac-

cording to their distances to the center of the inter-

section. Each node is occupied by a processing unit.

The system enables to concurrently run different real-

time tasks or process. A process can be executed in

response to a timer event or as a reaction to a change

in one of its attributes.

4.0.1 ICS System Modeling

Figure 4 illustrates the class diagram of ICS system

model. It is composed of two classes Car and ICS

to specify the car and ICS nodes respectively. Car

and ICS classes are annotated by Member and Coor-

dinator stereotypes, respectively, from the proposed

package in Figure 1. Car component is character-

ized by a set of knowledge; speed, mode, distance

which represent the speed of car, assignment speed

mode and distance from the crosscutting, respectively

and the time of the last speed update, which must

be less than a threshold. Each attribute is annotated

by the knowledge stereotype from the proposed pack-

age. Car component runs three process which are the

monitorSpeed, updateSpeed and calculateSpeed. The

monitor process focus on monitoring whether the time

of the last speed update must be lower than a thresh-

old. The calculate process is responsible for comput-

ing the speeds of potential cars depending on the cur-

rent trafﬁc situation and the time at which they can

reach the intersection. The update process adjusts the

cars speeds to avoid conﬂicts.

Figure 4: ICS system model.

Component/node processes are annotated by Pro-

cess stereotype. They are executed in process-

ing unit which is speciﬁed by Processor class

and annotated by MARTE::HwProcessor stereo-

type. Battery and Memory classes are annotated

by MARTE::HwSupport and MARTE::HwMemory

stereotypes, respectively.

4.0.2 Closed-loop Patterns Application to the

ICS Example

Ensemble pattern starts by checking ensemble condi-

tion which must be evaluated to true at both the ICS

and the car nodes, separately. This checking requires

knowledge values input data such as car speed, dis-

tance and current mode. Thus, ensemble pattern is

integrated in the ICS input model of Figure 4 by two

associations between its Evaluator class (see Figure

2) and Car and ICS classes of ICS model (see Fig-

ure 4). The integration of the closed loop patterns

in the ICS model is illustrated in the resulting model

of Figure 5. The Evaluator is responsible for check-

ing whether input data is obsolete, if not it stores new

values in the history (TraceLog class). We assume

that membership condition is related to the distance

of car to the crosscutting which must be lower than

60 m. If the condition is validated, Evaluator identi-

ﬁes cars which satisfy the condition, as members to

dynamically join the ensemble. Then, Evaluator gen-

erates as output knowledge description which needs

to be exchanged from the car to the ICS and from ICS

to car. Once data are received by the car component,

Evaluator establishes a set of metrics to determinate

the Pens at this timestamp and compares it to max-

Pens. The adaptation of car speed is separately man-

aged by the proposed adaptation pattern depending on

the description generated by ensemble pattern. Thus,

ensemble and adaptation patterns are combined to-

gether by adding a new association between Descrip-

tion class of ensemble pattern and AdaptationEngine

class of adaptation pattern (see Figure 2 and Figure

3). In fact, car speeds represent the state variable

which are captured and monitored using monitoring

actions (MonitoringAction Class) of the adaptation

pattern. Thus, an association between the Car class

of the ICS model and the MonitoringAction class of

the adaptation pattern is established (see Figure 5).

Afterwards, the adaptation engine examines the col-

lected values and generates adaptation actions which

are applied to the changeable element represented by

the updateSpeed() process. Thus, the adaptation pat-

tern is combined with the ICS model by a new as-

sociation between its AdaptationAction class and the

changeable element represented by the updateSpeed

process of the Car class (see Figure 5). Adapta-

tion actions are stored each timestamp in the history

ICSOFT 2021 - 16th International Conference on Software Technologies

164

(TaceLog) for future adaptation decision. Once the

speed adaptation is performed, the ensemble pattern is

invoked to recover the updateSpeed process reaction

time. Then, Evaluator performs a set of metrics to as-

sess the closed-loop delay which is computed based

on Pens and rProp values. In fact, once a membership

evaluation is performed at the ICS, a car propagates

its knowledge to the ICS immediately and the data is

received at the ICS Pens time later. The knowledge

is propagated with a rProp delay from the car to the

ICS. Similarly, the ICS propagates its knowledge to

the corresponding car just after a membership eval-

uation is performed and data is received Pens time

later at the car. The ICS’s knowledge is propagated

to the car rProp time later. The attributes rProp and

Pens are from Request and Ensemble stereotypes 1,

respectively, denote the knowledge propagation and

the ensemble evaluation period of a node i in the ICS

system.

Figure 5: Application of Closed loop patterns to ICS sys-

tem.

5 CONCLUSION AND

DISCUSSION

The use of high-level methods for the speciﬁcation

and the analysis of cyber-physical systems provide

advantages upon low-level development. It consists

in raising the level of abstraction to describe coop-

erative dynamic components systems. Almost exist-

ing approaches do not support the high-level design

for monitoring, adaptation and real-time analysis con-

cerns. They do not operate at an abstract level and

do not support the traceability of dynamic compo-

nents versions during execution. To overcome these

issues, we deﬁned a new component ensemble-based

UML/MARTE package to support the dynamic inter-

action between distributed components and to specify

CPS and real-time constraints. Additionally, we have

proposed design patterns for specifying closed-loop

features. In fact, a pattern view screens out speciﬁc

details and makes it possible to describe and conceive

solutions independently from any system. It offers the

advantage of concerns separation to reduce execution

problems.

As future works, we plan to integrate the present

UML/MARTE extensions and proposed patterns into

a complete model driven-based approach for the anal-

ysis of distributed systems.

REFERENCES

Arcaini, P., Riccobene, E., and Scandurra, P. (2015). Mod-

eling and analyzing mape-k feedback loops for self

adaptation. International Symposium on Software En-

gineering for Adaptive and Self Managing Systems,

SEAMS15, IEEE, Piscataway, NJ, USA, page 13–23.

Beux, S. L. (2007). Un ﬂot de conception pour applications

de traitement du signal systematique implementees

sur fpga a base d ingenierie dirigee par les modeles.

Universite des Sciences et Technologie de Lille.

Bradai, S., Bouattour, G., Naifar, S., and Kanoun, O.

(2020). Electromagnetic energy harvester for battery-

free iot solutions. IEEE World Forum on Internet of

Things (WF-IoT).

Bures, T., Nicola, R. D., Gerostathopoulos, I., Hoch, N.,

Kit, M., Koch, N., Monreale, G. V., Montanari, U.,

Pugliese, R., Serbedzija, N., Wirsing, M., and Zam-

bonelli, F. (2013). A life cycle for the develop-

ment of autonomic systems: The e mobility show-

case. 2013 IEEE 7th International Conference on Self-

Adaptation and Self-Organizing Systems Workshops,

pages 359–381.

Buschmann, F., Meunier, R., Rohnert, H., Sommerlad, P.,

and Stal, M. (1996). Pattern Oriented Software Archi-

tecture.

Corsaro, A., Schmidt, D. C., Klefstad, R., and ORyan,

C. (2002). Virtual component - a design pattern for

memory-constrained embedded applications. In in

Proceedings of the Ninth Conference on Pattern Lan-

guage of Programs (PLoP.

Crnkovic, I., Sentilles, S., Vulgarakis, A., and Chaudron,

M. R. (2011). A classiﬁcation framework for software

component models. IEEE Transaction. Software. En-

gineering. volume 37(5), pages 593–615.

Fredj, N., Kacem, Y. H., , and Abid, M. (Dec 2018). Run-

time uml marte extensions for the design of adaptive

rte systems. International Conference on Intelligent

Systems Design and Applications (ISDA),2018, Vel-

lore India.

Fredj, N., Kacem, Y. H., and Abid, M. (2020). Runtime

model-based framework for specifying and verifying

adaptive rte systems. International Journal of Com-

puter Applications Technologies.

Iglesia, D. G. D. L. and Weyns, D. (2015). Mape-k formal

templates to rigorously design behaviors for self adap-

tive systems. ACM Transactions on Autonomous and

Adaptive Systems, Volume 10, Issue 3, pages 1–15.

Krichen, F., Hamid, B., Zalila, B., Jmaiel, M., and Coulette,

B. Development of reconﬁgurable distributed em-

bedded systems with a model driven approach. Con-

Component Ensemble-based UML/MARTE Extensions for the Design of Dynamic Cyber-Physical Systems

165

currency and Computation: Practice and Experience,

Volume 27, Issue 6.

Masrur, A., Kit, M., Matena, V., Buresb, T., and Hardt, W.

(2017). Component-based design of cyber-physical

applications with safety-critical requirements. Journal

of Microprocessors and Microsystems volume 10(3),

page 1–17.

ICSOFT 2021 - 16th International Conference on Software Technologies

166