Creating Distributed Simulations:
The <DEVS, HLA, CORBA> Triad
Bernard P. Zeigler
Hessam S. Sarjoughian
University of Arizona, Tucson, USA
Tom Lake
InterGlossa, Ltd, UK
Copyright: University of Arizona
Arizona Center for Integrative Modeling and Simulation
All rights reserved,
SIW 2000
website: www.acims.arizona.edu
Navigating Course Modules
M&S in DoD
& Industry
System
Concepts
Module 2
Module 1
Part 2
HLA/CORBA
Basic
DEVS
Concepts
DEVS
OO Computational
Environment
Module 3
Module 5
Creating
DEVS-C++/Java
Models
DEVS
Formalism
Module 6
Module 4
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
2
Navigating Course Modules (Cont.)
Modeling & Simulation
Foundation (Modules 1:6)
Efficient Large-Scale
Distributed Simulation
DEVS/HLA
Requirements
Module 17
Module 9
DEVS/HLA
Joint MEASURE
HLA
Basics
Module 7
DEVS/HLA
Design & Implementation
Module 18
Module10
Zero Lookahead Simulation
HLA Federation
Development
Module 8
Module19
Creating Federations
in DEVS/HLA
Module 11
DEVS-based
TOOLS
Module 20
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
3
Navigating Course Modules (Cont.)
Modeling & Simulation
Foundation (Modules 1:6)
Efficient Large-Scale
Distributed Simulation
Module 17
CORBA
Basics
Module 12
SES
Concepts
DEVS/HLA
Joint MEASURE
Module18
Module14
DEVS/CORBA
Requirements, Design, Impl.
Module13
Collaborative/Distributed
DEVS M&S
Module 15
DEVS-based
TOOLS
Module 20
DEVS/HLA/CORBA Tutorial
Distributed Co-Design
M&S
Zero Lookahead Simulation
Module19
Summary,
More Info,
AZ Center for M&S
Module 16
SIW(fall 2000)
4
Module1:
M&S in DoD: Roles of HLA and DEVS
 Rise
of M&S in DoD
 Rationale and Overview of HLA
 M&S Current and Future: SBA
 Enabling Role of Discrete Event M&S (DEVS)
 Comprehensive Architecture for M&S
HLA and Simulation Based Acquisition
Research,
Development,
& Engineering
Policy
Development
Test &
Evaluation
Training
Concept
Analysis
Intellectual
Common tools
Model and Data
Repositories
HLA M&S
Infrastructure
Support for Collaboration
On-line Control
Common Software Modules
Communications
Source: NRC Modeling and Simulation,
Vol. 9, National Academy Press
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
10
Example: HLA Distributed Simulation
Joint
Measure
OPNet
Comm
Model
DD21
(Warship
Model)
DEVS
Federate
DEVS
Federate
DEVS
Federate
RTI
Ambasador
RTI
Ambasador
RTI
Ambasador
Network
RTI
Executive
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
13
DEVS Modeling & Simulation Framework
• DEVS = Discrete Event System Specification
• Provides sound M&S framework
• Dynamic system representation capability
• Supports hierarchical, modular modeling
• DEVS/HLA User Friendly HLA-Compliant Environment
• HLA enables interoperability of existing simulations
• DEVS supports developing new simulation models
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
16
Source: NRC Modeling and Simulation,
Vol. 9, National Academy Press
Layered Architecture for M&S
Collaboration
Enable cooperation among participants
Decision
Decision Making in Application domains
Search
Searches, Evaluates Design Space
Models::Attributes and Dynamics
HLA
Executes models
Supports all Hardware aspects of M&S
DEVS/HLA/CORBA Tutorial
DEVS
SIW(fall 2000)
Modeling
Simulation
Network
17
Module2:
Fundamentals of Modeling & Simulation
 Basic
Systems Concepts
 M&S Entities and Relations
 Systems Models
 DEVS Bus
M&S Entities and Relations
Device for
executing model
Real World
Simulator
Data: Input/output
relation pairs
modeling
relation
Each entity is represented
as a dynamic system
Model
structure for generating behavior
claimed to represent real world
Each relation is represented
by a homomorphism or other
equivalence
DEVS/HLA/CORBA Tutorial
simulation
relation
SIW(fall 2000)
19
M&S Entities and Relation(cont’d)
Distributed Simulation
Real World
Simulator
Simulator
Simulator
modeling
relation
simulation
relation
Model
Model
Model
Model should be easily migrated from
Single Workstation to
Distributed Simulation Environment
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
20
M&S Entities and Relation(cont’d)
Experimental Frame
Real World
Simulator
modeling
relation
Model
Model
Model
Experimental frame specifies
conditions under which the system
is experimented with and observed
DEVS/HLA/CORBA Tutorial
simulation
relation
SIW(fall 2000)
21
Dynamic Systems
Simulator:
Numerical
Integrator
System
System Specification:
DESS: differential equation
DTSS: difference equation
DESS model:
dq/dt = a*q +bx
DEVS: discrete event
Simulator:
Recursive
Algorithm
Simulator:
Event
Processor
System
System
DEVS model
DTSS model:
time to next event,
q(t+1) = a*q(t)+ b*x(t)
state at next event ...
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
22
DEVS Bus Concept
Discrete
Event
Formalisms
Discrete Time
Systems
DEVS
DEVS
message
Diff Eq.
Systems
DEVS
message
message
HLA
HLA
HLA
RTI
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
24
Module 3: Basic DEVS Concepts
Atomic Models
 Coupled Models
 Dynamics
 Components
 Coupling

Two Fundamental Model Types

Atomic: lowest level model, contains
structural dynamics -- model level
modularity  HLA federate

Coupled: composed of one or more
atomic and/or coupled models 
HLA federation
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
26
Models Capture System’s Dynamic Behavior

Simulation models capture a systems’ dynamic
behavior  how it organizes itself over time in
response to imposed conditions and stimuli.

Such modeling is required in order to be able to
predict how a system will react to external inputs
and proposed structural changes.
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
27
Components
• A component can be viewed as a system with inputs and
outputs.
• An atomic component an internal structure which dictates
how inputs/states are transformed to outputs.
INTERNAL STRUCTURE
inputs
states
functions
outputs
• components are coupled together to create coupled models
which themselves can be components in larger systems
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
28
Component Discrete Event Dynamics
To capture system’s dynamics, we need to represent its states and
how they change over time, autonomously and in response to
external events::
» Inputs
» States
» Outputs
» Time advance
» Internal Dynamics
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
29
Example of Atomic Component: Repair Shop
A repair shop receives devices for repair from a customer. Each device
requires a certain length of time for it to be repaired. Upon the repair of the
device, it is sent to the customer.
INTERNAL STRUCTURE
new parts
faulty device
DEVS/HLA/CORBA Tutorial
States:
busy
idle
Functions:
seal-crack
replace-part
SIW(fall 2000)
repaired device
order parts
30
Component Discrete Event Dynamics(cont’d)
External Event Transition Function: transforms a state and an input event
into another state
(e.g., when a faulty device arrives and if idle then start repairing It )
Internal Event Transition Function: transforms a state into another state
after the time advance has elapsed
(e.g., given that there are 10 parts available and a broken part
requiring 7 of them, after fixing the broken part, 3 parts will remain.)
Time Advance Function: determines the time to remain in a state
(e.g., schedule an operation to fix a device using available part.)
Output Function that maps a state into an output
(e.g., when the number of parts available falls below a minimum
number, issue an order to restock the part.)
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
31
Example: Coupled Model
Experimental Frame
Generator
Transducer
faulty device
Repair Shop
repaired device
States:
Parts Supplier
new parts
busy
idle
Functions:
seal-crack
replace-part
order
parts
order
parts
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
32
Module 4: DEVS Formalism
 Discrete-event
System Specification
 Basic DEVS for atomic models
 DEVS Coupled Models
 Closure Under Coupling
 Hierarchical Model Construction
The DEVS Framework for M&S








Generic Dynamic Systems Formalism
Well Defined Coupling of Components
Hierarchical Construction
Stand Alone Testing
Repository Reuse
Event-Based, Efficient Simulation
Includes Continuous and Discrete Time Systems
Object-Oriented Implementation
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
34
DEVS Atomic Model
Elements of an atomic model:
 input
events
 output
events
 state
variables
 state
transition functions
 output
function
 timing
function
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
35
Atomic Model Specification
DEVS = < X, S, Y, dint, dext, dcon, ta, l >
X: a set of input events
Y: a set of output events
S: a set of states
ta: S  R+0,  time advance function
dint: S  S internal transition function
dext: Q x Xb  S external transition function
dcon: Q x Xb  S confluent transition function
where Xb is a set of bags over elements in X
Q = {(s,e) | s  S, 0  e  ta(s)}
l: S  Y output function
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
36
Internal Transition Function/Output Function
y
l (s )
s
ta(s)
s’ = dint (s)
DEVS = < X, S, Y, dint, dext, dcon, ta, l >
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
37
External Transition Function
x
s’ = dext (s, e, x)
s
e
ta(s)
DEVS = < X, S, Y, dint, dext, dcon, ta, l >
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
38
Confluent Transition Function
x
s’ = dcon (s, ta(s), x)
s
e
ta(s)
DEVS = < X, S, Y, dint, dext, dcon, ta, l >
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
39
Coupled Model
Elements of coupled model:

Components

Interconnections
– Internal Couplings
– External Input Couplings
– External Output Couplings
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
40
Coupled Model Specification
DN = < X , Y, D, {Mi }, {Ii }, {Zi,j } >
X : a set of input events.
Y : a set of output events.
D : an index set (names) for the components of the coupled model.
For each i  D ,
Mi is a component DEVS model.
For each i  D  self , Ii is the set of influencees of i .
For each j  D  self ,
Zi,j is output translation mapping
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
41
Closure Under Coupling
DEVS
< X, S, Y, dint, dext, dcon, ta, l >
DN
< X , Y, D, {Mi }, {Ii }, {Zi,j }>
DEVS
< X, S, Y, dint, dext, dcon, ta, l >
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
Every DEVS
coupled
model has a
DEVS Basic
equivalent
42
Hierarchical Model Construction
EF
EFA
GEN
TRANSD
EF
ARCH
ARCH
PROC
COORD
PROC
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
43
Coupled Model
gpt
start
start
generator
(genr)
out
in
stop
DEVS/HLA/CORBA Tutorial
out
out
arrived
solved
processor
(proc)
transducer
(transd)
out
SIW(fall 2000)
44
Hierarchical Coupled Model
efP
ef
start
start
start
generator
(genr)
out
out
in
stop
DEVS/HLA/CORBA Tutorial
solved
out
out
arrived
solved
processor
(proc)
transducer
(transd)
out
SIW(fall 2000)
out
45
Experimental Frame/Model Modularity
efP
start
start
out
in
ef
Processor
With
Queue
(procQ)
out
out
out
solved
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
46
Module 5:
DEVS OO Computational Environment
Container Classes
 Object Oriented DEVS
 DEVS Simulator Principles
 DEVS M&S Environments

Heterogeneous Container Class Library
entity
• name?
• equal?
• num_of?
• remove
container
bag
• add
set
• max?
• greater_than?
• remove
• is in?
• size?
• add
• ask_all
• tell_all
order
relation
• add
• remove
• assoc_all?
queue
function
DEVS/HLA/CORBA Tutorial
• add
• remove
• front?
• replace
• assoc?
SIW(fall 2000)
stack
• push
• pop
• top?
list
• insert
• remove
• list_ref?
48
Object-Oriented DEVS Classes
ENTITY
DEVS
ATOMIC
inherits
devs
can hold
DIGRAPH
Legend
CONTAINER
entity
DEVS/HLA/CORBA Tutorial
MESSAGE
content
SIW(fall 2000)
port,
value -> ENTITY
49
Simulator/Simulation Concepts


Simulator is responsible for executing a model’s dynamics
(represented as instructions) in a given formalism.
Abstract simulator is a characterization of what needs to be
done in executing a model’s instructions
– atomic simulator
– coupled simulator


