Transformations to Support Model Evolution and Scalability

1
Transformations to SupportModel Evolution and
Scalability

• Jeff Gray, Yuehua Lin, Jing Zhang
• ACM Midsoutheast November 2005

2
Overview of Presentation
Background andChallenges
Criteria for Scalability
Alternative Approaches
ExampleReplicators
3
Background Model Integrated Computing (MIC)
Metamodeling Interface
Application Domain
Application Evolution
Environment Evolution
App 1
App 2
App 3
Modeling Environment
Model Builder
The Generic Modeling Environment (GME) adopts the
MIC approach and provides a plug-in mechanism for
extension.
4
Example DSMLs (not UML)
5
Ability to evolve models

• The size of system models will continue to grow
• We have created models containing several
  thousand modeling elements
• Others have reported similarly (Johann/Egyed
  ASE 2004)
• A key benefit of modeling
• Ability to explore various design alternatives
  (i.e., knobs)
• E.g., understanding tradeoff between battery
  consumption and memory size of an embedded device
• E.g., scaling a model to 800 nodes to examine
  performance implications reduce to 500 nodes
  with same analysis
• Reducing complexities of the modeling activity
• Limit the amount of mouse clicking and typing
  required within a modeling tool to describe a
  change
• Improves productivity and reduces potential
  manual errors

A general metric for determining the
effectiveness of a modeling toolsuite comprises
the degree of effort required to make a correct
change to a set of models.
6
Previous Challenge Crosscutting Constraints in
Real-Time/Embedded Models
Crosscutting Constraints
A
B
F
c
d
e
B
B
c
d
e
c
d
e
Changeability???

• Crosscutting in Models
• Base models become constrained to capture a
  particular design
• Concerns that are related to some global property
  are dispersed across the model

Solution first presented in Comm. ACM 2001 (AOP
Issue) and AOSD book chapter
7
C-SAW Model Transformation Engine
MetaModel
M
M
ECL Interpreter
o
o
d
d
e
e
l
l
i
i
n
n
g
g




A
A
P
P
ECL Parser
I
I
s
s
Implemented as a GME plug-in to assist in the
rapid adaptation and evolution of models by
weaving crosscutting changes into models.
8
New Challenge Replicating a Base Model to
Address Scalability Issues
Three UAV Model
Single UAV Model

• Model Scalability
• Base models must be replicated to explore
  alternative designs
• Model elements need to be replicated, in addition
  to all required connections

9
Contribution and definition

• Core contribution
• This work makes a contribution to model
  scalability by describing a model transformation
  approach that enables automated replication to
  assist in rapidly evolving a model.
• Definition
• replicator a model transformation that
  expands the number of elements from a base model
  and makes the correct connections among those
  elements

10
Example applications

• Event QoS Aspect Language
• Specify properties of event-based communication
  within a DRE (e.g., mission-computing avionics)
• System Integration Modeling Language
• Specify properties of high-performance physics
  experiments
• UAV QoS Language (not described here)
• Specify properties of video QoS in an Unmanned
  Aerial Vehicle
• Future A language to address performance issues
  among distributed systems using network patterns

11
Event QoS Aspect Language (EQAL)

• Assists in specification of publish-subscriber
  event service configuration for large-scale DRE
  systems
• Publishers generate events to be transmitted
• Subscribers receive events via hook operations
• Event channels accept events from publishers, and
  deliver events to subscribers
• Replication requirements
• Add 5 CORBA_Gateways to each original site
• Repeatedly replicate one site instance to add 5
  more extra sites, each with 5 additional
  CORBA_Gateways
• Create all required connections among replicated
  models

