For developing software systems it is crucial to consider non-functional properties already in an early development stage to guarantee that the system will satisfy its non-functional requirements. Following the model-based engineering paradigm facilitates an early analysis of non-functional properties of the system being developed based on the elaborated design models. Although UML is widely used in model-based engineering, it is not suitable for model-based analysis directly due to its lack of formal semantics. Thus, current model-based analysis approaches transform UML models into formal languages dedicated for analyses purpose, which may introduce accidental complexity of implementing the required model transformations.

1. Business
Informa.cs
Group
Ins$tute
of
So,ware
Technology
and
Interac$ve
Systems
Vienna
University
of
Technology
Favoritenstraße
911/1883,
1040
Vienna,
Austria
phone:
43
(1)
5880118804
(secretary),
fax:
43
(1)
5880118896
office@big.tuwien.ac.at,
www.big.tuwien.ac.at
Sealab
Quality
Group
Department
of
Informa$on
Engineering
,
Computer
Science
and
Mathema$cs
University
of
L’Aquila
Via
Vetoio,
Coppito
67100
L’Aquila
,
Italy
University
of
L’Aquila
Department
of
Informa$on
Engineering,
Computer
Science
and
Mathema$cs
Combining
fUML
and
Profiles
for
Non-­‐Func.onal
Analysis
Based
on
Model
Execu.on
Traces
Tanja
Mayerhofer,
Philip
Langer
Luca
Berardinelli

2. Outline
• Mo$va$ons
• UML-­‐Based
Analysis
Methodologies:
• transla$onal
approaches
• fUML-­‐based
approaches
• The
proposed
framework
• Model
Execu$on
• UML/fUML
integra$on
• UML-­‐based
Analysis
• Reusable
and
Analysis-­‐specific
components
• Case
Study:
Early
Performance
Analysis
• Future
work
2

3. Mo$va$ons
• Problems
• fUML
ignores
UML
Profiles:
stereotypes
and
tags
don’t
have
a
running
counterpart
at
the
instance
level.
• fUML
cannot
be
exploited
by
model-­‐based
methodologies
that
relies
on
model
annota$ons
• Seman$c
anchoring
mechanisms
(e.g.,
model
transforma$ons)
are
always
required
that
link
external
seman$cs
(and
nota$ons)
to
(a
subset
of
)UML
modeling
elements
• Solu.on
(contribu.on)
• a
reusable
framework
for
performing
model-­‐based
analyses
leveraging
execu$on
traces
of
UML
models
and
integra$ng
UML
profiles
heretofore
unsupported
by
fUML.
• Example
given
• Modeling
solu$on
for
Early
Performance
Analysis
• nota.on:
fUML,
MARTE
Profile
• methodology:
So,ware
Performance
Engineering
(SPE,
by
C.
Smith)
• tool:
framework
tailored
for
early
model-­‐based
performance
analysis
3

4. Mo$va$ons
4
Ninth
Interna$onal
ACM
Sigso,
Conference
on
the
Quality
of
So,ware
Architectures
QoSA
2013
Vancouver,
Canada,
June
17-­‐21,
2013
The
conference
is
a
part
of
CompArch
2013
hep://comparch2013.org
No.fica.on:
March,
25th
Architecture Evaluation
• quality assessment of legacy systems and third party applications
• empirical validation, testing, prototyping and simulation for assessing architecture quality
• quality attributes of software architectures
• methods and processes for evaluating architecture quality
• model-driven evaluation of software architecture quality
• evaluating the effects of architectural adaptations at run-time
• lessons learned and empirical validation of theories and frameworks on architecture quality