Simulation engines enforce particular realizations of an abstract
simulator
Simulations can be executed as:
– Sequential
– Parallel
– Distributed (sequential/parallel)
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
50
Atomic DEVS Simulator
initialize
tL = 0
tN = ta()
External Event
(Input)
Elapsed
Time
simulation cycle
• tL = time of last event
• tN = time of next event
tL = tN
• Elapsed time enables user to
tN = tN + ta()
inject input into the model
at multiples of elapsed periods
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
51
Coupled DEVS Simulator
initialize
tL = 0
Coupled Model
simulation cycle
tN = ta()
tL = tN
• tL = time of last event
tN = tN + ta()
• tN = time of next event
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
52
Coupled Model Simulation Cycle
1 Compute the global next event time, tN: use reduce to get
minimum of component times to next event (tN)
2 Tell all components the global tN and
if component is imminent (tN == global tN),
then generate output message(using l)
3 Sort and distribute (using coupling) output messages.
4 Tell all components
if component is imminent (tN == global tN )
or has incoming mail (external events)
or both
then execute transition function (deltfunc).
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
53
DEVS Simulation Protocol
1. nextTN
3 getOut
coordinator
Coupled
Model
5 applyDelt
4 getOut
simulator
tN
2. outTN
Component
tN. tL
After each transition
tN = t + ta(), tL = t
DEVS/HLA/CORBA Tutorial
simulator
tN
simulator
tN
Component
tN. tL
Component
tN. tL
NOTE: Component can be a Coupled Model in which
case coordindator would be needed instead of simulator.
SIW(fall 2000)
54
DEVS M&S Environments
An object-oriented computational environment
• based on the DEVS formalism
enabling users to construct
• flexible, complex, and multilevel models
• robust, user-friendly, reusable fashion
and execute them in both
• desk-top and
• distributed simulation platforms
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
55
Module 6: Creating DEVS C++/Java Models
Atomic Models in DEVSJAVA
 Coupled Models in DEVSJAVA
 Examples: Job Processors, EF elements
 Examples: DEVS mapping of explosion
 Hierarchical Models