12
Scaling the Event QoS Aspect Language
strategy expandSite(site, numGW integer)
findModel("Site " intToString(site)).addGateWay_
r(1, numGW) strategy addGateWay_r(curr, numGW
integer) if (curr lt numGW) then
addGateWay(curr) addGateWay_r(curr1,
numGW) endif strategy addGateWay(num
integer) declare site_gw atom declare ec
model site_gw addAtom("CORBA_Gateway",
"CORBA_Gateway" intToString(num)) ec
findModel("Event_Channel") addConnection("Local
Gateway_EC", site_gw, ec)
13
Conclusion

• Related work
• Much related work in model transformation and
  supporting tools
• We believe the general idea is applicable to
  other MT tools
• Not able to locate any literature on the general
  scalability issue as it applies to automated
  transformation (any ideas?)
• Future work
• Transformations may be reused often and influence
  the correctness of the modeling process
• Improved capabilities to test and debug within
  C-SAW are currently under investigation
• Layer a DSML on top of a performance analysis
  solver DSML will abstract various networking
  design patterns (e.g., reactor pattern) base
  models will be scaled using replicators to
  explore performance implications

14
Conclusion

• Benefits of replicators as model transformations
• Domain independence
• Initial evidence that productivity (in terms of
  design exploration) is improved, as well as
  correctness of the resulting model
• Primary limitation of automated approach
• Without the addition of screen layout information
  in the model transformation, the resulting view
  may be cluttered or unreadable

15
For More Information
Replicators and Two-Level Aspect Weaving
http//www.cis.uab.edu/gray/Research/C-SAW/Contai
ns papers, downloads, video demos
Generic Modeling Environment
http//www.isis.vanderbilt.edu/Projects/gme
16
Notes

• Not UML models
• Instances of system elements
• Not PIM to PSM transformations
• Replicator name not object or database
  replication

17
System Integration Modeling Language (SIML)

• Assists in specification of configuration of
  large-scale fault tolerant data processing
  systems
• Used to model several thousand processing nodes
  for high-performance physics applications at
  Fermi Accelerator Lab
• A system model may be composed of independent
  regions
• Each region may be composed of local process
  groups
• Each local process group may contain primitive
  application models
• Each system, region, and local process group must
  have a manager that is responsible for mitigating
  failures in its area
• Replication requirements
• Replication of local process group nodes
• Replication of entire region models and their
  contents
• Generation of communication connections between
  regional managers and newly created local
  managers
• Generation of additional communication
  connections between the system manager and new
  regional manager processes

18
Scaling the System Integration Modeling Language
aspect Start() scaleUpNode("L2L3Node", 5)
scaleUpRegion("Region", 8) strategy
scaleUpNode(node_name string max integer)
rootFolder().findFolder("System").findModel("
Region").addNode(node_name,max,1) strategy
addNode(node_name, max, idx integer)
declare node, new_node, input_port,
node_input_port object if (idxltmax)
then node rootFolder().findFolder("System")
.findModel(node_name) new_node
addInstance("Component", node_name,
node) input_port findAtom("fromITCH") no
de_input_port new_node.findAtom("fromITCH")
addConnection("Interaction", input_port,
node_input_port) addNode(node_name, max,
idx1) endif strategy
scaleUpRegion(reg_name string max integer)
rootFolder().findFolder("System").findModel("
System").addRegion(reg_name,max,1) strategy
addRegion(region_name, max, idx integer)
declare region, new_region, out_port,
region_in_port, router, new_router object
if (idxltmax) then region
rootFolder().findFolder("System").findModel(region
_name) new_region addInstance("Component",
region_name, region) out_port
findModel("TheSource").findAtom("eventData")
region_in_port new_region.findAtom("fromITCH")
addConnection("Interaction", out_port,
region_in_port) router
findAtom("Router") new_router
copyAtom(router, "Router") addConnection("Rou
ter2Component", new_router, new_region) addRe
gion(region_name, max, idx1) endif
19
Discussion

• Physical limits of manual replication
• SIML models have been scaled by-hand to 32 and 64
  nodes
• After 64 nodes, the manual process deteriorated
  taking several days with multiple errors
• Benefits of automated replication
• Replication is parameterized and can be evolved
  rapidly
• Using a model transformation, SIML models have
  been scaled up to 2500 nodes
• The time to create the model transformation by a
  user unfamiliar with the domain lt 1.5 hours