5. UML-­‐Based
Analysis
Methodologies:
transla$onal
approaches
5
• UML-­‐based
methodologies
prescribe
model
annota$ons
on
input
UML
Models
added
through
user-­‐defined
or
standard
UML
Profiles
• Integra.on
Tools
produce
Analysis
Models
in
different
(textual/graphilcal)
(formal)
nota$ons
for
sake
of
seman.cs
anchoring
• Model
Analysis
Reports
are
produced
by
Analysis
Tools
to
assess
func$onal/non-­‐
func$onal
proper$es
of
the
modeled
system
Integration
Tool
Integration
Tool
Analysis
Tool
Analysis
Tool
Integration
Tool
Analysis
Tool
«integrate»
«produce»
Analysis
Model
Analysis
Model
Analysis
Model «analyzedBy»
«produce»
Input
Profile
Application
UML
Model
«appliedTo»
Profile
Application
Profile
Application
Output
Model
Analysis
Report
Model
Analysis
Report
Model
Analysis
Report

6. UML-­‐Based
Analysis
Methodologies:
transla$onal
approaches
(example)
6
Vieorio
Cortellessa,
Raffaela
Mirandola:
PRIMA-­‐UML:
a
performance
valida$on
incremental
methodology
on
early
UML
diagrams.
Sci.
Comput.
Program.
44(1):
101-­‐129
(2002)
• Three
“metamodels”
combined
(UML,
S-­‐PMIF,
PMIF);
• Four
unidirec$onal
m2m
transforma$ons
(UML-­‐>SPMIF,
UML-­‐>PMIF,
SPMIF+PMIF-­‐>SPMIF,
SPMIF+PMIF-­‐>PMIF)
• Three
different
technical
spaces
(MOF,
Ecore,
XML)
• Toolset:
modeling
tools
(UML,
S-­‐PMIF,
PMIF),
analysis
tools
(Execu$on
Graph
Analysis,
QN
Solvers)
[Kurtev02]
Kurtev,
I.,
Bézivin,
J.,
Aksit,
M.
"Technological
Spaces:
An
Ini$al
Appraisal",
In
Proceedings
of
the
Confederated
Interna$onal
Conferences
CoopIS,
DOA,
and
ODBASE
2002,
Industrial
track,
Irvine,
CA,
USA,
2002.
hep://wwwhome.cs.utwente.nl/~kurtev/files/TechnologicalSpaces.pdf

7. UML-­‐Based
Analysis
Methodologies:
transla$onal
approaches
7
Pros
• Exis.ng
analysis
techniques
and
tools
for
the
target
language
can
be
directly
exploited.
Cons
• Addi$onal
level(s)
of
indirec$on
• Deep
knowledge
of
source/target(s)
metamodels
and
seman$cs,
model
transforma$on
techniques.
• Implementa.on
and
maintenance
of
model
transforma.ons
(as
Integra.on
Tools)
• Academic
tools
less
stable
than
industrial-­‐strength
ones
Integration
Tool
Integration
Tool
Analysis
Tool
Analysis
Tool
Integration
Tool
Analysis
Tool
«integrate»
«produce»
Analysis
Model
Analysis
Model
Analysis
Model «analyzedBy»
«produce»
Input
Profile
Application
UML
Model
«appliedTo»
Profile
Application
Profile
Application
Output
Model
Analysis
Report
Model
Analysis
Report
Model
Analysis
Report
model
transforma0ons
for
seman0c
anchoring

8. UML-­‐Based
Analysis
Methodologies:
fUML-­‐based
approaches
-­‐
Overview
8
UML
Input
Profile
Application
UML
Model
«appliedTo»
Profile
Application
Profile
Application
Output
Model
Analysis
Report
Model
Analysis
Report
Model
Analysis
Report
Cons
-­‐ (not)
addi$onal
level
of
indirec$on
-­‐ (not)
implementa$on
and
maintenance
of
model
transforma$ons
-­‐ (not)
deep
knowledge
of
source/target(s)
metamodels
and
seman$cs,
model
transforma$on
techniques.
fUML
fUML-based Model Execution
UML/fUML Integration
UML-based Analysis

9. UML-­‐Based
Analysis
Methodologies:
fUML-­‐based
approaches
-­‐
Overview
9
Input
Profile
Application
UML
Model
«appliedTo»
Profile
Application
Profile
Application
Output
Model
Analysis
Report
Model
Analysis
Report
Model
Analysis
Report
Pros
à
Contribu)on
of
paper
-­‐ Integra$on
of
the
analysis
algorithms
directly
with
the
design
modeling
language
-­‐ Integra$on
of
Model
Analysis
Report(s)
directly
with
the
design
modeling
language
UML
fUML
fUML-based Model Execution
UML/fUML Integration
UML-based Analysis

