Creating Distributed Simulations: The Triad Bernard P. Zeigler

Creating Distributed Simulations: The  Triad Bernard P. Zeigler

Creating Distributed Simulations: The 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(contd) 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(contd) Experimental Frame Real World Simulator modeling relation Experimental frame specifies conditions under which the system is experimented with and observed DEVS/HLA/CORBA Tutorial simulation relation Model Model Model 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: Event Processor Simulator: Recursive Algorithm 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 Systems 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 systems 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(contd) 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, int, ext, con, ta, X: a set of input events Y: a set of output events S: a set of states

ta: S R+0, time advance function int: S S internal transition function ext: Q x Xb S external transition function con: 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)} : S Y output function DEVS/HLA/CORBA Tutorial SIW(fall 2000) 36 Internal Transition Function/Output Function y (s ) s ta(s) s = int (s) DEVS = X, S, Y, int, ext, con, ta, DEVS/HLA/CORBA Tutorial SIW(fall 2000) 37

External Transition Function x s = ext (s, e, x) s e ta(s) DEVS = X, S, Y, int, ext, con, ta, DEVS/HLA/CORBA Tutorial SIW(fall 2000) 38 Confluent Transition Function x s = con (s, ta(s), x) s e ta(s) DEVS = X, S, Y, int, ext, con, ta, 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, int, ext, con, ta, DN X , Y, D, {Mi }, {Ii }, {Zi,j } DEVS X, S, Y, int, ext, con, ta, 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 stop generator (genr) out in

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

stop generator (genr) out out in 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 DIGRAPH CONTAINER entity DEVS/HLA/CORBA Tutorial can hold Legend MESSAGE content SIW(fall 2000) port, value ENTITY 49 Simulator/Simulation Concepts

Simulator is responsible for executing a models dynamics (represented as instructions) in a given formalism. Abstract simulator is a characterization of what needs to be done in executing a models 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 ) 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: ( ) 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 ( ext ) 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 ( int ) 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 ( ext ) public void deltext(int e,message x){ //Internal Transition Function ( int ) 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 ( ) 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 stop generator (genr) out out in 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 strike start target damage damage defuse bomb //add components add(bomb); add(counter); add(target1); add(target2); defuse

fuse explosion 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 (Contd) a) fuse dormant Bomb explosion

explosion defuse fuse live explode 10 150 1 dead defuse External TransitionFn when receive fuse in phase dormant hold_in(live,5) when receive defuse in phase live hold_in(dormant,150) else continue Internal TransitionFn in phase live hold_in(explode,1) in phase explode passivate_in(dead) Output Fn

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 Federation Management Declaration Management Object Management Ownership Management Time Management Data Distribution Mgmt DEVS/HLA/CORBA Tutorial Functionality 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 Control attribute and interaction publication Create and delete object reflections Transfer ownership of object attributes Coordinate the advance of logical time and its relationship to real time Supports efficient routing of data 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 federates 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) Customer_ Emploee_ Transactions (I) Water (PS) Appetizer (S) Coffee (PS) Soda (PS) Soup (S) DEVS/HLA/CORBA Tutorial

Interaction Class Structure Table Order_Taken_From_ Customer_Seated (IS) Kids_menu (I) Order_Taken_From_ Clam_Chowder (S) ManhattanAdult_menu (PS) (I) New_England (PS) Order_Taken (I) Drink_Served (I) 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) live component: real-time execution w/ hard deadlines 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 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 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 Control attribute and interaction publication

Object Management Yes Ownership Management 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: DEVS/HLA/CORBA Tutorial Create and delete object reflections 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 position position in out out in drive Evader (Endo Model) Blue Tank fireout fire

perceive firein 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 drive Red Tank Endo Model Evader position fireout perceive 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 RTI Devs

Create Fed. Execution Join Fed. Execution Federation Execution - Publish/Subscribe - Register Publish Object Class Register Object Pub/Sub Attributes Pub/Sub Interaction Models Create Models Setup Coupling initialize 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 Time Advance Cyclic Execution Phase Time Advance Req Grant Time 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 Compute input/output Create/join federation 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() tL ;= grantTime; tN = grantTime + time_adv_funct(); 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 F2 NER(t1) t1 TAG(t1) t1 F1 NER(t2) t2 F2 t1+g b) a) F1 F1 1 NER(t1) RTI Time Reqt F2