start
out
stop
Generator
setPeriod
//Constructor for Generator Model
public genr(String name,int Int_arr_time){
super(name);
inports.add("stop");
inports.add("start");
inports.add("setPeriod");
outports.add("out");
phases.add("busy");
int_arr_time = Int_arr_time ;
}
//Output Function: ( l )
public message out( ){
message m = new message();
content con = make_content("out",
new entity("job" + count));
m.add(con);
return m;
}
DEVS/HLA/CORBA Tutorial
Generator Atomic Model
//External Transition Function ( dext )
public void deltext(int e,message x){
Continue(e);
for(int i=0; i< x.get_length();i++)
if(message_on_port(x,"setPeriod",i)){
entity en = x.get_val_on_port("setPeriod",i);
intEnt in = (intEnt)en;
int_arr_time = in.getv();
}
for(int i=0; i< x.get_length();i++)
if(message_on_port(x,"start",i)){
ent = x.get_val_on_port("start",i);
hold_in("busy",int_arr_time);
}
for(int i=0; i< x.get_length();i++)
if(message_on_port(x,"stop",i))
passivate();
}
//Internal Transition Function ( dint )
public void deltint( ){
if(phase_is("busy")){
count = count +1;
hold_in("busy",int_arr_time);
} }
SIW(fall 2000)
57
in
setProcTime
out
Processor
Processor Atomic Model
//External Transition Function ( dext )
public void deltext(int e,message x){
//Internal Transition Function ( dint )
Continue(e);
public void deltint( ){
for(int i=0; i< x.get_length();i++)
passivate();
if(message_on_port(x,"setProcTime",i)){
state = 0;
entity en = x.get_val_on_port("setProcTime",i);
job = new entity("none");
intEnt in = (intEnt)en;
}
processing_time = in.getv();
}
if(phase_is("passive")){
for(int i=0; i< x.get_length();i++)
//Output Transition Function ( l )
if(message_on_port(x,"in",i)){
public message out( ){
job = x.get_val_on_port("in",i);
System.out.println("Output Function " + name);
hold_in("busy",processing_time);
message m = new message();
state = 1;
if(phase_is("busy")){
}
content con = make_content("out",job);
}
m.add(con);
}
con = make_content("outName",new pair(this,job));
m.add(con);
}
return m;
}
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
58
Generator/Processor/Transducer Coupled Model
gpt
start
start
stop
generator
(genr)
out
in processor
(proc)
out
out
arrived transducer
solved
(transd)
out
//Constructor for GPT Model
//create components
atomic am1 = new genr(“Generator”);
atomic am2 = new proc(“Processor”);
atomic am3 = new transd(“Transducer”);
//add components
add(am1);
add(am2);
add(am3);
DEVS/HLA/CORBA Tutorial
//Constructor for GPT Model (Cont.)
//specify couplings
show_state();
Add_coupling(am1,"out",am2,"in");
Add_coupling(am1,"out",am3,"arrived");
….
Add_coupling(am2,"out",am3,”solved");
….
Add_coupling(this,"start",am1,"start");
Add_coupling(am2,"out",this,"out");
SIW(fall 2000)
59
Hierarchical Coupled Model
efP
ef
start
start
start
generator
(genr)
out
out
in
stop
DEVS/HLA/CORBA Tutorial
solved
out
out
arrived
solved
processor
(proc)
transducer
(transd)
out
SIW(fall 2000)
out
60
Hierarchical Modeling (Cont.)
//Constructor for EF Model
Components:
public class EF extends digraph{
• Processor with Queue
• EF
//create components
atomic am1 = new genr(”Generator",procTime, numJobs);
atomic am2 = new transd("transd");
//Constructor for pQEF Model
//Specify Internal couplings
Add_coupling(am1,"out",am2,”arrived");
public class pQEF extends digraph{
//Specify External Input Couplings
Add_coupling(this,”start",am2,”start");
Add_coupling(this,”solved",am2,”solved");
//Specify External Output Couplings
Add_coupling(am1,”out",this,”out");
Add_coupling(am2,”out",this,”out");
….
}
DEVS/HLA/CORBA Tutorial
//create components
digraph cm1 = new EF(”EF",procTime, numJobs);
atomic am1 = new pQ(”ProcessorWqueue");
add(am1);
add(cm1);
//Internal Couplings
Add_coupling(cm1,"out",am1,”in");
Add_coupling(am1,”out",cm1,”solved");
….
}
SIW(fall 2000)
61
Explosion Example
//Constructor for Coupled Model
//create components
atomic bomb = new bomb(“Bomb”);
atomic counter = new counterM(“CM”);
atomic target1 = new target(“Target1”);
atomic target2 = new target(“Target2”);
CM
start
CM
defuse
strike
target
damage
start
damage
defuse
explosion
bomb
//add components
add(bomb);
add(counter);
add(target1);
add(target2);
fuse
strike
target
damage
//specify couplings
addCoupling(this, “start”, bomb, “fuse”);
...
addCoupling(counter, “defuse”, bomb, “defuse”);
addCoupling(bomb, “explosion”, target2, “strike”);
...
addCoupling(taget1, “damage”, this, “damage”);
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
62
Explosion Example (Cont’d)
a)
explosion
defuse
fuse
dormant
Bomb
fuse
live
explode
10
explosion
150
1
dead
defuse
External Transition
Fn
when receive fuse
in phase dormant hold_in(live,5)
when receive defuse
in phase live hold_in(dormant,150)
else continue
Internal Transition
Fn
in phase live
hold_in(explode,1)
in phase explode
passivate_in(dead)
OutputFn
in phase live
output explosion
b)
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
63
Module 7: HLA Basics
HLA Highlights
 Basic HLA terminology
 Federation Rules
 Run-Time Infrastructure (RTI)
 RTI Services

High Level Architecture : Highlights
Support
Utilities
Interfaces to
Live Players
Simulations
Interface
Runtime Infrastructure (RTI)

Simulator interoperability and reuse

RTI implemented in C++,Java,Ada,...

live, simulated

humans, equipment, sensors

DoD mandated standard by 2001
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
65
Some Terminology
Federation:
a set of simulations, a common federation
object model, and supporting RTI, that are used together
to form a larger model or simulation
Federate: a member of a federation; one simulation
– Could represent one platform, like a cockpit simulator
– Could represent an aggregate, like an entire national simulation
of air traffic flow
Federation
Execution: a session of a federation
executing together
Source: Intro to HLA (JDITEC4_98.ppt)
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
66
Some More Terminology
 Object::
An entity in the domain being simulated by a federation that
– is of interest to more than one federate
– is handled by the Runtime Infrastructure
 Interaction:
a non-persistent, time-tagged event generated by one
federate and received by others (through RTI)
 Attribute:
A named datum (defined in Federation Object Model)
associated with each instance of a class of objects
 Parameter:
A named datum (defined in Federation Object Model)
associated with each instance of a class of interactions
Source: Intro to HLA (JDITEC4_98.ppt)
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
67
HLA Object Models and OMT

Federation Object Model (FOM)
– A description of all shared information (objects, attributes, and
interactions) essential to a particular federation

Simulation Object Model (SOM)
– Describes objects, attributes and interactions in a particular simulation
which can be used externally in a federation

Object Model Template (OMT)
– Provides a common framework for HLA object model documentation
– Fosters interoperability and reuse of simulations via the specification of
a common representational framework
Source: Intro to HLA (JDITEC4_98.ppt)
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
68
HLA Specification Elements
• Architecture specifies
- 10 Rules which define relationships among federation components
– 5 for FOM
– 5 for SOM
- An Object Model Template which specifies the form
in which simulation elements are described
- An Interface Specification which describes the way simulations
interact during operation
Source: Intro to HLA (JDITEC4_98.ppt)
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
69
Federation Rules
1 Federations shall have an HLA Federation Object Model (FOM),
documented in accordance with the HLA Object Model Template (OMT).
2 In a federation, all representation of objects in the FOM shall be in the
federates, not in the runtime infrastructure (RTI).
3 During a federation execution, all exchange of FOM data among federates
shall occur via the RTI.
4 During a federation execution, federates shall interact with the runtime
infrastructure (RTI) in accordance with the HLA interface specification.
5 During a federation execution, an attribute of an instance of an object
shall be owned by only one federate at any given time.
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
70
Federate Rules
6
Federates shall have an HLA Simulation Object Model (SOM),
documented in accordance with the HLA Object Model Template
(OMT).
7 Federates shall be able to update and/or reflect any attributes of objects
in their SOM and send and/or receive SOM object interactions
externally, as specified in their SOM.
8 Federates shall be able to transfer and/or accept ownership of attributes
dynamically during a federation execution, as specified in their SOM.
9 Federates shall be able to vary the conditions (e.g., thresholds) under
which they provide updates of attributes of objects, as specified in their
SOM.
10 Federates shall be able to manage local time in a way which will allow
them to coordinate data exchange with other members of a federation.
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
71
Interface Specification
Provides
a specification of the functional interfaces
between federates and the RTI
– Interfaces are divided into six service groups
Each
–
–
–
–
–
–
–
service specification includes:
Name and Descriptive Text
Supplied Arguments
Returned Arguments
Pre-conditions
Post-conditions
Exceptions
Related Services
Application
Programmer Interfaces (APIs) in
CORBA IDL, C++, Ada ’95 and Java
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
72
RTI Components
Federation:
A set of federates interacting via the RTI service and its FOM.
Federate:
A simulation component program and its SOM.
FED (Federation Execution Data) file:
It contains information derived from the FOM and used by the RTI at runtime.
FedExec (Federation Executive):
Responsible for federation management. Enables federates joining and resigning from the
federation as well as facilitating data exchange among participating federates.
RTIExec (RTI Executive):
A global process managing the creation and destruction of federation executives.
RID file:
RTI Initialization Data. This data contains RTI vendor-specific information that is needed
to run an RTI.
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
73
HLA RTI Service Categories
Category
Functionality
Federation Management
Create and delete federation executions
Join and resign federation executions
Control checkpoint, synchronization,
restart
Declaration Management
Establish intent to publish and subscribe
to object attributes and interactions
Object Management
Ownership Management
Create and delete object instances
Control attribute and interaction
publication
Create and delete object reflections
Transfer ownership of object attributes
Time Management
Coordinate the advance of logical time
and its relationship to real time
Data Distribution Mgmt
Supports efficient routing of data
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
74
Module 8: HLA Federation Development
Federation Development & Execution Process (FEDEP)
 HLA Tool Architecture
 OMT
 Object Model Development
 Time management interoperability

HLA Five Step Development Process
Requirements
Definition
Conceptual
Model
Development
Federation
Design
Federation
Integration
and Test
Execute
and Analyze
Results
Source: Intro to HLA (JDITEC4_98.ppt)
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
76
HLA Tool Architecture
Object Model
Development
Tools
Data
Dictionary
Object Model
Data Dictionary
System
FED
RTIs
FOMs
SOMs
FOMs
SOMs
Object Model
Library
DoD Data Stds.
DoD
Data Dictionary
System
HLA Object Model
Integrated Tools Suite
Source: Intro to HLA (JDITEC4_98.ppt)
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
78
Object Model Development
HLA Object Models:
• Describe Federate (Creating HLA SOM)
PURPOSE: provide federate’s intrinsic capabilities
(Note: Other means such as DEVS are needed to describe dynamics)
• Describe Federation (Creating HLA FOM)
PURPOSE: provide inter-federate information exchange specification
HLA Object Model Elements:
• object model identification
• object class structure
• interaction class structure
• attributes
• parameters
• routing space
• SOM/FOM lexicon
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
79
Sample OMT Tables
Object Class Structure Table
Customer (PS)
Bill (PS)
Order (PS)
Employee (S)
Food (S)
…
Greeter (PS)
Waiter (PS)
Cashier (PS)
Dishwasher (PS)
Cook (PS)
Main_Course (PS)
Drink (S)
Interaction Class Structure Table
Customer_
Emploee_
Transactions (I)
Appetizer (S)
Water (PS)
Coffee (PS)
Soda (PS)
Soup (S)
…
…
DEVS/HLA/CORBA Tutorial
…
Order_Taken_From_
Customer_Seated (IS) Kids_menu (I)
Order_Taken_From_
Clam_Chowder (S)
ManhattanAdult_menu
(PS)
(I)
Order_Taken (I)
Drink_Served
(I)
New_England
(PS)
Appetizer_Served (I)
…
…
SIW(fall 2000)
80
Object Model Development
HLA Object Models:
• Describe Federates (Creating SOM)
other means are needed to describe federate design and functionality
• Describe Federation (Creating FOM)
inter-federate information exchange
Attributes & parameters
Object classes
Interaction classes
Information model contract
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
81
Challenge: Time Management Interoperability
training federate:
real-time execution
Run Time
Infrastructure (RTI)
constructive federate:
time-stepped
execution
Run Time
Infrastructure (RTI)
constructive federate:
event driven execution
Run Time
Infrastructure (RTI)
parallel simulation federate:
optimistic Time Warp
execution
live component:
real-time execution
w/ hard deadlines
Run Time
Infrastructure (RTI)
Run Time Infrastructure
(RTI)
multiprocessor
Goal: provide services to support interoperability among federates with
different local time management schemes in a single federation execution.
Observation: RTI by itself cannot guarantee interoperability.
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
83
Message Ordering Services
The baseline HLA provides two types of message ordering:
• Receive Order: messages passed to federate in order of reception
• Time Stamp Order (TSO): successive messages passed to federate have non-decreasing
time stamps
Property
Latency
Reproduce before and after
relationships?
All federates see same
ordering of events?
Execution repeatable?
Typical applications
Receive
Order
Time Stamp
Order (TSO)
low
higher
no
yes
no
yes
no
yes
training, T&E
analysis
 Receive
order minimizes latency, does not prevent temporal anomalies
 TSO prevents temporal anomalies, but has somewhat higher latency
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
84
Module 9: DEVS/HLA Requirements
 HLA-compliant
M&S environment
 support
model construction in C++/Java
 support
for FEDEP
 integration
with HLA Tool Architecture
 layered
architecture for flexibility
 support
for time management, logic and real time integration
user orientation: shield user from HLA programming
DEVS/HLA Support for FEDEP
DEVS/HLA
Requirements
Definition
Conceptual
Model
Development
Federation
Design
Federation
Integration
and Test
Execute
and Analyze
Results
Source: Intro to HLA (JDITEC4_98.ppt)
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
86
DEVS/HLA Mapping Approach
DEVS coupled model
* structure definition
* component
~ attributes quantization
* coupling
RTI-C++
OMDT
Object
•Declaration
•Initialization
•Registration
•P/S
* State Updating
DEVS/HLA/CORBA Tutorial
* Interactions
SIW(fall 2000)
Metadata
Classes
Attributes/Data Types
Interactions
88
DEVS Components as HLA Federates
Internal transition function
Internal transition function
External transition function
External transition function
Output function
Output function
DEVS
Federate
DEVS
Federate
RTI
Ambasador
RTI
Ambasador
Network
Fedex
DEVS/HLA/CORBA Tutorial
RTI
Executive
SIW(fall 2000)
Run
Time
Infrastructure
89
DEVS Distributed Simulation Layers
Layer Alternatives (DEVS/HLA etc)
DEVS-C++
DEVS
DEVSJAVA
Parallel/ Parallel
DistributedDEVS
Time Warp
Simulation
ProtocolProtocol
Simulation
Middleware
CORBA
HLA/RTI
WAN-Internet
Network
LAN Cluster
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
90
Time Management Integration & Migration
High performance
component
Operator Training:
fast enough
real-time
PC workstation
component
live component:
real-time execution
w/ hard deadlines/windows
RTI
Migration -- successively convert components of model
from discrete event simulation to real time execution
Integration -- enable real time execution to inter-operate
with discrete event simulation
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
91
DEVS/HLA High Level Automation Features
DEVS/HLA Automates it:
Category
Federation Management
Declaration Management
Yes
Yes
Create and delete federation executions
Join and resign federation executions
Control checkpoint, synchronization, restart
Establish intent to publish and subscribe
to object attributes and interactions
Create and delete object instances
Object Management
Yes
Control attribute and interaction publication
Create and delete object reflections
No
Transfer ownership of object attributes
Time Management
Yes:
No:
Coordinate the advance of logical time
and its relationship to real time
Data Distribution Mgmt
Yes
No:
Ownership Management
DEVS/HLA/CORBA Tutorial
Quantization and Predictive Filtering
Support efficient routing of data: HLA Routing Space
SIW(fall 2000)
92
Module 10: DEVS/HLA Design and
Implementation
 augmented
class hierarchy
 interaction/updates
 DEVS
simulation protocol
 migration
and integration with real time
DEVS/HLA Class Hierarchy
entity
Federate
Ambassador
attribute
Devs
quantizer
DevsFedAmb
Coupled
Digraph
Atomicbase
Atomic
port
HLAport
Federate
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
94
Quantization and Attribute Updating
Quantization is the
mechanism used to
automatically execute
attributed updating
Update triggered at
threshold crossing
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
95
DEVS/HLA:Pursuer-Evader Model
Object
class
Evader Federate
Pursuer Federate
Red Tank
Red Tank
Evader
(Endo Model)
position
position
in
out
out
in
perceive
Blue Tank
fireout
drive
firein
fire
state update : quantized attribute (position)
interaction: HLA port (fire ) + coupling
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
96
Pursuer-Evader Model:Adding Viewer
EvadWEndo
PursWQuant
Red Tank
position
in out
out in
Red Tank
Endo Model
Evader
position
perceive
fireout
drive
Blue Tank
firein
Blue Tank
update(quantized attribute)
interaction(HLA port coupling)
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
Red Tank
Transducer
Viewer
97
Attribute Communication
Send Federate
Devs
Receive Federate
Attribute
Attribute
attrRtiId
quant
value
attributeList
attrRtiId
Devs
attributeList
value
quantizer
value
Attribute Message
attrRtiId
value
size
Receive Attribute
Interface
Send Attribute Interface
Attribute Set Message
attrRtiId
size
Attribute Set
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
98
Interaction Communication
Send Federate
Receive Federate
Devs
Devs
Devs Message
myDevs
port
address
value
Receive Interaction
Interface
Send Interaction
Interface
Interaction Message
myClassId
DEVS/HLA/CORBA Tutorial
Parameters
time
SIW(fall 2000)
tag
99
DEVS Distributed Simulation Layers
DEVS
Parallel/ Distributed
Simulation Protocol
Middleware
Network
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
100
DEVS/HLA Simulation Protocol
Create/join federation
Compute
input/output
Initialization
Send interactions
create models
add coupling
setup object / interaction comm.
Initialize time
timeAdvGrant
Execute
transition functions
TRUE
DEVS cycle
Update Attributes
FALSE
Event process
DEVS/HLA/CORBA Tutorial
Request next time
timeAdvGrant=FALSE
SIW(fall 2000)
Time advance
101
Communication Protocol between DEVS and RTI
Devs
RTI
Create Fed. Execution
Join Fed. Execution
Federation Execution
- Publish/Subscribe
- Register
Models
Create Models
Setup Coupling
initialize
Publish Object Class
Register Object
Pub/Sub Attributes
Pub/Sub Interaction
DevsRtiId
instanceId
attrRtiId
myClassId,myParamId
Initialization
phase
Federation
Time Advance
DEVS/HLA Tutorial
University of Arizona (1998)
102
Communication Protocol between Devs and RTI
Federation Execution
- advance Time
- update Attributes
- update Interactions
Cyclic Execution
Phase
Time Advance Req
Grant Time
Time Advance
Devs Internal Cycle
Update/reflect Attr.
Update/receive Inter.
Discover Object
Update
Update Attributes
Update Interaction
instanceId
Time Advance Req
(infinite)
Termination Req
Terminate Comm.
Delete Models
Termin Termin
ate
ate
Fed. Ex. Devs
- compute input output
- internal transition
- external transition
- quantize attributes
Resign Fed. Execution
Destroy Fed. Execution
DEVS/HLA Tutorial
University of Arizona (1998)
103
DEVS/HLA Simulation Protocol
Create/join federation
Compute
input/output
Initialization
Send interaction
create models
add coupling
setup object / interaction comm.
Initialize time
timeAdvGrant
Execute
delta function
TRUE
DEVS cycle
Send Attributes
FALSE
Event process
DEVS/HLA Tutorial
Request next time
timeAdvGrant=FLASE
University of Arizona (1998)
Time advance
104
DEVS Cycle LogicFor Cancellation-Free DEVS
When receive timeAdvGrant(grantTime){
interactions = Output_funct();
Send interactions with time-stamp grantTime + epsilon;
Int_tr_funct()
; = grantTime; tN = grantTime + time_adv_funct();
tL
Send timeAdvanceRequest (tN); Send tick();
apply quantizers to variables
Send updateAttributeValues;
}
When receive reflectAtributeValues{
}
update variables
When receive interactions (current
Extract
input x from
time)
{
interactions
e = current time - tL
tL = current time; tN = current time + time_adv_funct();
Ext_tr_funct(e,x);
Send timeAdvanceRequest (tN); Send tick();
apply quantizers to variables
Send updateAttributeValues;
}
DEVS/HLA Tutorial
University of Arizona (1998)
105
DEVS/HLA Simulation ProtocolProblem with Cancellation Behavior
F1
NER(t1)
t1
TAG(t1)
t1
F1
F2
NER(t2)
t2
F2
t1+g
b)
a)
1
F1
NER(t1’)
F1
RTI Time Req’t
F2
F2
NER(t2’)
DEVS/HLA tutorial
c)
SIW, 99
2 NER(t2’)
d)
University of Arizona
Deadlock for communicating imminents
F1
NER(t1)
t1
F1
t1+g
F2
t1
NER(t2)
F2
TAG(t1)
t1+g
NER(t1’) where t1’ depends on
F2’s inputs so can’t immediately be
sent as required
t1+g
t1+g
F2
NER(t2’)
c)
DEVS/HLA tutorial
NER(t2)
b)
a)
F1
TAG(t1)
SIW, 99
University of Arizona
A Solution: DEVS w/Cancellation based on
DEVS w/out Cancellation
DEVS with Cancellation
DEVS without Cancellation*
HLA/RTI
* is constrained by: ta(deltext(s,e,x)) = ta(s) - e
for all s,e,x.
DEVS/HLA tutorial
SIW, 99
University of Arizona
Implementing DEVS Protocol in HLA Using Quantizers
Federate B
Time Manager
Federate A
System Models
System Models
CoordinatorEndo
Coordinator
tN
SimulatorEndo A
tN2
System Models
CoordinatorEndo
tN
Simulator A
Simulator B
tN1
User Models
Model
A
Model
B
RTI Exec
DEVS/HLA/CORBA Tutorial
User Models
SimulatorEndo B
Model
C
Fedex
SIW(fall 2000)
Model
D
tN : Global DEVS Time
tNi : Time of Next Event
of Federate i
109
Implementation (cont’d)
t1
n
Federate 2
Coordinator
n+0.1
Compute Input/Output
Send Interactions
n+0.2
Execute Transition Functions
Update Attributes
n+0.3
Send local time of next event
(tNi) of the ith Federate
n+1
DEVS Time (Simulation time)
Federate 1
RTI Time (Simulation Cycle)
Coordinator tells Global
DEVS time (tN)
t2
Coordinator receives local
times of next events (tNi)
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
112
Migrating DEVS Models to Real Time Operation
DEVS-RT
DEVS
Par DEVS
Sim. Protocol
DEVS-RT-Simulator
HLA/RTI
Real Time RTI
Network
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
113
Module 11: Creating Federations in
DEVS/HLA