10. The
proposed
framework:
fUML-­‐based
Model
Execu$on
10
1. analyzing
the
execu$on
à
Trace
model
§ Chronological
execu.on
order
§ Input
/
output
§ Token
flow
§ Call
hierarchy
2. observing
the
execu$on
state
à
Event
model
3. controlling
the
execu$on
à
Command
API
• fUML
View:
a
UML
Model
whose
elements
belong
to
the
fUML
language
units
(Classes,
Common
Behaviors,
Ac0vi0es,
and
Ac0ons)
• Extended
fUML
VM:
standard
fUML
VM
+
moliz
extensions
for
fUML-based Model Execution
«produce»
Extended
fUML VM
fUML
Execution
Trace
fUML
View
«executedBy»

11. The
proposed
framework:
fUML-­‐based
Model
Execu$on
11
1. analyzing
the
execu$on
à
Trace
model
2. observing
the
execu$on
state
à
Event
model
§ Start
/
end
of
ac.vity
execu.on
§ Start
/
end
of
ac.vity
node
execu.on
§ Suspension
of
ac.vity
execu.on
§ Modifica.on
of
extensional
values
3. controlling
the
execu$on
à
Command
API
• fUML
View:
a
UML
Model
whose
elements
belong
to
the
fUML
language
units
(Classes,
Common
Behaviors,
Ac0vi0es,
and
Ac0ons)
• Extended
fUML
VM:
standard
fUML
VM
+
moliz
extensions
for
fUML-based Model Execution
«produce»
Extended
fUML VM
fUML
Execution
Trace
fUML
View
«executedBy»

12. The
proposed
framework:
fUML-­‐based
Model
Execu$on
12
1. analyzing
the
execu$on
à
Trace
model
2. observing
the
execu$on
state
à
Event
model
3. controlling
the
execu$on
à
Command
API
§ Start
/
stop
execu.on
§ Resume
execu.on
un.l
certain
ac.vity
node
§ Resume
execu.on
stepwise
§ Retrieve
run.me
informa.on
• fUML
View:
a
UML
Model
whose
elements
belong
to
the
fUML
language
units
(Classes,
Common
Behaviors,
Ac0vi0es,
and
Ac0ons)
• Extended
fUML
VM:
standard
fUML
VM
+
moliz
extensions
for
fUML-based Model Execution
«produce»
Extended
fUML VM
fUML
Execution
Trace
fUML
View
«executedBy»

13. The
proposed
framework:
UML/fUML
Integra$on
Input
Profile
Application
UML
Model
«appliedTo»
Profile
Application
Profile
Application
fUML-based Model Execution
«produce»
Extended
fUML VM
fUML
Execution
Trace
fUML
View
«executedBy»
UML/fUML Integration
Execution
Trace
Execution
Trace
UML
Execution
Trace
«produce»
«integrate»
«integrate» UML Trace
Adapter
fUML
Adapter
«produce»
«use»
«integrate»
• fUML
Adapter:
it
truncates
all
unsupported
UML
elements,
as
well
as
the
profile
applica$ons,
and
generates
the
in-­‐memory
representa$on
of
fUML
models
processable
by
the
fUML
virtual
machine;
• UML
Trace
Adapter:
It
maps
the
fUML
Execu$on
Traces
with
the
corresponding
modeling
elements
on
the
source
UML
Model
by
exploi$ng
mapping
informa$on
saved
by
the
fUML
Adapter.
integrated
UML
execu$on
trace
is
created
• UML
Execu.on
Trace:
it
refers
to
the
original
elements
of
the
UML
model
instead
of
the
fUML
view.
13