F2 NER(t2) DEVS/HLA tutorial c) SIW, 99 2 NER(t2) d) University of Arizona Deadlock for communicating imminents F1 F2 NER(t1) t1 F1 t1+g t1 NER(t2) F2 TAG(t1)

t1+g t1+g F2 NER(t2) t1+g b) a) F1 TAG(t1) NER(t1) where t1 depends on F2s inputs so cant immediately be sent as required NER(t2) c) DEVS/HLA tutorial 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 System Models System Models CoordinatorEndo Simulator A User Models Model A Model B RTI Exec DEVS/HLA/CORBA Tutorial Federate B Time Manager Federate A

Coordinator tN SimulatorEndo A tN2 tN tN1 SimulatorEndo B Fedex SIW(fall 2000) System Models CoordinatorEndo Simulator B User Models Model C Model D tN : Global DEVS Time tNi : Time of Next Event of Federate i 109

Implementation (contd) 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) Done by DEVS/HLA Run Federate run( ) of Federate

Initialize models Run FederateDEVS Start DEVS simulator End of main( ) End of run( ) Constructor of FederateDEVS 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 executeFederation() of Federate set up HLAports Coupling ports for attribute comm Create Fedex Join Fedex

Create object classes Create their attributes Set Time Management Parameters set up classes and attributes Link these to DEVS models 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 Sample code for a Federate // constructor of FederatePursWQuant // create the highest component RedTank EndoModel (DEVS comp) (DEVS comp) RedTkObj position position Blue Tank fireout PursWQuant *PWQ = new PursWQuant(PursWQuant); // 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 Feature Languageneutral Data Types Local/remote Transparency Brief Description

Marshalling and de-marshalling of method arguments greatly simplify message exchange among objects over the network Objects can communicate in the same way whether on a single processor or over a network between processors with different bit-level architectures High Level Use of IDL interfaces enables objects expressed in Binding arbitrary languages to communicate with each other and easy wrapping of legacy code. Self Describing CORBA offers access to configuration meta data Meta Data CORBA Name service, Event Service, Time Service, etc. Services provide utilities for distributed computing DEVS/HLA/CORBA Tutorial SIW(fall 2000) 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++ class Counter { //java int i;

//methods omg.omg.CORBA.Counter c; //get reference to c via //naming service using cntr int i getCount public: int getCount(){return i++;} }; = c.getCount(); 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 ORBs

work with Visibroker ORBs 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 Overview Requirements for Distributed Simulation/Execution DEVS and CORBA: complementary match-up DEVS/CORBA Design and Implementation Applications 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 Feature Languageneutral Data Types Local/remote Transparency High Level Binding Benefit for DEVS Implementation Together with container specification, this can provide a language neutral form of DEVS model specification Supports DEVS-based simulation over heterogeneous

platforms Use of IDL interfaces enables coupling of DEVS components in arbitrary languages and DEVS-based wrapping of legacy code. Self Describing CORBA offers access to configuration meta data that may Meta Data be exploited for understanding model behavior and monitoring simulation progress. CORBA Name service, Event Service, Time Service, etc. offer Services functionality for integration into DEVS/CORBA 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 DEVS/HLA/CORBA Tutorial GPT DEVS/CORBA Interfaces DEVS models

Coordinator 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 TAOs Real-Time EventService Genr Proc stop out Event consumer Event supplier ariv Event supplier SourceID 1 SourceID 3 solv stop

Event Event Event consumer supplier consumer out in Event consumer Transd SourceID 2 SourceID 1 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 ~ activity 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)

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 ORBs and Visibroker ORBs 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 [email protected] 128.196.29.12 Activator Pool [email protected] 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 G User GPT Federation Reference P T

1 Deploy(gpt) DEVS/HLA/CORBA Tutorial 2 Activator @acims4 Activator @acims11 Activator @pisces Model Partitioning And Dispatching G P T Simulator (G) 4

DEVS-CORBA Naming Service 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 (contd) Model Data Base recommendations updates Control Factory of Factory summaries

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 GPT Example executed in DEVS/ CORBA Real-Time Environment Desired Thruput gpEndo Genr HLC gpt Genr

Proc DEVS/HLA/CORBA Tutorial Transd LLC SIW(fall 2000) Proc Transd LLC 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 stop generator (genr)

out out in 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 EFA-DEC PRUNING EFA MULT TRANSD GENR MULT-DEC COORD GENR TRANSD ARCH EF PROCS ARCH-SPEC