DEVS/HLA Development Process
C++ DEVS/HLA Component Templates
User Interface to DEVS/HLA
Examples: Pursuer/Evader C++ Implementations
DEVS/HLA Development Process
• develop DEVS-C++ (or Java)
atomic and coupled models
• store in model base
Requirements
Definition
Conceptual
Model
Development
Federation
Design
• decide mapping models to federates
• wrap models as Federate instances
• add HLA ports for inter-federate interaction
• add objects and attributes for state updates
• add predictive contract mechanisms
Federation
Integration
and Test
• test Models in stage-wise
• bottom up fashion on workstation
• test federates
• test federations
Execute
and Analyze
Results
• compile model federate objects
• locate federates on network nodes
• start coordinator federate
• start model federates
Source: Intro to HLA (JDITEC4_98.ppt)
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
115
User Interface to DEVS/HLA
Done by User
Start main( )
Create FederateDEVS(FederationName)
Run FederateDEVS
Done by DEVS/HLA
Run Federate
run( ) of Federate
Initialize models
Start DEVS simulator
End of main( )
Constructor of FederateDEVS
End of run( )
Constructor of Federate
Constructor of Federate
Constructor of FederateDevs
Create RTIAmbasador
Create DEVS Models
Add them as components
Execute Federation
for interaction comm.
Constructor of Federate
Create HLAports
set up HLAports
Coupling ports
for attribute comm
Create object classes
Create their attributes
set up classes and attributes
Link these to DEVS models
executeFederation() of Federate
Create Fedex
Join Fedex
Set Time Management Parameters
End of executeFederation()
End of constructor( )
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
116
DEVS/HLA Model Templates
main
Federate *myFederate
main( ) {
........
}
FederateDevs
Public:
set *components;
set *classComponents;
devsModel
Public:
static char *classname;
/* Create FederateDevs */
myFdereate = new FederateDevs(federationName);
/* Run FederateDevs */
myFederate->run ( );
/* Create instance of DEVS */
add (new devsModel (TopModelName));
/* Specify Interaction Communication */
/* for each interaction */
HLAport *hp = new HLAport (portName);
add_outport(hp); or add_inport(hp);
setup(hp);
/* Specify Attribute Communication */
/* for each object class */
objectClass *oc = new objectClass(“atomicClassName”);
/* for each attribute */
oc-> addAttribute (new attribute (…) );
classComponents->add(oc);
setup(oc); /* setup env. for comm. atomic model */
/* Create component models */
setAtomicClassName( “atomicClassName”);
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
117
DEVS/HLA Example:
Pursuer-Evader-Viewer Model
FederatePursWQuant
PursWQuant (DEVS comp)
FederateEvadWEndo
RedTank
RedTank
EndoModel
(DEVS comp)
(DEVS comp)
Sample code for a Federate
// constructor of FederatePursWQuant
// create the highest component
RedTkObj
position
position
PursWQuant *PWQ = new PursWQuant(“PursWQuant”);
Blue Tank
fireout
// create objectclasses and register them to RTI
fire
objectClass *RedTKObj = new objectClass(“RedTank”);
firein
position
RedTKObj->addAttribute(new
attribute(“position”,0,NULL);
setUp(RedTKObj);
BlueTank
// setup HLAport
HLAport *hp = new HLAport(“fire”);
addOutport(hp); setUp(hp);
Red Tank
// coupling
addCoupling(PWQ, “fireout”, this, hp);
DEVS/HLA/CORBA Tutorial
Viewer
SIW(fall 2000)
update(quantizer)
interaction(coupling)
118
DEVS/HLA Example:
Pursuer Model
PursWQuant
Red Tank
myPosition
in
out
out
in
Driver
fout fireout
// Constructor of PursWQuant
// create components
RedTank *redtank = new RedTank (“RedTank”);
Driver *drver = new Driver (“Driver”);
// add components
add (redtank);
add (drver);
// define interfaces (couplings)
addCoupling (redtank, “out”,driver,”in”);
addCoupling (drver, “out”,redtank,”in”);
addCoupling (drver, “fout”,this,”fireout”);
// constructor of RedTank
// create quantizers and attributes
quantizer *qt = new quantizer(name,initValue, quantum);
attribute *at = new attribute(“position”, &myPosition, qt);
attributeList->add(at);
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
119
Module 12: Basic CORBA Concepts
CORBA - Common Object Request Broker Architecture
 Basic Features and Services
 Interfacing to Objects
 Connecting to Distributed Objects via Naming Service
 Event Channel and Real Time CORBA
 Interoperability of Vendor Orbs
 CORBA relative to other middleware

CORBA Basic Features and Service
CORBA:
• an open standard for distributed object computing
• defines a set of components that allow client applications to invoke
operations with arguments on remote object implementations
CORBA
F eatu re
L anguageneutral
D ata T ypes
L ocal/rem ote
T ransparency
H igh
B inding
L evel
S elf D escribing
M eta D ata
CORBA
S ervices
DEVS/HLA/CORBA Tutorial
B rief D escrip tion
M arshalling and de-m arshalling of m ethod argum ents
greatly sim plify m essage ex change am ong objects
over the netw o rk
O bjects can com m unicate in the sam e w ay w h ether
on a single processo r or over a netw o rk betw een
processors w ith different bit-lev el architectures
U se of ID L interfaces enables objects expressed in
arbitrary langu ages to com m unicate w ith each other
and easy w rapping of legacy cod e.
C O R B A offers access to con figuration m eta data
N am e service, E vent S ervice, T im e S ervice,
provide utilities for distributed com puting
SIW(fall 2000)
etc.
121
CORBA Overview (See Notes Below)
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
122
Language Transparency Via Interface
OBJECT
invocation
interface
CORBA
IDL
(Interfacce
Definition
Language)
DEVS/HLA/CORBA Tutorial
servant
Internal call
SIW(fall 2000)
Implementation
--C++
--Java
123
Example: Object Invocation Via Interface
//C++
//java
class Counter {
int i;
omg.omg.CORBA.Counter c;
//get reference to c via
//naming service using “cntr”
int i
//methods
getCount
= c.getCount();
public:
int getCount(){return i++;}
};
main (){
Counter c = new Counter(“cntr”);
//give reference to naming
//IDL
//service
Module Example{
}
interface Counter{
int getCount()
};
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
124
Connecting to Objects Through Naming Service
• initialize ORB
• create new objects
and connect to ORB
• get reference to
naming service
Client
• register objects
with naming service
Server
• get references to
server objects via
their names
ORB
ORB
The Naming Service allows clients to find
objects based on names using Naming
Context specification --providing object
location transparency.
DEVS/HLA/CORBA Tutorial
Naming Service
SIW(fall 2000)
125
Common Object Service (COS) Event Service
Event
consumer
Event
consumer
Event
supplier
Event
supplier
Event Channel 1
Event Channel 2
CORBA Event Service
• The Event Service provides basic asynchronous communication in
ORB, de-coupling event suppliers from the event consumers.
• The supplier-consumer model allows an object to communicate an event
to any other objects that might be interested in such an event.
• Both “pull” and “push” communication mechanism are specified.
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
126
CORBA Real Time Event Service
Event
consumer
Event
consumer
Event
supplier
Event
supplier
Event Channel
Real-Time Event Service
Scheduling Service
• part of Real-Time CORBA Specification
• events go through one channel
• filtering at consumer is done by producer id
• priority and urgency-scheduling is supported
•ACE (Adaptive Communication Environment)
TAO provides End-to-End QoS
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
127
Example of CORBA Interoperabilty: TAO Real-Time ORB’s
work with Visibroker ORB’s
Naming
Service
Time
Service
Event
Service
Client
Server
Visibroker
ORB
Visibroker
ORB
TAO (The ACE ORB)
CORBA
ACE
NETWORK
Internals of services are not standardized, but ORBs can use other ORBs services
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
128
CORBA in relation to other Middleware

Java
– Java Virtual Machine (JVM)
» cross platform interoperability
– JINI technology
» alternative middleware to CORBA
– both require Java as the primary programming language
– can work with CORBA

» to provide convenient development environment (e..g
Visiboker)
» to support lower layer to set up CORBA run-time
environment
DCOM
– For Microsoft components
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
129
Module 13: DEVS/CORBA Requirements,
Design and Implementation
 DEVS/CORBA
 Requirements
 DEVS
Overview
for Distributed Simulation/Execution
and CORBA: complementary match-up
 DEVS/CORBA
 Applications
Design and Implementation
Basic DEVS/CORBA Overview
DEVS :
- Discrete Event System Specification
- Sound formal modeling and simulation framework
CORBA:
- Common Object Request Broker Architecture
- Open standard as a middleware (network software)
DEVS/CORBA:
- Parallel and distributed M&S environment
- Improves performance (computing power, execution speed )
- Provides high scalability and availability (infinite resources)
- Lowers the cost of development
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
131
Requirements for DEVS/CORBA Distributed
Simulation Environment
• Open, Expressive Environment
• Distributed/Networked (Intra/Inter)
• Model Reuse
• Scalable Performance
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
132
Requirements for DEVS/CORBA Distributed Real
Time Execution Environment
• Include Simulation as subset
• Interact with other business objects
• Extend to Real time control/management
• Model Continuity thru Development Phases
• Simplify Distributed Programing and Set-up
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
133
Requirements for DEVS/SES/CORBA
• Hierarchical federations
• Heterogeneous Federations: Logical, Real-time, speed-ahead
• Implement SES at CORBA level
• Automated mapping of pruned SES to hierarchical federations
• Automated distribution of components
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
134
DEVS and CORBA: The Match
DEVS : a generic dynamic simulation formalism
CORBA: a generic IDL for concretizing DEVS
CORBA
F eature
L a ngua gene utra l
D ata T ypes
L oca l/re m ote
T ra nspare nc y
H igh
L e ve l
B ind ing
S e lf D escrib ing
M eta D ata
CORBA
S ervices
B enefit for D E V S Im p lem e n ta tion
T o gethe r w ith co nta iner spec ificatio n, this ca n pro vide a
la ngua ge ne utra l fo rm o f D E V S m ode l specificatio n
S uppo rts D E V S -based sim ulatio n o ve r hetero ge neo us
platform s
U se of ID L interfaces ena b les coup ling o f
D EV S
co m po ne nts in arb itrary la ngua ges a nd D E V S -based
w rapp ing o f le gac y code.
C O R B A o ffe rs access to configuratio n m eta data that m a y
be exp lo ited for unde rsta nd ing m o de l behav ior a nd
m o nito ring s im ula tio n pro gress.
N a m e service, E ve nt S e rvice, T im e S ervice, etc. offe r
functio na lity fo r inte gratio n into D E V S /C O R B A
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
135
DEVS/CORBA Implementation
SimEngine
FederationManager
Federation
CoordinatorImpl
SimulatorImpl
System
ActivatorImpl
Deployer
Daemon
DEVSNamingService
Launcher
Util
ObjectSerializer
IOProcess
Semaphore
StreamThread
IDL
AnyPort
Component
DEVSCorba
= Java
Packages
DEVS/HLA/CORBA Tutorial
Examples
SIW(fall 2000)
136
DEVS/CORBA Implementation
data messages
Simulator
Simulator
(ModelServer)
Genr
Simulator
(ModelServer)
in
out
Proc
out
(ModelServer)
ariv
solved
Transd
Network
Control messages
CORBA
Name Server
-----------------ORB
GPT
DEVS/CORBA Interfaces
DEVS models
Coordinator
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
137
Example: Distribution over Internet
Coordinator
Simulators
GPT
Genr
Proc
Transd
Coord
Thread
Internet
CORBA
Name Server
-----------------ORB
DEVS/HLA/CORBA Tutorial
LAN
LAN
ORB
SIW(fall 2000)
138
Distributed Real-Time DEVS Execution Environment
SEARCH
DEVS
DEVS Processors/Activities
RT-DEVS Execution Engine
Simulation/
execution
layer
ACE-TAO CORBA
Network
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
139
Mapping DEVS coupling to COS EventService
Genr
Proc
stop
out
Event
consumer
Event
supplier
out
in
Event
consumer
Transd
Event
supplier
ariv
solv
stop
Event
Event
Event
consumer
consumer
supplier
Event Channel 1
Event Channel 2
Event Channel 3
CORBA Event Service
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
140
Coupling Mapping with TAO’s
Real-Time EventService
Genr
Proc
stop
out
Event
consumer
Event
supplier
out
in
Event
consumer
ariv
solv
SourceID 2
SourceID 1
stop
Event
Event
Event
consumer supplier
consumer
Event
supplier
SourceID 1
SourceID 3
Transd
SourceID 1
SourceID 3
Source
ID 2
Event Channel
Real-Time Event Service
Scheduling Service
Events are filtered by the associated SourceID
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
141
Migrating Simulation Models to Real Time Operation
DEVS
DEVS-RT
Par DEVS
Sim. Protocol
DEVS-RT-Simulator
Visibroker CORBA
TAO CORBA
ACE Real Time
Network
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
142
Real-Time DEVS Formalism Implementation
• activity: a wrapper class that specifies a job to be done, the
time it requires, and the result (where the latter may be
computed as a result of execution)
• the base class specifies the parameters explicitly
• procActivity: a devs model that can execute an activity as
just described
procAlwaysActivity
atomic
entity
procActivity
~ activity
~processing_time
~result
~ alwaysActivity
inputActivity
~myDevs
~resultMessage
~passivate
• alwaysAcivity: an activity that can be continually
executed
• procAlwaysAcivity: processor for alwaysAcitivty
that outputs its message
• inputActivity: an activity for responding to
external events
DEVS/HLA/CORBA Tutorial
simActivity
~tN
~myModel
~resultMessage
• simActivity: an activity that is given
a devs model. The model is executed
until its first non-null output is
obtained, which is the result of
execution; the actual real time to
execute is the time of the activity
• simStepAcivity: an activity that is
executed
stepwise fashion
SIW(fallin
2000)
simStepActivity
~tL
~iter
143
Real-time Execution of Parallel Search
parSearch
makeProc
procActivitys
procActivity
compActivity
• parSearch : coupled model for parallel search. SimActivity
instances can be alternative devs models generated by
automatically pruning an SES (or generated in some other
manner)
~ activity
simActivity
~myDevs
•makeProc : gets activity instances as inputs and creates
procActivity instances to work on them
•compActivity : gets processed activities with their results and
keeps track of the best so far, using metric specified in the
activity. Outputs the best so far when its allowed time has
elapsed.
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
144
Interoperation between TAO Real-Time ORB’s
and Visibroker ORB’s
Naming
Service
Time
Service
Event
Service
Coordinator Simulator
Visibroker
ORB
Visibroker
ORB
Simulator
Visibroker
ORB
TAO (The ACE ORB)
CORBA
ACE
NETWORK
- ACE (Adaptive Communication Environment) Layer provides End-to-End QoS
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
145
DEVS-CORBA Naming Tree
DEVSCORBA
Federation
Manager
Activator@
128.196.29.12
Activator Pool
Activator@
128.196.29.17
Federation Pool
GPTFed
Coord Genr Proc Trans
@GPTFed
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
TerraFed
Coord TS TS”
@TerraFed
146
DEVS-CORBA Naming Repository
GPT Federation :FastSimulation
DEVS-CORBA Federation Pool
FedName
GPTFed
FactoryFed
Components
[email protected]
Genr
Proc
Trans
Transd
FastSim
Coordinator
FastSimulation
Proc
FastSim Simulator
[email protected]
TS1
TS2
TS3
EF
NSFFed
Genr
Type
[email protected]
RT1
RT2
RT3
[email protected]
RTExecution
FactoryFederation: RTExecution
TS1
TS2
RTExec
Coordinator
RTSimulation
TS3
EF
RT Exec
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
147
Run Time System (RTS) Setup
DEVS
Naming and Directory
Service
1
2
run
RTS
acims4.acims.arizona.edu
daemon
Build
DEVS
NDS
Activator
simulator
simulator
simulator
acims11.acims.arizona.edu
RTS Manager
3
.hosts
daemon
DEVS/HLA/CORBA Tutorial
simulator
simulator
simulator
pisces.acims.arizona.edu
Read a file
containing
host addresses
acims4.acims.arizona.edu
acims11.acims.arizona.edu
pisces.acims.arizona.edu
Activator
4
daemon
Activator
simulator
simulator
simulator
Create a daemon
for a processor
(using Java rsh)
Create an activator
Create
Simulator pool
SIW(fall 2000)
148
Deploy a Model to Federation
Activator
@acims4
G
Simulator
(G)
4
DEVS-CORBA
Naming
Service
G
User
GPT
Federation
Reference
P
Activator
@acims11
T
Activator
@pisces
1
Deploy(gpt)
DEVS/HLA/CORBA Tutorial
2
Model
Partitioning
And
Dispatching
P
T
Simulator
(P)
Coord
@GPTFed
Simulator
(T)
5
3
Assign a model
to a simulator
SIW(fall 2000)
Bind to
DEVS-CORBA
Naming Service
register simulators
to coordinator
Host
Boundary
149
Hierarchical Heterogeneous Federations
FastSimulation
Alternative
1
RTExecution
Candidate Schedules
Best Schedule
Alternative
n
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
Supervisor
Factory
Component
Model
150
Real-time, simulation-based control
Simulate
faster then real-time
Observe in real-time
control
Real world
Parameter
settings
DEVS/HLA/CORBA Tutorial
Model
Recommended
values
SIW(fall 2000)
151
Real-time, simulation-based control (cont’d)
summaries
Control
Factory
commands
DEVS/CORBA
DEVS/HLA/CORBA Tutorial
Son, Y., et al. (1999).A Multi-Pass Simulation-Based, Real-Time Scheduling
and Shop Floor Control System. Trans. of SCS 16(4): 159-172.
SIW(fall 2000)
152
HLC (High Level Control):
• starts gpt and gptEndo with same conditions and thruput goal
(gptEndo is executed faster than real time via simulation)
• waits for LLC in gptEndo to reach desired thruput and sends
setting back to LLC in gpt
Desired
Thruput
GPT Example executed in
DEVS/CORBA Real-Time
Environment
gpEndo
Genr
Proc
Transd
LLC
HLC
gpt
Genr
Proc
DEVS/HLA/CORBA Tutorial
Transd
LLC
SIW(fall 2000)
LLC (Low Level Control):
• queries Transd for TA and Thru
• incrementally adjusts Genr rate and Proc
#machines toward given thruput goal
• Transd represents online DB
153
Module 14: System Entity Structure
Hierarchical Model Construction
EF
EFA
GEN
TRANSD
EF
ARCH
ARCH
PROC
COORD
PROC
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
155
Hierarchical Coupled Model
efP
ef
start
start
start
generator
(genr)
out
out
in
stop
DEVS/HLA/CORBA Tutorial
solved
out
out
arrived
solved
processor
(proc)
transducer
(transd)
out
SIW(fall 2000)
out
156
SYSTEM ENTITY STRUCTURE
EFA
EFA-DEC
decomposition
ARCH
EF
ARCH-SPEC
EFA-DEC
MULT
GENR
TRANSD
specialization
PROC
MULT-DEC
COORD
multiple
PROCS decomposition
PROC
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
157
EFA
Generating Family of Models
EFA-DEC
EF
ARCH
ARCH-SPEC
PRUNING
EFA-DEC
EFA
MULT
GENR
EFA-DEC
PROC
TRANSD
MULT-DEC
COORD
PROCS
ARCH-SPEC
EFA-DEC
PROC
EFA
ARCH
EF
PROC
EF
GENR
TRANSD
GENR
TRANSD
TRANSFORMING
PROC
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
158
Module 15: Collaborative/Distributed DEVS M&S
Environment
Distributed Modeling
 Conceptual View for Collaborative/Distributed M&S

HLA/OMT vs. DEVS/SES
H L A /O M T
DEVS
S y s te m E n tity
S tru c tu re
SOM
A to m ic M o d e l
N /A
FOM
C o u p le d M o d e l
D e co m p o sitio n
N o t su p p o rte d
N o t su p p o rte d
S p e cia liza tio n & A sp e ct
R o u tin g
P a rtia l ro u tin g
N o t su p p o rte d
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
160
HLA/Object Model Template
Federate A
Federate B
Dynamic Model
Dynamic Model
Simulation Engine
HLA/OMT:
FOM & SOM
RTI
Simulation Engine
RTI
Network
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
161
Collaborative DEVS Modeling
Structure
Frame (CDM)
+
Dynamics
DEVS
Model
(DEVS/HLA)
Legend
yields
HLA
Object Model
DEVS/HLA/CORBA Tutorial
translates into
SIW(fall 2000)
162
DEVS/HLA Simulation Scenario




Setting: A Mountainous region of Yugoslavia.
Objective: Maintain a track on the hyper-velocity Red Tank.
Platform: Blue Helicopter is a standard variable speed air vehicle.
 Equipped with a Ku band radar sensor with a constrained field of regard.
Environment Models: Tank traverses the surface of a 1km resolution global terrain database.
Space Manager
(Emission Propagation)
emissions
quantized
Red Tank
Pitch/Altitude
Updates
HLA
Endomorphic
Red Tank
Start/stop @ sensor scan rate
GRASS
GIS
DEVS/HLA/CORBA Tutorial
Blue
Helicopter
Logger
(Spatial Event Prediction)
Start/stop
Log-in messages
High-Resolution
Terrain
SIW(fall 2000)
163
DEVS/HLA Federates
radar
propagated
radar
emission
radar
propagated
TANK
radar
return
elevation
radar
return
EMMISION
PROPAGATION
radar
return
Attributes:
• position
• pitch
position
elevation
TERRAIN
radar
return
estPosition
HELICOPTER
radar
emission
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
164
Experimentation with Model
position
estPosition
DEVS/HLA/CORBA Tutorial
track quality
EXPERIMENTAL
FRAME
SIW(fall 2000)
165
Alternative Federations
TANK
TANK
TERRAIN
TERRAIN
DEVS/HLA/CORBA Tutorial
Endo
TANK
Endo
TANK
EMMISION
PROP
EMMISION
PROPAGATION
SIW(fall 2000)
HELI
COPTER
HELICOPTER
166
Modeling
Simulation
UA
Tucson, AZ
H o st N a m e
P isc e s
L o c a tio n
T u c so n
P o rt
12357
IP A d d re ss
1 2 8 .1 9 6 .2 7 .9 6
…
…
UA
RTI-Executive
UA
Tucson, AZ
STOP
Suspend
GO
UA Federate
DEVS/HLA
Simulator
Collaborative DEVS Modeler
(HLA/OMT)
H o st N am e
N ex u s
L o catio n
S u n n y v ale
P o rt
12357
IP A d d ress
x x x .x x x .x x .x x
…
…
DEVS/HLA/CORBA Tutorial
LMSS
Sunnyvale, CA
LMSS Federate
STOP
Suspend
GO
SIW(fall 2000)
167
CDM & DEVS/HLA Scenario
Distributed
Simulation
Network
Federate LMMS
(Simulation Federate)
UA/LMMS
Simulation Federation
Federate YVPG
(Simulation Federate)
Federate UA
(Simulation Federate)
UA/YVPG
Simulation Federation
Federate UA
(Simulation Federate)
Collaborative
Modeling
Model (Aircraft)
Model (Radar)
DEVS/HLA/CORBA Tutorial
DEVS/SES
SIW(fall 2000)
Model (Terrain)
Model (Aircraft)
168
Component-based M&S Architecture
CDMS Environment
Model Composition
Analysis
Model Construction
Auxiliary Components
(e.g., Genetic Algorithm)
DEVS/DESS Simulation
DEVS/DESS Modeling
Collaboration
Environment
Distributed
Object Management
Database (Persistence
Object Store)
Hardware (Computing)
Platforms
DEVS/HLA/CORBA Tutorial
Graphical User
Interface
Network
SIW(fall 2000)
169
Basic Modes of Collaboration
Place
same
same
Time
conventional
meeting
synchronous
collaboration
asynchronous
collaboration
different
DEVS/HLA/CORBA Tutorial
different
SIW(fall 2000)
170
Collaborative Model Construction
clarify
objectives
CM
collect
data
Distributed
Source
build
model
CM, SC, AC
validate
model
CM, SC
AC
CM: Conventional Meeting
SC: Synchronous Collaboration
AC: Asynchronous Collaboration
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
171
Collaborative Model Composition
clarify
objectives
CM
build
hierarchical
model
search for
components
distributed
repository
sites
execute
hierarchical
model
AC, SC
AC
AC
CM: Conventional (Electronic) Meeting
SC: Synchronous Collaboration
AC: Asynchronous Collaboration
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
172
Collaborative Configuration System
Human Factors Div.
San Francisco, CA 
Electronics Div.
Tucson, AZ 
DEVS/HLA/CORBA Tutorial
Collaborative DEVS
Modeler
Manufacturing Div.
Houston, TX 
SIW(fall 2000)
Development Div.
Boston, MA 
XYZ Corporation
 Four dispersed divisions
collaborate to produce Model for
“Aircraft Flight in a Synthetic
Natural Environment”
173
Collaborative Configuration System
• DEVS/HLA
— Distributed Simulation
Sunnyvale
CA
HLA/RTI
GES
NJ
UofA
Tucson
Sunnyvale
CA
Collaborative Distributed
Network System
GES
NJ
• Collaborative Configuration System
— Configuration
— Management/Monitoring
UofA
Tucson
UofA
Tucson
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
174
CDM Architecture
Knowledge Worker
Knowledge Worker
Modeling Tasks:
• add component
• add link
• etc.
DM
DM
Networking Tasks:
• connect client to server
• receive updates from server
• send model to server
• etc.
CDNS
CDNS
CDM
environment
internet
Knowledge Manager
Networking Tasks:
• grant/deny client access
• broadcst model updates
• etc.
DM: DEVS Modeler
CDNS: Collaborative Distributed
Network System
Modeling Tasks:
• update model
• etc.
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
CDNS
DM
175
Client Window
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
176
Graphical Model
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
177
Modeling Window
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
178
Distributed Object Computing (DOC)

Technologies enabling distributed software systems
– DOC sits at the confluence of two major software technology areas:
» Distributed computing systems
» Object-oriented design and programming
– DOC Challenges
» Inherent complexities from the fundamental problem of distribution
» Accidental complexities from limitations with tools and techniques
used to build distributed software

DOC Design Problem
– Even simple Client/Server DOC systems consist of multi-vendor
and heterogeneous components that present non-deterministic
performance and capacity planning behaviors
– How to tractably evaluate design performance, alternatives, and
tradeoffs
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
179
Module 16: Distributed Codesign Methodology
 CORBA
- Common Object Request Broker Architecture
 Basic Features and Services
 Interfacing to Objects
 Connecting to Distributed Objects via Naming Service
 Event Channel and Real Time CORBA
 Interoperability of Vendor Orbs
 CORBA relative to other middleware
DEVS-DOC Models

DEVS:
– Formal systems-theoretic M&S
framework
– Dynamic system representation
– Hierarchical, modular modeling

software
object
Distributed Cooperative Objects
domain
arc
DOC:
– Distributed Codesign approach
– Independent SW & HW
modeling
– Coupling SW & HW models
(OSM) produces dynamic
model
Object
System
Mapping
link
processor
Loosely Coupled Network
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
gate
181
Distributed Cooperative Objects (DCO)
The software architecture component
 Object-oriented paradigm

– A set of attributes
– A set of methods

software
object
Distributed Cooperative Objects
domain
arc
Software objects interact
via arcs
– Peer-to-peer: messaging arcs
–

Client-server: invocation arcs
Software interactions invoke
methods, which create jobs
– Synchronous interactions block jobs
– Software object thread mode setting dictates job
execution concurrency
» None: only one active job at a time
» Object: only one active job per object method
» Method: an active job for every interaction

Software objects “load” the LCN via
– Active software objects: memory loading
–
Interactions: communications loading
– Jobs: computational loading
Modeling Software Objects


Defining DCO software objects:
Defining software methods:
– Quantum modeling
– Name of object for reference
–
» Name
» Computational Workload
» Invocation Probability
Size of object for memory loading
– Thread Mode of object: none, object, method
– Methods a set of methods
–
– Directed modeling
» Name
» Task sequences of
 Computational Workloads
 Arcs
Arcs a set of interaction arcs
– Duty Cycle for defining initializer objects
–
Initialization Method for directed modeling of
initializer objects
 Modeling

concepts
Defining software arcs:
– Quantum modeling: for any one invocation, the
method selected is irrelevant as long as the
invocation is in correct proportion to the aggregate
invocations of all methods
– Directed modeling: each invocation specifies a
method for execution
–
–
–
–
–
Name
Destinations
Size
Return Size
Message Type
synchronous, asynchronous, return, message
– Time Out
– Firing Frequency
(quantum modeling)
– Method Called
(directed modeling)
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
183
Software Object Structure
inMsgs
inJobs
swObject
state variables
sigma:
phase:
activeJobs:
commJobs:
queuedJobs:
timerMsgs:
fireJobs:
fireMsgs:
loadStatus:
parameters
objectSize:
threadMode:
methods:
arcs:
dutyCycle:
initMsg:
DEVS/HLA/CORBA Tutorial
initial value
0,
fire,
empty relation
empty function
empty relation
empty relation
empty set
empty set
unloaded,
default value
0 bytes
none,
empty set
empty set

null msg
range
[0 .. ]
{passive,active,fire}
0 or more thread-Job pairs
0 or more Job-blockedStatus pairs
0 or more thread-Job pairs
0 or more timeOut-Msg pairs
0 or more Jobs
0 or more Msgs
{unloaded,onDisk,inMem}
range
[0 .. ]
{none, object, method}
0 or more methods
0 or more dcoArcs
[0 .. ]
a Msg
SIW(fall 2000)
outMsgs
outJobs
outSW
184
Software Object Dynamics
X
(inMsgs, M1)
M1.returnSize=10
(doneJobs,J1(A,O1,50,100,M1))
S
fire,0
activeJobs={(O1J1)}
firingJobs={J1(A,O1,50,100,M1)}
passive,
active,
activeJobs={(O1J1)}
fire,0
activeJobs={(O1J1)}
firingJobs=
{J1(A,O1,50,50,M1)}
firingMsgs={M2.A1}
active,
activeJobs={(O1J1)}
(doneJobs,J1(A,O1,50,50,M1))
fire,0
firingMsgs={returnM1,M3.A2}
passive,
e
Y
(outSW, (A,Mem,1000,load))
(outJobs,J1(A,O1,50,100,M1))
DEVS/HLA/CORBA Tutorial
(outJobs,J1(A,O1,50,50,M1))
(outMsgs,M2.A1)
SIW(fall 2000)
(outSW,(A,Mem,1000,unload)
(outMsgs,returnM1)
(outMsgs,M3.A2)
185
Loosely Coupled Networks (LCN)
The hardware architecture component
 Processors

– Invoked software objects load memory
– Software object jobs load cpu
– Software object interaction messages converted
to packets for routing across LCN

Gates
– Interconnect two or more network links
– Two types of gates
link
» Routers switch LCN traffic between links
» Hubs broadcast LCN traffic across links

Links
– Provide a communications path
between processors and gates
processor
Loosely Coupled Network
gate
Modeling Processors, Gates, & Links

Defining Processors
–
–
–
–

Name of processor
CPU Speed of processor
Memory Size of processor
Swap Time Penalty associated with memory swaps
Defining Gates
– Routers
»
»
»
»
»
Name of router
Header Size for wrapping local packets
Link Speeds for each incident link
Bandwidth internal to router
Buffer Size internal to router

Defining Ethernet Links
– Ethernet Hubs
»
»
»
»
Name of hub
Link Speeds for each incident link
Bandwidth internal to router
Buffer Size internal to router
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
– Name of ethernet
–
Number of Segments for determining worst case
propagation
187
LCN Processor Structure

Processor
inMsgs
inMsgs
transport
– Transport component
outMsgs
outMsgs
inPkts outPkts
outLoop inLoop
inLink
inLink1
router
outLink1
outLink
inLoop
inSW
inJobs
DEVS/HLA/CORBA Tutorial
cpu
» Converts outgoing DCO
messages into packets and
incoming packets to DCO
messages
– Router component
» Inspects destination of
packets and routes
accordingly
inSW
inJobs
The processor is a DEVS
coupled model
outJobs
outJobs
– CPU component
» Invoked DCO software loads
memory
» DCO jobs are received,
executed, and released
SIW(fall 2000)
188
LCN Gate Structure
Gate
IN0 / OUT0
INLOOP OUTLOOP
IN0
IN
Hether1
Router
IN2 / OUT2
IN1 / OUT1
OUT
OUT0
INLOOP OUTLOOP
IN1
IN
Hether2
OUT
OUT1
INLOOP OUTLOOP
IN2
DEVS/HLA/CORBA Tutorial
IN
SIW(fall 2000)
HT1
OUT
OUT2
189
Modeling Framework: OSM
software
object
arc
Distributed Cooperative
Objects


Object
System
Mapping
–
–
–
–

node
Loosely Coupled Network
DEVS/HLA/CORBA Tutorial
Maps DCO objects onto LCN
processors
Defines communication modes:
message segmentation into
packets
Packet size
Packet overhead
Packet acknowledgement size
Acknowledgement timeout
Maps invocation and message
arcs onto communications modes
link
SIW(fall 2000)
190
DEVS-DOC Experimental Frame
L C N C la s s e s
D e s c rip tio n o f M e tric
P ro c e s s o rs
C o m p u ta tio n a l W o rk L o a d P e rfo rm e d
G a te s
D C O C la s s e s
L in k s
D o m a in s
O b je c ts



A c tiv e T im e /U tiliz a tio n



I/O D a ta L o a d



U tiliz a tio n o f S to ra g e

P e rc e n ta g e o f A c tiv e O b je c ts

D e g re e o f M u ltith re a d in g

In te ra c tio n s



L e n g th o f E x e c u tio n Q u e u e s
# o f In itia liz a tio n In v o c a tio n s

T o ta l E x e c u tio n T im e

C o e ffic ie n t o f In te ra c tio n

D a ta T ra ffic


U tiliz a tio n o f B a n d w id th


% o f P a c k e t R e tra n s m is s io n



L e n g th o f P a c k e t B u ffe r

N e t T h ro u g h p u t o f D a ta



R a te o f O v e rh e a d




G ro s s & N e t R e s p o n s e T im e
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
191
DEVS-DOC Modeling Process
Refine hardware design?
State M&S
objectives
Refine software design?
Define processors,
routers, hubs, links,
and network
topology (LCN)
Define software
objects and
interactions (DCO)
Map software
onto processors
(OSM)
Refine distribution?
DOC
Configure simulation control and
data collection components
(Experimental Frame)
stop
Run simulation and
analyze results
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
no
yes
Desired
performance &
behavior?
192
DEVS/HLA and Predictive Contracts Case-Study

DEVS/HLA
– DoD HLA-compliant M&S environment
– Mapping of DEVS-C++ to DMSO RTI (C++)

Predictive Contract Research
– How to reduce message traffic exchanged between distributed simulation
federates with a marginal addition to computational overhead?

Three predictive contract mechanisms studied
– Non-predictive quantization: send a real-valued variable update for each
threshold crossing
– Predictive quantization: send a single bit variable update to signal next higher,
or lower, threshold crossing
– Multiplexed predictive quantization: send a set of single bit variable updates in
one message between federates
» Applicability: large number of models per federate
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
193
Pursuer-Evader Federation
Pursuer
EvaderWEndo
Red Tank
Red Tank
Endo Model
position
position
in
Evader
perceive
out
out
in
fireOut
drive
fireIn
Blue
Tank
update (quantizer)
Pursuer
Evader
Pursuer
Evader
Pursuer
Evader
Pursuer Federate
Evader Federate
interaction (coupling)
DEVS/HLA
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
194
DEVS/HLA Federation Infrastructure
Federate P
System Models
CoordinatorEndo
Simulator A
User
Models
Time Manager
Federate E
System Models
System Models
tN
tN1
Coordinator
SimulatorEndo A
SimulatorEndo B
Simulator B
User
Models
E1
P1
DEVS/HLA/CORBA Tutorial
tN2
CoordinatorEndo
Model
Model
Model
Model
E1
E1
E1
Model
Model
Model
Model
P1
P1
P1
RTI Exec
tN
Fedex
tN: Global DEV Time
tNi: Time of Next Event of Federate i
SIW(fall 2000)
195
Real System Predictive Contract Results
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
196
DEVS-DOC Simulated Results For
DEVS/HLA Predictive Contracts
Com pa r ing Q ua ntiza tion - S im ula te d Run Tim e
1000000
100000
10000
10000
Non-P r e dic tive
P r e dic tive
1000
1000
S e c onds
S e c onds
Com pa r ing Q ua ntiza tion - Ethe r ne t Bus y Tim e
100
10
1
M ultiple x e d
Non-P r e dic tive
P r e dic tive
100
M ultiple x e d
10
10
100
1000
10000
Num be r of S e nde r /Re c e ive r P a ir s
1
1
10
100
1000
10000
0
Num be r of S e nde r /Re c e ive r P a ir s
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
197
DEVS-DOC Runtime Performance
Com pa r ing Q ua ntiza tion - Re a l Ex e c ution Tim e
100000
Non-P r e dic tive
10000
P r e dic tive
M inute s
M ultiple x e d
1000
100
10
1
1
10
100
1000
10000
Num be r of S e nde r /Re c e ive r P a ir s
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
198
Modeling Layer
Auxiliary
Modules
(GUI)
Distributed Object Computing
Modeling Constructs
DEVS Modeling Constructs
DEVS-DOC
DEVS-DOC M&S Environment
Simulation Layer
Distributed Simulation
(DEVS/CORBA)
Persistent Object Store
Middleware (CORBA)
Uniprocessor Simulation
Parallel DEVS (DEVSJAVA)
Operating System
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
199
Module 17: DEVS/HLA Support of Joint
Measure
TM *

Joint MEASURETM: Motivations, Objectives, Applications

Joint MEASURETM Background
–Joint MEASURE Overview
–The Distributed Joint MEASURE Architecture.
*

DARPA/ASTT Technology Demonstration

Joint MEASURETM Benefits to Systems-of-Systems Analysis
Mission Effectiveness Analysis Simulator for Utility, Research and Evaluation developed by
Lockheed Martin Missiles and Space Systems
Mission Effectiveness


SBA: early assessment of new system’s expected mission
effectiveness
Assess contribution to overall ability to counter an enemy threat:
 ability to gather and share information,
 survive
 service hostile targets.

Difficulty: large impacts due
 Subtle design decisions
 modest alterations use of the system
 minor modifications of the scenario
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
201
Goals and Objectives:





Assist in evaluating a proposed system’s mission effectiveness, wrt
 specified set of possible design variations
 operational utilization patterns
 engagement scenarios
Need for High Performance: It is easy to generate a requirement to simulate a
multi-hour analysis scenario thousands of times.
Repeatability: based on DEVS, a logical model formalism with a well-defined
state concept, Joint MEASURETM has the ability to exactly replicate simulation
runs
Maintainability and Reusability: The modular aspect of DEVS models enforces
a software engineering practice that simplifies code reuse and simplifies the
construction of new federations from existing components
Portability at a high level. The high-level of abstraction provided by the DEVS
formalism subsequently facilitated porting the system to DEVS/C++ and later to
DEVS/HLA
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
202
Applications:


JCTN - Utility of measurement-based sensor fusion.
–
Access to remote (I.e., non-LMMS) Lockheed Martin models.
–
End run around ‘proprietary’ concerns.
DD21/Deepwater - Analysis of system-of-system options.
–
Complex scenario modeling requirements (with concomitant performance
requirements).
–
Need to integrate/interface models developed by number of team mates.
–
Eventual need to integrate person-in-the-loop simulation with analytically simulation.
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
203
DEVS/HLA Joint MEASURE Federations
Joint
MEASURE
DD21
(Warship
Model)
OPNet
Comm
Model
DEVS
Federate
DEVS
Federate
DEVS
Federate
RTI
Ambasador
RTI
Ambasador
RTI
Ambasador
Internet
RTI
Executive
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
204
Joint MEASURE
TM
Overview
• Mission Effectiveness Simulator Generator
– Intended for Monte-Carlo analytical work.
– High performance is a priority.
– Expected to be used by broad community.
• Provides an infrastructure composed of:
– DEVS-Compliant Models/DEVS Simulation Engine
- Emission Propagation
- Spatial Encounter Prediction
– Geographical Information System (GIS).
– Data Modeling and Analysis Toolkit.
– Graphical User Interface (GUI)
• Archives a library of reusable models:
– Sensors
– Weapons
– C2
– Environment
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
205
Joint MEASURE
TM
Overview
User Interface, Graphics and Animation
• Scenario Specification
Can be specified interactively.
Specification includes: variable routes,
behaviors and subsystems and the
attributes of those subsystems.
Scenarios can be stored, retreived and
concatenated.
Provides full access to underlying GIS.
Provides most useful map projections.
• Runtime Visualization/Animation
Optional 2d-3d run-by-run animation.
Display clutter controls.
Runtime data analysis updates.
Start/Stop/Pause.
• Data Analysis
Collects and displays a variety of
mission effectiveness data.
Integrated with Prophet (a statistical
and modeling package with report
generation capabilities.)
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
206
TM
Joint MEASURE Architecture
Data
Analysis
Emission Propagation
GIS
Simulation
Engine
GUI
Encounter Prediction
Reusable
Models
Infrastructure
Components
Alternative Models
Hierarchical Decomposition
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
207
TM
The Non-Distributed Joint MEASURE Architecture
GIS dB
GIS
Propagator
Sensors
C3
Weapons
Hull
Platform
Logger
Sensors
C3
Weapons
Hull
Platform
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
208
TM
The Non-Distributed Joint MEASURE Architecture

Platform(s) - Top Level Modeling Components
–
Encapsulate Sub System Models:
(Hull, Sensors, Weapons, Comms, C2)
– Interact with other Platforms via ‘Emissions’

Spatial Encounter Predictor (Logger) - Infrastructure Component
– Calculates when events could occur.
– Publish and Subscribe oriented.
– Handles detection, firing and collision events.

Propagator - Infrastructure Component
– Determines signal and noise strength and latencies.
– Interfaces to GIS system for environment models.
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
209
DEVS/HLA and Support of Joint Measure
Joint
Measure
DEVS
Parallel/ Distributed
Simulation Protocol
HLA/RTI
Network
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
210
TM
The Distributed Joint MEASURE Architecture
GIS dB
GIS dB
GIS
GIS
C3
Sensors
Hull
Weapons
Sensors
Platform
C3
Sensors
Hull
Platform
Weapons
Propagator
Propagator
Logger
Logger
Weapons
C3
Hull
Platform
Sensors
C3
Weapons
Hull
Platform
Endomorphs
Hull
Hull
HLA/RTI over Internet
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
Endomorphs
LMMS
211
TM
The Distributed Joint MEASURE Architecture

Infrastructure components are replicated.

Endomorphs are created in remote Federates.

Remote Loggers announce when updates are relevant via
‘events’.

Models update their endomorphs via ‘object updates’.
The Goal of DEVS/HLA Joint MEASURE Validation Test Bed

Establish the practicality of using the DEVS/HLA
approach in an industrial strength application.

Demonstrate that remote models can be accessed for
analytically demanding purposes.

Explore the impact of alternative distribution strategies
on performance and fidelity.

Quantify the resulting performance and fidelity
improvements and/or tradeoffs.
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
213
Lockheed/UA Joint Measure:
Space Based Radar Detection
Endomorphic model
preserves radar
reflective properties
quantized:
•altitude
•pitch
radar
Xsection
HLA
Internet
radar
emissions
LAN
Space
Model
Federate UA
DEVS/HLA/CORBA Tutorial
• emissions prop
agation
• spatial encounter
prediction
Federate LM
SIW(fall 2000)
214
ASTT Test Bed Scenario Features
(A Distributed HEL Weapon Architecture Evaluation Test Bed)

Approach
–
Distribute models to processors on the basis of affiliation.
» Enemy Threat platforms execute on Processor ‘A’
» Friendly HEL Architecture(s) execute on Processor ‘B’.
–
–
–

All models are responsible for maintaining remote endomorph(s).
All detection/tracking is performed locally against endomorphs.
Other interactions (e.g. detonations) are transmitted over the network.
Model’s Update Algorithm for maintenance of Endomorphs
–
–
–
Models maintain their own (possible dynamic) signature databases.
Models monitor (with local logger support) position of possible detectors.
Models update selected signature cell values in response to:
»
»
–

Dynamic changes in their own signature cell values.
Motion derived changes in detector bearing and elevation.
Updates are quantized in order to control the update frequency.
Test Bed Support for Algorithm Evaluation
–
–
–
Quantization parameters can be easily manipulated.
Number of processors distributed over can be increased.
Endomorphs can be eliminated for baseline case
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
215
Summary: DEVS Framework and DEVS/HLA






DEVS provides sound system-based modeling framework
DEVS/HLA (implemented in C++/Java) provides
sound/user-friendly environment for developing HLACompliant simulations
DEVS/HLA supports integration of common modeling
approaches
DEVS/HLA supports Hierarchical Modeling as well as
efficient parallel/distributed simulation
DEVS/HLA supports Predictive Contract Methodology
Collaborative DEVS Modeler and other DEVS tools
support FEDEP development
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
216
Module 18: Efficient Large Scale
Distributed Simulation





Predictive Contract Methodology
DEVS Bus Concepts
Representing Discrete-time and Differential Equation
Systems
Coupling Agents and Environments
Developing Efficient Distributed Simulations
Bandwidth Constraints on Distributed Simulation
Simulator interfaces
model
to coordinator
Component
Model
Component
Model
Component
Model
Simulator
Simulator
Simulator
Messaging
Messaging
Messaging
HLA
middleware
Messaging
Limited
bandwidth
channel
Coordinator
Coupled
Model
Coordinator
manages time
and message
routing
Communication is bottleneck due to large number of interacting entities
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
218
Overcoming Bandwidth Constraints
Component
Model
Component
Model
Component
Model
Simulator
Simulator
Simulator
Messaging
Messaging
Messaging
Quantization reduces
update message volume and size
Simulators use local models of remote
federates to reduce need for updates e.g.
Dead Reckoning
Publish/Subscribe routes updates within classes
Spatial Encounter Prediction (routing space) reduces
message exchange to pairs that are (dynamically) close
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
219
Local Computation Tradeoffs and Scalability
Local
Models
high
Predictive
quantization
Spatial
Encounter
Prediction
Communication
reduction
Quantization
low
high
low
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
Local
computation
overhead
220
DEVS Bus Concept
Discrete
Event
Formalisms
Discrete Time
Systems
DEVS
DEVS
message
Diff Eq.
Systems
DEVS
message
message
HLA
HLA
HLA
RTI
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
221
Quantization Predictive Filtering
 quantization
– non-predictive
– predictive
– scalability

error characterization
– error/message reduction tradeoff
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
222
Quantization
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
223
Non-predictive Quantization
Receiver
Sender
Quantizer
• sender generates fixed time step outputs
• quantizer demon is applied to sender output
• reduce number of messages sent
• but not their size
• quantizer incurs some computation
• sender’s computation unaffected
• receiver must persist attribute values
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
224
Predictive Quantization
Sender
(t1,1) (t2,1) (t3,1)
t1
t2
Receiver
t3
• sender employs own model to predict next boundary crossing
• sends one-bit message at crossings
• Advantage: reduce both number of messages and size
• multiplex messages together to exploit small message size
• prediction can also reduce sender’s computation
• time stamping: background (logical) or absent (real time)
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
225
Combined Predictive/non Pred. Quantization
X,Y: predictive attributes
Z: non-predictive attribute
Z
DZ
X:
x: Px
Y:
y: Py
Z:
z: Qz
D
X
Y
D (when
changed)
+1,-1
+1,-1
Px x:
X:
Py y:
Y:
z: Z:
real
Z
Y
X
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
226
Predictive Quantization: Detail
• employed model can be very simple
– standard integrator :: linear extrapolation
• time = quantum size/input (derivative)
• boundary = up/down according to sign(derivative)
• map Diff. Eq. system component-wise using memory-less
equivalents (see next figure)
– double integrator :: 2nd order extrapolation (used
in Dead Reckoning)
• (time, boundary) determined by smallest positive root of
algebraic solution (quantum size, p, v, a)
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
227
Scalability of Predictive Quantization
Sender
#messages(D)
Receiver
#computations(D)
#bits(D)
2-3
Orders of
Magnitude
#messages(D)
non-predictive
#computations(D)
non-predictive
#bits(D)
predictive
predictive
0
0
Quantum size, D
DEVS/HLA/CORBA Tutorial
Quantum size, D
SIW(fall 2000)
228
Error Characterization
• local
– federate-measured difference between hi fi and 2nd order model
– cannot guarantee control on global error
• global
–
–
–
–
deviation from true global state
propagation, feedback
theory developed and validated
error can be reduced to below any given tolerance level with small
enough quantum size
– typically, require quantum size no smaller than 10% to 0.1% of range
of variable
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
229
Favorable Tradeoff in Quantization
• If tolerance = 1% of Full Scale,
Dtol = Full Scale /100 c, ranging from Full
Scale/1000 to Full Scale/50
Full Scale
#messages(D) = #messages(1)/D
Execution Time
Saturation
level
Error = c D
0
1
Quantum size, D
Error tolerance Dtol = tolerance / c
•Experiments with a variety of examples
show that c ranges from 0.5 to 10.
DEVS/HLA/CORBA Tutorial
Avg
Transit
Time
#messages
CAN EXPECT extremely favorable tradeoff
in execution time (or number of concurrent
entities) near system saturation level
SIW(fall 2000)
230
Quantization Test Cases
A variety of examples have been investigated
 classical ODEs (orbiting body,predator/prey, slow/fast system,
chaotic system)
 spatially distributed system (heat seeker in diffusion field)
 multi-entity systems (pursuer/evader pairs,urban traffic, follow the
leader)
Results confirm the theoretical predictions and provide estimates of
parameters and tradeoff relations
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
231
Visualized Examples of Quantization
0.1
0.04
0.001
execution time
0.0001
Heat Seeker in Diffusion Field
• source
• seeker (sensitivity = .05)
• temperature (colors)
K Messages
0.00001
100
80
60
40
20
0
Quantum
size
K Messages
tolerable
error level
Can increase quantum size to seeker
sensitivity level while still getting same
qualitative behavior
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
232
Mapping DESS Directly into DEVS
x
s
x
f1
s
x
f2
d s 1 /d t

s1
d s 2 /d t

s2
Predictive Quantizer Integrator
...
s
x
fn
d s n /d t

x
sn
s
x
s
x
Component-wise mapping
based on predictive quantization
F
f1
f2
F
d s 1 /dt
1

DEVS
d s 2 /dt

DEVS
d s n /dt

DEVS
s
s2
...
s
x
fn
F
sn
Persistent Function Element
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
233
Stress Test: Rossler Choatoic ODE
Stress Test : Rossler Chaotic ODE
Advanced Simulation Technology Thrust
fz (x, z) = b + (x – c )* z

+
y
-1

+
x
fz

z
-1
-a
Theory: Global error of non-predictive quantization
with time step h, should be same as predictive
quantization with h = D/max derivative.
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
21
234
Quantum size and DEVS/HLA Federate Assignment
E xecution
T im e (secs.) for
case
a)
b)
c)
5,237
1,050
757
4,856
942 *
845
6,684
1,029
997