14. The
proposed
framework:
UML-­‐based
Analysis
Model-­‐based
Analyzer:
A
model-­‐based
analysis
is
typically
performed
to
answer
certain
ques$ons
about
the
expected
behavior
of
the
modeled
system.
The
expected
behavior
is
directly
reflected
by
the
trace
of
the
model's
execu$on
and
can
now
be
analyzed
using
a
model-­‐based
analyzer,
which
computes
certain
metrics
by
interpre$ng
the
execu$on
trace
and
the
addi$onal
informa$on
captured
using
profile
applica$ons.
14
Input
Profile
Application
UML-based Analysis
fUML-based Model Execution
UML/fUML Integration Output
UML
Model
«appliedTo»
Model
Analysis
Report
Model
Analysis
Report
Model
Analysis
Report
«produce»
Model-based
Analyzer
Execution
Trace
Execution
Trace
UML
Execution
Trace
«analyzedBy»
«produce»
«produce»
Extended
fUML VM
fUML
Execution
Trace
fUML
View
«integrate»
«integrate» UML Trace
Adapter
fUML
Adapter
«executedBy»
«produce»
«integrate»
«use»
Profile
Application
Profile
Application

15. fUML-based Modeling Solution for Software Performance Engineering (SPE)
The
proposed
framework:
Reusable
and
specific
to
analysis
components
15
Input
Profile
Application
UML-based Analysis
fUML-based Model Execution
UML/fUML Integration Output
UML
Model
«appliedTo»
Model
Analysis
Report
Model
Analysis
Report
Model
Analysis
Report
«produce»
Model-based
Analyzer
Execution
Trace
Execution
Trace
UML
Execution
Trace
«analyzedBy»
«produce»
«produce»
Extended
fUML VM
fUML
Execution
Trace
fUML
View
«integrate»
«integrate» UML Trace
Adapter
fUML
Adapter
«executedBy»
«produce»
«integrate»
«use»
Tool
Profile
Application
Caption:
Profile
Application
Artifact
specific to the
analysis
MARTE
Application
Performance
Analyzer
(EG analysis)
Execution Time
Report
C.U. Smith and L.G. Williams. Performance solutions: A practical guide to creating
responsive, scalable software, volume 1. Addison-Wesley Boston, 2002.