EFA-DEC PROC EFA EF EFA-DEC PROC PROC 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

HLA/OMT DEVS SOM Atomic Model System Entity Structure N/A FOM Coupled Model Decomposition Not supported Not supported Specialization & Aspect Routing Partial routing Not supported 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 High-Resolution Terrain Blue Helicopter Logger

(Spatial Event Prediction) Start/stop Log-in messages 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 TERRAIN elevation 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 HELI COPTER EMMISION HELICOPTER

PROPAGATION SIW(fall 2000) 166 Modeling Simulation UA Tucson, AZ Host Name Location Port IP Address Pisces Tucson 12357 128.196.27.96 UA Tucson, AZ STOP Suspend GO UA Federate

DEVS/HLA Simulator Collaborative DEVS Modeler (HLA/OMT) Host Name Location Port IP Address Nexus Sunnyvale 12357 xxx.xxx.xx.xx DEVS/HLA/CORBA Tutorial UA RTI-Executive 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 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 Analysis Model Construction 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 AC DEVS/HLA/CORBA Tutorial build model CM, SC, AC validate model

CM, SC CM: Conventional Meeting SC: Synchronous Collaboration AC: Asynchronous Collaboration 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 Collaborative DEVS Modeler Electronics Div. Tucson, AZ DEVS/HLA/CORBA Tutorial 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 UofA Tucson DEVS/HLA/CORBA Tutorial

GES NJ Collaborative Configuration System Configuration Management/Monitoring UofA Tucson SIW(fall 2000) 174 CDM Architecture Knowledge Worker Knowledge Worker DM DM Modeling Tasks: add component add link etc. 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 Software objects load the LCN via None: only one active job at a time Active software objects: memory loading Object: only one active job per object method Method: an active job for every interaction 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 Arcs a set of interaction arcs Duty Cycle for defining initializer objects Initialization Method for directed modeling of initializer objects Computational Workloads Arcs

Defining software arcs: Modeling concepts 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 Ethernet Hubs Name of hub

Link Speeds for each incident link Bandwidth internal to router Buffer Size internal to router DEVS/HLA/CORBA Tutorial Defining Ethernet Links Name of ethernet Number of Segments for determining worst case propagation SIW(fall 2000) 187 LCN Processor Structure Processor inMsgs inMsgs transport Transport component outMsgs outMsgs

inPkts outPkts outLoop inLoop inLink inLink1 router outLink1 outLink inJobs DEVS/HLA/CORBA Tutorial cpu Inspects destination of packets and routes accordingly CPU component inSW inJobs Converts outgoing DCO messages into packets and incoming packets to DCO messages Router component

inLoop inSW The processor is a DEVS coupled model outJobs outJobs SIW(fall 2000) Invoked DCO software loads memory DCO jobs are received, executed, and released 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 Loosely Coupled Network DEVS/HLA/CORBA Tutorial link

Maps DCO objects onto LCN processors Defines communication modes: message segmentation into packets node SIW(fall 2000) Packet size Packet overhead Packet acknowledgement size Acknowledgement timeout Maps invocation and message arcs onto communications modes 190 DEVS-DOC Experimental Frame 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 drive fireOut 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 Comparing Quantization - Simulated Run Time 1000000 100000 10000 10000 Non-Predictive Predictive 1000 1000 100 Seconds Seconds Comparing Quantization - Ethernet Busy Time 10 1 Multiplexed Non-Predictive Predictive 100

Multiplexed 10 10 100 1000 10000 Number of Sender/Receiver Pairs 1 1 10 100 1000 10000 0 Number of Sender/Receiver Pairs DEVS/HLA/CORBA Tutorial SIW(fall 2000) 197 DEVS-DOC Runtime Performance Comparing Quantization - Real Execution Time

100000 Non-Predictive 10000 Predictive Minutes Multiplexed 1000 100 10 1 1 DEVS/HLA/CORBA Tutorial 10 100 1000 Number of Sender/Receiver Pairs SIW(fall 2000) 10000 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 systems 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 systems 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

RTI Ambasador RTI Ambasador DEVS Federate 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 Joint MEASURE Architecture TM 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 The Non-Distributed Joint MEASURE Architecture TM GIS dB GIS Propagator Sensors C3