Q uantum _size 
0.01
a)0.05
0.1
a)
c)
b)
fire
Out
fire
fire
In
fire
Out
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
fire
In
235
Baseline Quantization for Multi-entity Federates
Federate B
Federate A
model A1
value
Q
value
model B1
value
model B2
double
(64 bits)
model A2
value
Q
Network
model An-1
value
Q
value
model Bn-1
model An
value
Q
value
model Bn
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
236
Predictive Quantization Multiplexer
2bits for
active/+1 /-1
Federate A
model
A1
value
model
A2
value
PQ
Federate B
model M’
model M
model B1
D
D
PQ
value
network
model Bn-
model An1
value
D
D
PQ
model An
value
value
model B2
value
PQ
DEVS/HLA/CORBA Tutorial
1
value
model Bn
SIW(fall 2000)
237
Predictive Multiplexer vs Baseline Performance
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
238
Coupling Agents and Environments
agents -- system components with perceptual,
decision and usually mobility capabilities
•
•
•
•
micro satellites
urban traffic
robot colonies
mobots
environment -- spatial layered variables with
energy propagation capabilities
Three types of component coupling
• physical to physical -> environment
• agents to environment
• agents to agent
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
239
Component-to-component
Coupling of physical components
• different resolutions
• synchronization
• load balancing
Ocean
Atmosphere
WindStress
heat fluxes
water fluxes
Sea
Surface
Temps
Daily at noon
DEVS/HLA/CORBA Tutorial
Daily at midnight
SIW(fall 2000)
240
Agents-to-Agents
Spatial
Model
Agents
couplings
locations
Agents interact through
• sensing each other
• communicating with each other
Spatial Encouner Prediction reasons
whether pairs of agents can interact
Emissions Propagation
Both kinds of interaction
can employ endomorphic
models, i.e., models of self or
other components in the system
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
241
Communicating Agent Interaction
Endomodels
used within agents to enable
them to communicate about
their internal states
Receiving
Agent
Sending
Agent
Endo
model
Info
About My
State
Sending
Agent Endo
Receiving
Agent
model
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
242
Perceiving-Reflective Agent Interaction
Perceiving
Agent
Reflective
Agent
Endo
model
How I
look
Endomodels used by simulators
•to reduce message traffic
• to overcome latency in real time
operation
Reflective
Agent
Endo
model
Internet
DEVS/HLA/CORBA Tutorial
Perceiving
Agent
LAN
SIW(fall 2000)
243
Endomorphic Model Construction
Sending/Reflective
Agent
Endo-morphism
Experimental Frame defined by
Needs of
Receiving/Perceiving
Agent
Endo
model
Sending/Reflective
Agent
LEGEND
State transition
homomorphism
Endo
model
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
244
Summary



