Model Intelligence Guides (MIGs) An opensource project available from: http://www.eclipse.org/gmt/gems
Modeling scalability challenges for large systems. Model-driven engineering (MDE) is a promising form of system development that combines high-level visual abstractions that are specific to a domain with constraint checking and code-generation to simplify software development. As model-based tools and methodologies have evolved, however, it has become clear that in certain domains, such as distributed real-time and embedded (DRE) systems, the models are so large and the domain constraints so intricate that it is extremely hard for modelers to manually produce correct and high-quality models. In these domains, modeling tools that only provide solution-correctness checking via constraints provide few benefits over conventional hand-crafted development methods since the key complexity in these domains is their large model sizes and combinatorial constraints, not code construction per se. For example, specifying the deployment of software components to Electronic Control Units (ECUs), which are the automotive equivalent of a CPU, in a car, while observing configuration and resource constraints can easily generate solution spaces with millions or more possible deployments and few correct ones, even with only a few tens of model entities. For these large modeling problems, it is infeasible to create a complete and valid model manually.
Consider a group of 9 components that need to be deployed to one of 9 ECUs within a car. There are 9^9 = 387,420,489 unique deployments that could be tried. Part of the complexity, therefore, is how quickly the solution spaces grow as the number of model elements increases. A difficulty of highly combinatorial domains is that although modelers may satisfy domain constraints, their models may have poor quality, e.g., a modeler manually deploying components to nodes might use far more nodes than the minimum number required to host the set of components. Another difficulty is that modelers are lucky to find any valid solution with large models and complex constraints. Since finding a single solution is so hard, it becomes infeasible to produce scores of valid solutions and search for an optimal one. Although numerous numerical methods can search for a solution with a given percentage of optimality, they all rely on the ability to generate large numbers of valid solutions, which is not possible without automation.
In domains with large models and intricate constraints, modelers must be able to see hundreds of modeling moves into the future to satisfy global constraints or optimize costs. The more localized modeler decisions areand the less distant they peer into the futurethe less chance they can find a correct or good solution. One approach to creating solutions for problems in these domains is to transform partial solutions specified by modelers, such as listing the components and nodes they may be deployed to, into a format that can be solved using a general purpose solver, such as a constraint logic programming solver. There are many optimization, constraint solver, and inference engines available for this purpose. However, modeling is emerging as a major challenge since it is hard to automate the formulation of real problems in a suitable form for efficient algorithmic processing. Transforming an arbitrary graphical model into a format suitable for a general purpose solver is therefore tedious and error-prone. Likewise, integrating the results of the solver back into a modeling tool and providing interactive capabilities is also hard.
Solution approach -> Model Intelligence Guides address the challenges of modeling large and complex domains by:
With a constraint-solver integrated modeling environment, users go through an iterative process of specifying portions of a model, adding or refining existing domain constraints, debugging constraints that are not tractable, and using the constraint solver to automate model construction and optimization.
MIGs can guide the user in making localized decisions by highlighting optimal or valid model modifications and decrease user effort and modeling time. The solver framework can also be used to complete a batch process of model changes, such as connecting all components to a valid host, while respecting global constraints. Batch processes performed by MIGs arrive at higher quality solutions in less time than a manual approach. Finally, in situations when the users partial model (such as a listing of components and nodes they must be deployed to) cannot satisfy the domain constraints (e.g. the modeled nodes do not have sufficient resources to host the components) MIGs can suggest ways of bringing the model to a state that satisfies the domain constraints. For example, MIGs might indicate that a particular nodes available memory be increased to satisfy a failed resource requirement.
Papers:
Andrey Nechypurenko, Jules White, Egon Wuchner, and Douglas C. Schmidt, Applying Model Intelligence Frameworks for Deployment Problem in Real-time and Embedded Systems, Proceedings of MARTES: Modeling and Analysis of Real-Time and Embedded Systems to be held on October 2, 2006 in Genova, Italy in conjunction with the 9th International Conference on Model Driven Engineering Languages and Systems, MoDELS/UML 2006.
Generic Eclipse Modeling System (GEMS) An opensource project available from: http://www.sf.net/projects/gems
GEMS is a configurable toolkit for creating domain-specific modeling
and program synthesis environments for Eclipse. The configuration is accomplished through metamodels specifying the modeling paradigm
(modeling language) of the application domain. The modeling paradigm contains all the syntactic, semantic, and presentation information
regarding the domain; which concepts will be used to construct models, what relationships may exist among those concepts, how the concepts
may be organized and viewed by the modeler, and rules governing the construction of models. The modeling paradigm defines the family of
models that can be created using the resultant modeling environment.
The built-in metamodeling language is based on the UML class diagram notation. Metamodels in other E-core readable formats can be used as
well. Metamodel constraints are specified in Java. Once a metamodel has been imported, an interpreter is run that traverses the model and
generates an Eclipse plug-in for editing instances of the Domain Specific Modeling Language (DSML) described by the
metamodel. The generated plug-in uses Eclipse's Graphical Editor Framework (GEF) and
Draw2D plug-in to visualize the DSML as a diagram. Instances of the DSML may also have interpreters run on them to generate various
artifacts or perform complex analyses.
GEMS is the frramework that we are building all of our other Eclipse
based modeling environments on. We are also planning to transition
several of our modeling tools built on GME to GEMS.
FireAnt, Model Driven Deployment of Enterprise Java Bean Applications
The effectiveness of deployment and
configuration capabilities can be measured by three metrics: (1) the correctness
of the deployment plan, i.e., whether or not the configuration and deployment
of each component is accounted properly for, (2) the execution accuracy of
the system, i.e., whether or not the plan is executed properly, and (3) the execution
reproducibility, i.e., whether or not the plan can be executed repeatedly
with the same results.
FireAnt is a tool used to address the challenges of deploying and configuring EJB applications. FireAnt is a model-driven tool designed to improve deployment plan correctness by (1) visually capturing the components that need to be deployed and their dependencies, (2) describing the target infrastructure required for the deployment, (3) visually specifying which components are to be deployed and configured on which machines, (4) visually specifying the configuration of the components on each target, and (5) providing constraint checking to ensure that each component and its dependencies are accounted for properly. The FireAnt deployer takes the deployment models produced by they modeling tool and does the run-time execution of the deployment plan to provide execution accuracy and reproducibility.
Project Website:
http://www.sf.net/projects/fireant
Papers:
http://www.dre.vanderbilt.edu/~jules/DnC_Ejb_Paper_3.doc
Modeling Service Oriented Architectures (SOA)
To simplify the process of developing SOAs and ensuring their QoS
requirements are met, we are creating an eclipse plug-in for
model-driven development (MDD). The tool will focus on the choice and generation of J2EE-based service architectures that use the Apache
Axis web services development kit. Expressive power in MDD is gained via notations and abstractions that are aligned more with the
application domain, rather than low-level features of operating
systems, middleware platforms, and third-generation programming
languages. In particular, MDD uses visual representations to model
domain-specific abstractions, which enables designers of SOA's to
construct models that incorporate domain and QoS concepts as
first-class entities. Analysis can then be performed on the models to determine the appropriate service architecture and synthesize
implementations for both the internal and external service buses that can be configured, deployed, and integrated seamlessly with
applications written using J2EE. We have received an Eclipse
Innovation grant for this work.
We are also very interested in describing SOAs that integrate J2EE
systems and Corba systems. Raytheon is very interested in describing the communication between these systems, using a tool such as this,
and then generating the bus between the systems using either either the Java Connector Architecture or SOAP.
We are working with Cisco to provide implementations of the BEEP
protocol(RFC3080, RFC3081). After creating implementations of BEEP over Java NIO and the Adaptive Communication Environment (ACE), we
will implement SOAP over BEEP. Part of this work includes the development of a DSML for modeling SOAP applications. We plan to
support specification of message composition, messaging style, and behavior for SOAP systems. The tool will then generate driver code and
other implementation artifacts for building the modeled system.
Project Website: http://www.sf.net/projects/j2eeml
Screenshots: http://sourceforge.net/project/screenshots.phpgroup_id=129443
Paper: http://www.cs.wustl.edu/~schmidt/PDF/J2EEML.pdf
the J3 Process, is an open-source MDD environment that supports the rapid design and implementation of autonomic applications. J3 consists
of several MDD tools and autonomic computing frameworks, including (1) J2EEML, which captures the design of EJB applications, their quality
of service (QoS) requirements, and the autonomic adaptation strategies of their EJBs via a domain-specific modeling language
(DSML), (2) Jadapt, which is a J2EEML model interpreter that analyzes the QoS and
autonomic properties of J2EEML models, and (3) JFense, which is an autonomic framework for monitoring, configuring, and resetting
individual EJBs.
The J3 Process contains the following MDD tools and component
middleware frameworks that address the challenges of developing
autonomic EJB applications:
J2EEML, which is a DSML-based MDD tool tailored for designing
autonomic EJB applications that uses visual representations to model domain-specific abstractions. J2EEML provides a formal mapping from
QoS requirements to application components.
Jadapt, which is an MDD tool that produces many artifacts required to implement autonomic EJB applications modeled in J2EEML. Jadapt generates code that meets the J2EEML specifications and also reduces the amount of code that application developers must write manually.
JFense, which is an autonomic framework that provides components for monitoring, analysis, planning, and execution. Developers can use these components to avoid writing custom autonomic frameworks. JFense can be configured to meet the autonomic requirements of a variety of EJB applications.
The J3 Process is currently built on top of GME but uses JET
templates. We plan to transition it to GEMS.