16. Case
Study:
Early
performance
analysis
based
on
fUML
(1)
Case
Study
§ e-­‐health
system
§ Retrieval
of
pa$ent
informa$on
§ Analyze
end-­‐to-­‐end
execu$on
$me
§ So[ware
View:
UML
Classes
(structure)
§ so,ware
components
§ component
opera$ons
§ Hardware
View:
UML
Classes
(structure)
§ so,ware
alloca$on
on
hardware
§ hardware
plaworm
resources:
processing,
storage,
communica$on
§ MARTE
Annota$ons:
hardware
resources
details
like
§ frequencies
of
CPUs
§ bandwidth
of
comm.networks
§ disk
access
$me
§ …
16
ignored
by
fUML

17. Case
Study:
Early
performance
analysis
based
on
fUML
(2)
17
act Client::RPD
<<ResouceUsage>>
int RPD messages
§ So[ware
View:
UML
Ac$vi$es
(behavior)
§ associated
to
each
component
opera$on
§ MARTE
Annota$ons:
resource
usages
(a.k.a.
demand
vectors
in
SPE)
for
any
atomic
behavioral
unit.
The
usedResources
correspond
to
those
equipping
the
execu$on
host
where
the
so,ware
components
are
allocated
ignored
by
fUML
stereotype
ignored
by
fUML

18. Case
Study:
Early
performance
analysis
based
on
fUML
(3)
Analysis
of
execu$on
$me
based
on
Execu.on
Graph
(graph
reduc0on
algorithm)
18
UML2EG
transforma$on
S-­‐PMIF
Metamodel
UML
Metamodel
Eclipse
UML
MOSQUITO
(UAQ)
SPEED
(C.Smith)
http://www.perfeng.com/
………………………………………………………………………………………………
«conforms to»
«conforms to»
EGs are particularly suitable during the early stages of a software development process because
an EG "[...] characterizes the resource requirements of proposed software alone, in the absence of other
workloads, multiple users or delays due to contention for resources." [10]

19. Case
Study:
Early
performance
analysis
based
on
fUML
(3)
Analysis
of
execu$on
$me
based
on
Execu.on
Trace
(graph
reduc0on
algorithm)
t : Trace
ae1 : ActivityExecution
- activity = eHS::invokeServices()
ae2 : ActivityExecution
- activity = Client::requestPatientInfoPages()
c1 : CallActionExecution
- callee = Client::requestPatientInfoPages()
c3: CallActionExecution
- callee = displayResults
c2 : CallActionExecution
- callee = AppServer::getPatientData()
ae3 : ActivityExecution
- activity = AppServer::getPatientData()
c4 : CallActionExecution
- callee = Database::loginInteraction()
c5 : CallActionExecution
- callee = Database::getPatientData()
c6 : CallActionExecution
- callee = Database::getMedicalHistories()
c7 : CallActionExecution
- callee = Database::getDiseaseData()
c8 : CallActionExecution
- callee = ImageServer::getXrayImages()
c9 : CallActionExecution
- callee = ImageServer::getXrayImages()
+nodeExecutions
+nodeExecutions
+nodeExecutions
+activityExecutions
+activityExecutions +callee
+callee
+activityExecutions
execTime = 0,2888 sec
execTime = 0,0767 sec
execTime = 0,0736 sec
execTime = 0,0722 sec
execTime = 18,5570 sec
execTime = 9,2473 sec
execTime = 28,3156 sec
execTime = 28,3156 sec
execTime = 156,0333 sec
execTime = 184,3489 sec
execTime = 184,3489 sec
execTime = 184,3489 sec
19

20. Case
Study:
Early
performance
analysis
based
on
fUML
(3)
Analysis
of
execu$on
$me
based
on
Execu.on
Trace
(graph
reduc0on
algorithm)
20

21. Future
Work:
overview
Different
Types
of
possible
future
work:
• Modeling
Solu.ons
• for
different
Func$onal
Analyses
• for
Non-­‐Func$onal
Analyses
• for
combined
Func$onal/Non-­‐Func$onal
Analyses
• Extending
the
Model
Execu.on
component
• Extending
the
applicability
of
the
framework
@run.me
21
fUML-based Modeling Solution for...
Profile
Applications
Model Analyzer Model Analysis
Report
*
fUML-based Model
Execution
«produce»
Extended
fUML VM
fUML
Execution
Trace
fUML
View
«executedBy»
Code for Sensor Motes
UML2Agilla
Compiler
Agilla
Code
«produce»
Framework

22. Future
Work:
Modeling
Solu$ons
fUML-­‐based
Modeling
Solu$ons
for
Non-­‐Func$onal
Analysis
1. reliability
analysis
• Methodology:
Vieorio
Cortellessa,
Harshinder
Singh,
Bojan
Cukic:
Early
reliability
assessment
of
UML
based
so,ware
models.
Workshop
on
So,ware
and
Performance
2002:
302-­‐309
2. trade-­‐off
analysis.
• Methodologies:
EG
Analysis
(avalailable)
+
Reliability
(1)
3. context-­‐aware
analysis
• Methodology:
Luca
Berardinelli,
Vieorio
Cortellessa,
An$nisca
Di
Marco:
Performance
Modeling
and
Analysis
of
Context-­‐Aware
Mobile
So,ware
Systems.
FASE
2010:
353-­‐367
• Possible
Combina.ons:
• Performance
(current)
• Reliability
(1)
• Trade-­‐off
(2)
22
fUML-based Modeling Solution for...
Profile
Applications
Model Analyzer Model Analysis
Report
*

23. Future
Work:
Modeling
Solu$ons
fUML-­‐based
Modeling
Solu$ons
for
Func$onal
Analysis
4. model-­‐based
tes.ng
• UML
Tes.ng
Profile
(UTP)
23
fUML-based Modeling Solution for...
Profile
Applications
Model Analyzer Model Analysis
Report
*
As
so,ware
becomes
increasingly
pervasive,
the
need
for
quality
and
reliability
in
so,ware
systems
con$nues
to
increase.
Model-­‐based
methods
have
been
an
important
development
in
helping
organiza$ons
build
so,ware
with
higher
quality.
Prior
to
the
development
of
the
UML
Tes$ng
Profile
(UTP),
UML
(which
is
the
most
popular
modeling
language)
did
not
have
support
for
tes$ng-­‐related
ac$vi$es.
The
UTP
provides
extensions
to
UML
to
support
the
design,
visualiza.on,
specifica.on,
analysis,
construc.on,
and
documenta.on
of
the
ar.facts
involved
in
tes.ng.
It
is
independent
of
implementa.on
languages
and
technologies,
and
can
be
applied
in
a
variety
of
domains
of
development.
http://utp.omg.org/
TO
DOs
• Bibliographic
research
on
exis$ng
Model-­‐Based
Tes$ng
methodologies
• UTP
vs
fUML

24. Future
Work:
Extension
of
the
fUML-­‐based
Model
Execu$on
component
24
5. Introducing
the
concept
of
Time
in
the
fUML
VM.
References:
hep://link.springer.com/chapter/
10.1007%2F978-­‐3-­‐642-­‐15234-­‐4_6
In
this
paper
(cited
in
the
work
submieed
to
QoSA)
the
authors
proposed
the
coupling
of
fUML
with
TimeSquare
(hep://$mesquare.inria.fr/
).
TimeSquare
has
been
developed
by
a
partner
of
the
PRESTO
project
(hep://www.presto-­‐embedded.eu/
)
where
I’m
currently
involved.
We
can
contact
them
to
establish
collabora$on
on
this
possible
extension
fUML-based Model Execution
«produce»
Extended
fUML VM
fUML
Execution
Trace
fUML
View
«executedBy»
+
Time

25. Future
Work:
Extension
of
the
fUML-­‐based
Model
Execu$on
component
25
fUML-based Model Execution
«produce»
Extended
fUML VM
fUML
Execution
Trace
fUML
View
«executedBy»
6. Run.me
Model
for
UML
StateMachines
• replicate
the
fUML-­‐based
Model
Execu$on
for
UML
StateMachines;
• an
open
source
implementa$on
of
a
SM
VM
is
available
at
hep://commons.apache.org/proper/commons-­‐scxml//
Both
fUML
VM
and
SM
VM
have
been
integrated
in
Cameo
Simula.on
Toolkit
without
any
support
for
Execu.on
Traces
then…
+
StateMachine Model
Execution
«produce»
Extended
SM VM
SM
Execution
Trace
UML SM
View
«executedBy»
7. Implemen.ng
the
current
framework
as
a
plugin
for
Cameo
Simula.on
Toolkit
• s$ll
based
on
Eclipse
UML
(it
seems
possible)
• collabora$on
with
MD
(conflict
of
interest?)

26. Future
Work:
Extension
of
the
fUML-­‐based
Model
Execu$on
component
26
8. fUML
Seman.cs
vs.
QN
Seman.cs
vs.
PN
Seman.cs
Is
fUML
Seman$cs
suitable
for
suppor$ng
QN-­‐based
and/or
PN-­‐based
Analysis
Techniques?
fUML-based Model Execution
«produce»
Extended
fUML VM
fUML
Execution
Trace
fUML
View
«executedBy»
+
Queuing
Networks
(M/M/1)
+
Petri
Nets
an
M/M/1
queue
represents
the
queue
length
in
a
system
• having
a
single
server,
• where
arrivals
are
determined
by
a
Poisson
process
and
• job
service
.mes
have
an
exponen.al
distribu.on.
+
Time
+
Petri
Nets
=
Stochas$c
Petri
Net
+
Time

27. Future
Work:
WSN,
new
applica$on
domain
27
8. Applying
MDE
fUML-­‐based
approaches
to
WSNs
• s$ll
based
on
Eclipse
UML
(it
seems
possible)
• collabora$on
with
MD
(any
conflict
of
interest?)
Code for Sensor Motes
UML2Agilla
Compiler
Agilla
Code
«produce»
Input
UML
Model
MARTE
Profile
Agilla
Model
Library
Agilla
Profile
«appliedTo»
«include»
«integrate»
Agent-­‐based
Middleware
for
WSNs
http://mobilab.wustl.edu/projects/agilla/

28. Code for Sensor Motes
Future
Work:
Extending
the
applicability
of
the
framework
@run$me
28
Input
UML-based Analysis
fUML-based Model Execution
UML/fUML Integration Output
UML
Model
«appliedTo»
Model
Analysis
Report
Model
Analysis
Report
Model
Analysis
Report
«produce»
Model-based
Analyzer
Execution
Trace
Execution
Trace
UML
Execution
Trace
«analyzedBy»
«produce»
«produce»
Extended
fUML VM
fUML
Execution
Trace
fUML
View
«integrate»
«integrate» UML Trace
Adapter
fUML
Adapter
«executedBy»
«produce»
«integrate»
«use»
MARTE
Profile
UML2Agilla
Compiler
Agilla
Code
«integrate»
Agilla
Model
Library
Agilla
Profile
«appliedTo»
«use»
«produce»
Monitor
«monitored by»
Monitoring
Report
«produce»
«modify»
done
done
done
done
done
done
TBD
TBD
TBD
TBD
All
the
proposed
extensions
are
applicable

29. Ques$on
Time
29

30. Trace
model
30
ActivityExecution
fUML::Syntax::Activities::
IntermediateActivities::Activity
ActivityNodeExecution
fUML::Syntax::Activities::
IntermediateActivities::
ActivityNode
Input
Output
fUML::Syntax::Actions::
BasicActions::InputPin
fUML::Syntax::Actions::
BasicActions::OutputPin
ParameterInput
ParameterOutput
TokenInstance
ValueInstance ControlTokenInstance
ObjectTokenInstance
fUML::Syntax::Activities::
IntermediateActivities::
ActivityEdge
CallActivityNodeExecution
fUML::Syntax::CommonBehaviors::
BasicBehaviors::Behavior
Trace
fUML::Syntax::Activities::
IntermediateActivities::
ActivityParameterNode
UserParameterInput
fUML::Semantics::Classes::
Kernel::Value
0..1
+caller
0..1
+callee
0..1
*
1
1
*
1
+/traversedEdge
1
1
*
1
*
*
0..1
*
*
1 +/successor
0..1
chronological +/predecessor
0..1
+/predecessor
*
logical
+/successor
*
*
1
*
*
{ordered}
*
*
*

31. Event
model
31
Event
- timestamp :long
TraceEvent
- executionID :int
ExtensionalValueEvent
- type :ExtensionalValueEventType
FeatureValueEvent
ActivityEvent
ActivityEntryEvent
ActivityExitEvent
BreakpointEvent
SuspendEvent
ActivityNodeEvent
ActivityNodeExitEvent
ActivityNodeEntryEvent
«enumeration»
ExtensionalValueEventType
CREATION
DESTRUCTION
TYPE_ADDED
TYPE_REMOVED
VALUE_CREATION
VALUE_DESTRUCTION
VALUE_CHANGED
Breakpoint
fUML::Syntax::Activities::
IntermediateActivities::Activity
fUML::Syntax::Activities::
IntermediateActivities::ActivityNode
fUML::Semantics::Classes::
Kernel::ExtensionalValue
fUML::Semantics::Classes::
Kernel::FeatureValue
fUML::Semantics::Classes::
Kernel::Element
+extensionalValue
1
+featureValue
1
+location 1
+newEnabledNodes
0..*
+node1
+parent
0..1
+activity
1
+breakpoint 1
+node
1

32. Command
API
void
execute(Behavior
activity,
Object
context,
ParameterValueList
input)
void
executeStepwise(Behavior
activity,
Object
context,
ParameterValueList
input)
void
nextStep(int
executionID,
ActivityNode
node)
void
resume(int
executionID)
void
terminate(int
executionID)
void
addBreakpoint(Breakpoint
breakpoint)
32