Scalability
– local computation overhead
– ability to reduce bandwidth requirements
Quantization, especially, predictive quantization
– scalable mechanism
– good message filtering properties
– multiplexing can exploit the message size reduction for large numbers of
entities,
– providing high communication reduction
– with low computation overhead.
Quantization methods can be combined with other schemes
– local models
– spatial encounter prediction
– potentially provide greater load reduction
– cost of increased local computation.
Module 19: Zero Lookahead Simulation:
DEVS and HLA
Mapping DEVS Models to HLA
Parallel DEVS model
Maybe transform
before mapping?
Mapping must preserve
Simulation logic in the
mapped space for
observables
C++/HLA
Java HLA
Tom. Lake(a)glossa.co.uk
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
247
HLA Logical Simulation Constructs
* The shared part of the simulation NOT the implementation*
HLA provides a distributed whiteboard on which these things evolve
* Objects
instances of classes
* Attributes
of objects
* Interactions instances of classes
All seen by all
subject to Interest
Mgmt
* Parameters of interactions
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
248
Logical Evolution in HLA
Ownership exchange
Register Object
DiscoverObject
UpdateAttributeValues*
ReflectAttributeValues*
DeleteObject *
RemoveObject *
SendInteraction *
ReceiveInteraction *
* Only these have logical times attached
Others must happen “early enough”
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
249
What are Federates For?
Federates host objects
Federates keep time for objects
Federates manage interest for objects
Federates send and receive interaction for objects
Federates send and receive object attribute changes
One software system can have many federate
interfaces to a federation
Of course HLA started by assembling federates….
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
250
Some surprising Things….
Interactions are not like messages.
Interactions are seen by all subject to interest Mgmt
• Register object is not a timestamped operation in HLA
• Change of attribute value cause objects to be discovered
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
251
Distributed Computing is HARD
Heterogeneous platforms with different data formats
Delays in networks make it costly and slow to
coordinate the components
Cause of delays:
Speed of light
Router delays, losses
ATM queues, losses
Telcos can switch routes….
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
252
The time ordering problem
We are committed to taking events in logical time order
But events can happen remotely.
How can we be sure that we have not missed any?
RTI cannot advance beyond LBTS
Least Bound on (incoming) Time Stamp
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
253
Time Ordering -- Some Solutions
Optimistic techniques -- correct ordering faults when
they occur
Conservative techniques -- don’t let problems arise
Requires (for efficient large-scale operation):Lookahead -- give output events to RTI early.
Or Synchronous timestepping
Smart mappings of the problem may help give lookahead
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
254
Lookahead -- what is it?
You have lookahead L if your output is complete up
to time t-L at time t
Output means output attribute changes (predicted)
and interactions that you give rise to and
object deletions that you perform.
Can get lookahead in models as:
reaction time, minimum travel time, processing time, inertia, etc.
Sometimes transform models to move lookahead around
( Paper 160 this meeting).
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
255
Conditional Advance With Lookahead
I can hold out without smoking
until 9pm
SetLookahead(0min)
TimeAdvanceRequest(9pm)
Lights up at 9:00pm
Global LBTS is 9:00pm
then 9:05pm
I can go without smoking until
10pm but if someone else lights
up I can only hold out 5 minutes
SetLookahead(5min)
NextEventRequest(10pm)
Lights up at 9:05pm
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
256
Zero Lookahead Simulations, DEVS and HLA
DEVS -- lookahead is not automatically present
We can sometimes transform it in .
E.g. map DEVS phases to RTI time, time to an interaction
RTI -- Normally gives all events up to AND INCLUDING time t before
giving TimeAdvanceGrant(t) and parallel DEVS needs this
guarantee( in the obvious mapping) to output
But RTI can only guarantee “up to time t” for federates with zero
lookahead (and will only do this in response to
NextEventRequestAvailable)
Solution: Smart mapping
or communicate “ output at time t complete” explicitly
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
257
Without Lookahead?
Not a problem for small scale
simulations
Not a problem if time is coarsely
“chunked” so that many events are
simultaneous.
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
258
Mapping Models to HLA
Some of the cases are hard because distributed computing is
hard
Where we need smart mappings it is essential to start with a
sound definition of the model.
The tools to solve the problems, whether through optimistic
simulation or smart mappings can only arise in a well-defined
framework for modeling AND simulation.
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
259
Some Open Issues & Research Directions
• Characterize the class of logical-time models that
HLA/RTI can support
• Simulation algorithms interoperability
• DEVS/HLA migration to real-time and its integration
with its logical-time counterpart
• Predictive contract methodology
• model/simulation dependent characterization
• the best mix of schemes for a given application
context
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
260
AZ Center for Integrative M&S
•
•
•
Research Mission
– basic for improved infrastructure
– applied to challenging problems
Education Mission
– degree programs in M&S discipline
– training of M&S professionals
– short courses, tutorials
Service Mission
– support M&S needs of government and industry
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
261
Module 20: DEVS-based Tools in Support
of HLA-Compliant Simulations
DEVS/HLA C++/Java
 DEVS/CORBA
 Joint MEASURETM
 Collaborative DEVS Modeler
 DEVSJAVA
 DEVS-DOC