Weapons Hull Platform Logger Sensors C3 Weapons Hull Platform DEVS/HLA/CORBA Tutorial SIW(fall 2000) 208 The Non-Distributed Joint MEASURE Architecture TM 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 C 3 Hull

Platform Sensors Propagator Propagator Logger Logger Weapons C3 Hull Platform Weapons 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. 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. Models 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:

Enemy Threat platforms execute on Processor A Friendly HEL Architecture(s) execute on Processor B. 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 senders 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 senders 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 real Px x:

X: Py y: Y: z: Z: 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) #bits(D) 0 non-predictive #computations(D) non-predictive predictive predictive 0

Quantum size, D DEVS/HLA/CORBA Tutorial SIW(fall 2000) Quantum size, D 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 s1/dt s1 d s2/dt s2 Predictive Quantizer Integrator

... s x fn d sn/dt x sn s x s x Component-wise mapping based on predictive quantization Ff1 Ff2 d s1/dt d s2/dt s1 DEVS s2

DEVS ... s x fn F d sn/dt sn DEVS 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

Execution Time (secs.) for case Quantum_size 0.01 a)0.05 0.1 a) c) 5,237 1,050 757 4,856 942 * 845 6,684 1,029 997 fire fire In fire Out DEVS/HLA/CORBA Tutorial

b) c) b) fire Out a) 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 value PQ network value model B2

value model BnPQ D value 1 D model Bn PQ value model An value D D model An1 model B1 DEVS/HLA/CORBA Tutorial 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 Java HLA C++/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 -- dont 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: {hessam|zeigler}@ece.arizona.edu 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

Recently Viewed Presentations

  • Aspects of the Morpho-phonology and Classification of Taiwan ...

    Aspects of the Morpho-phonology and Classification of Taiwan ...

    Morpho-phonology of the Nominal Suffix in Taiwan Hakka Dialects Michael M. Opper Phondi Talk 10/15/2010 Objectives Talk about the phonological fundamentals of four Taiwan Hakka dialects Compare the Nominal Suffix NS in Taiwan Hakka dialects with a particular emphasis on...
  • Hesiod - Theogony (genesis of the gods)

    Hesiod - Theogony (genesis of the gods)

    Hesiod - Theogony (genesis of the gods) Enuma Elish Genesis Wisdom: to see that the world has come to be so that justice triumphs Love and strife Biological reproduction Abstraction, monsters, anthropomorphic gods
  • Chaplains and Quality - healthcarechaplaincy.org

    Chaplains and Quality - healthcarechaplaincy.org

    N = 271 Chaplaincy: A Research-Informed Profession Reviews of Chaplaincy Research Mowat, Harriet (2008). The potential for efficacy of healthcare chaplaincy and spiritual care provision in the NHS (UK): A scoping review of recent research.
  • Cell Membrane Animal Cell Cell Membrane of a

    Cell Membrane Animal Cell Cell Membrane of a

    Animal Cell Cell Membrane Cell Membrane of a Neuron Ion Channels Cell membrane proteins that pass ions in and out of the cell Voltage-Gated Ion Channels gates are regulated by membrane voltage Chemical-Gated Ion Channels (Receptors) gates are regulated by...
  • Abraham Lincoln - Platte County School District Number 3

    Abraham Lincoln - Platte County School District Number 3

    by Don Fisher Abraham Lincoln Born Feb. 12, 1809 Hard Work Many Jobs Lawyer Married Mary Todd Lincoln Led the Union during the War Emancipation Proclamation 1863 Civil War Ended in April 9,1865 Five days later Lincoln went to the...
  • Don&#x27;t Be Afraid to Ask

    Don't Be Afraid to Ask

    Recursive smoothing filter applied to two time series. A) Time series, h(t) (dots), is a unit spike. The smoothed version, θ (t) (solid line), a decaying exponential, is the impulse response of the smoothing filter. B) Time series, h(t) (dots),...
  • Nouns - Ms. Casino&#x27;s Classroom

    Nouns - Ms. Casino's Classroom

    Nouns. are words that name a person, place, thing, or idea. Everything that you can see, you can name. Look around the room. What do you see? Share with your partner. Each of the people, places, or objects you named...
  • Essays

    Essays

    Thesis Statements. A thesis statement manages to encapsulate an essay's main argument in a succinct, one-sentence comment. Beginner writers often times find it useful to create an essay map thesis, where the thesis briefly lists the areas that will be...