DEVS-Based HLA Tools
TOOLS
FEDEP
Phase
Dvlp.
Org
DEVS/HLA C++/Java
3,4,5,6
UA*/LM
3,4,5,6
LM
Collaborative DEVS Modeler
2,3
UA
DEVSJAVA
2,3,4
UA
DEVS-DOC
2,3
UA
Joint MEASURE
DEVS/HLA/CORBA Tutorial
TM
SIW(fall 2000)
263
DEVS/HLA



Purpose: Generic Environment for DEVS-based M&S
Major Functions:
– System-theory and formal M&S concepts
– Enables developing components in DEVS C++/Java
– Supports predictive contract methodology &
parallel/distributed execution of federations
– Industrial strength capability (e.g. Joint MEASURETM)
HLA FEDEP Support: Phases 3, 4, 5 and 6
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
264
DEVS/HLA (cont.)



HW/SW Specification:
– Computing HW platforms: Unix workstation & PC
– OS: Unix Solaris & Windows NT
– Languages: C++ & Java
– Versions 1.3 (supports RTI 1.3)
Organization: University of Arizona (with help from Lockheed Martin)
POC:
–
–
–
–
Bernard Zeigler
Ph: 520-626-4846
Email: [email protected]
URL: www.acims.arizona.edu
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
265
Joint MEASURETM

Purpose: Assess Sensor-weapon, System of Systems
Mission Effectiveness

Major Functions:
– DEVS/HLA compliant hierarchical, modular models
– Extensive model libraries (e.g., C4ISR, lasers and
targets)
– Integrates GIS, rich visualization, & statistical
analysis
– GUI supports analyst-friendly interactivity
 HLA
FEDEP Support: Phases 3,4,5 and 6
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
266
Joint MEASURETM

HW/SW Specification:
–
–
–
–


(cont.)
Computing HW platforms: Unix workstations
OS: Solaris
Language: C/C++
Version: 1.1
Organization: Lockheed Martin Missile Space
POC:
– Steven Hall
– Ph: 407-742-2903
– Email: [email protected]
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
267
Collaborative DEVS Modeler



Purpose: Anytime/anyplace model development
Major Functions:
– Facilitates collaborative hierarchical, modular model
development
– Model-based modeling (component model reuse)
– Supports single/multiple users
– User-friendly Interface
HLA FEDEP Support: Phases 2 and 3
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
268
Collaborative DEVS Modeler (cont.)



HW/SW Specification:
– Computing HW platforms: Unix workstation, PC, & Mac
– OS: Solaris, Windows, Mac-OS, Linux
– Language: Java
Organization: University of Arizona
POC:
–
–
–
–
Hessam Sarjoughian
Ph: 520-626-4846
Email: [email protected]
URL: www.acims.arizona.edu
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
269
DEVSJAVA



Purpose: Prototyping of Distributed Simulations
Major Functions:
– Enables design of HLA federates and federations
– Seamless transition to DEVS/HLA and
DEVS/CORBA
– Supports M&S Education
– Easy to use DEVS-Based M&S Environment
– Object-oriented
HLA FEDEP Support: Phases 2, 3, and 4
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
270
DEVSJAVA (cont.)



HW/SW Specification:
– Computing HW platforms: Unix workstation & PC
– OS: Unix Solaris & Windows
Organization: University of Arizona
POC:
–
–
–
–
Bernard Zeigler/Hessam Sarjoughian
Ph: 520-626-4846
Email: [email protected]
URL: www.acims.arizona.edu
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
271
DEVS-DOC (Distributed Object Computing)


Purpose: Distributed M&S Co-Design Environment
Major Functions:
– Supports distributed co-design (e.g., DEVS/HLA Federation Design)
– Supports concurrent HW and SW layers


HLA FEDEP Support: Phases 2 and 3
HW/SW Specification:
– Computing HW platforms: Unix workstations and PCs
– OS: Solaris and Windows
– Language: Java

Organization: University of Arizona
POC: Daryl Hild, Hessam Sarjoughian

Email: [email protected], [email protected]

DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
272
DEVS/CORBA


Purpose: Generic Environment for DEVS-based M&S
Major Functions:
– System-theory and formal M&S concepts
– Enables developing components in DEVSJAVA
– Business strength capability
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
273
DEVS/CORBA (cont.)



HW/SW Specification:
– Computing HW platforms: Unix workstation & PC
– OS: Unix Solaris & Windows NT
– Languages: Java
– Visibroker (Version ?)
Organization: University of Arizona
POC:
–
–
–
–
Bernard Zeigler
Ph: 520-626-4846
Email: [email protected]
URL: www.acims.arizona.edu
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
274
More Information



Committee on Technology for Future Naval Forces, N. R. C. (1997).
Technology for the United States Navy and Marine Corps, 2000-2035 Becoming
a 21st-Century Force: Volume 9: Modeling and Simulation. Washington, DC,
National Academy Press.
Zeigler, B. P. (1998). A Framework for Modeling & Simulation. In Applied
Modeling & Simulation: An Integrated Approach to Development & Operation.
D. Cloud and L. Rainey, (Eds)McGraw Hill.
Zeigler, B. P., H. Praehofer, T. G. Kim (2000). Theory of Modeling and
Simulation. Second Edition, New York, NY, Academic Press.
Many more publications and downloadable software
are available from Website: www.acims.arizona.edu
DEVS/HLA/CORBA Tutorial
SIW(fall 2000)
275
Descargar

No Slide Title