Difference between revisions of "EMF Compare/2012EMFCompareEnhancements"

From Eclipsepedia

Jump to: navigation, search
(Diff model restructuring to ease exploitation)
(Diff model restructuring to ease exploitation)
Line 20: Line 20:
 
** Stereotype
 
** Stereotype
 
** Any other data needed to re-create a Model / Diagram diff
 
** Any other data needed to re-create a Model / Diagram diff
 +
These API will specifically focus on making easier to reuse and integrate the diff model results in other tools like R4E.<br/>
 
It will be possible to re-create a Diff instance from the serialized information above. <br/>
 
It will be possible to re-create a Diff instance from the serialized information above. <br/>
Reworking those APIs will specifically focus on making easier the reuse and integration of the diff model
 
results in other tools.<br/>
 
 
UML and SysML comparison features will be updated accordingly.
 
UML and SysML comparison features will be updated accordingly.
  

Revision as of 05:17, 9 March 2012

This work is developed by Obeo and sponsored by Ericsson in the context of the Polarsys

Contents

EMF Compare integration

Diff model restructuring to ease exploitation

The diff model provided as a result by EMF Compare can be quite complex to leverage for several reasons :

  • The model is missing an “origin” information (remote, local, ancestor, hierarchy, with user name when possible), leading to excessive abstract types of changes in the diff model.
  • “DiffGroup” have to be created/deleted on demand by the adopter modifying a diff model, this concept should be either deleted or have utility methods to make sure the diff model is valid.
  • Lack of browsing and cross-referencing APIs
  • DiffElements should be easily serializable for storage of DiffElement selections and reuse of these selections in order to open the comparison editors at the right place.

We are working on a new API to directly retrieve the following serializable information from each Diff:

    • Description as provided by Structural differences in the Eclipse compare
    • Modification type
    • Element Details e.g. class name, package name, diagram, etc.
    • Meta-Meta model details e.g. Eclass, EPackage
    • Model Location e.g. xmi-id
    • Diagram Details e.g. element name, type, etc..
    • Stereotype
    • Any other data needed to re-create a Model / Diagram diff

These API will specifically focus on making easier to reuse and integrate the diff model results in other tools like R4E.
It will be possible to re-create a Diff instance from the serialized information above.
UML and SysML comparison features will be updated accordingly.

EMF Compare usability

DiffElement selection

From the stored DiffElement, to enable to select the related DiffElement in the current comparison editor. If no DiffElement matches, open a new comparison editor which contains the DiffElement to select.

Contextual menu contribution

To enable to contribute your own right click menu on the comparison editor, through extension point.

Undo/Redo support for the comparison editor

There is currently no way to undo merge operations done through EMF Compare. Support for undo/redo actions on these operations will be handled directly from the UI, with an accessible API for standalone merging.

Conflict resolving wizard

Currently, conflicts detected by EMF Compare are resolved by overriding : users either select the "local" version or the "remote" version, but cannot resolve the conflict by merging some parts of the change. This will be resolved through the addition of a new wizard accessible from the UI for conflict resolution.

Standalone comparison editor

Implementation of a standalone comparison editor that can be reused by third-party plugins to display comparison results. The current comparison editor relies on the comparison editor framework provided by the Eclipse platform. It provides the advantage of a good integration in the Eclipse platform, but can be not enough customizable in some cases. This feature includes both an editor mimicking the looks and behavior of the "standard" comparison editor, and the API to use and customize it out of the context of the team API.

UML Compare / Merge Performance Enhancements

Handling very large models

After the work done in 2011, there are still some needs for enhancements to be able to support large model comparisons and to fully support logical models. These enhancements focus on restricting the scope of a comparison, and on getting faster and using less memory when we compare and merge large models.

Scoped models comparison

EMF Compare has the concept of a “scoped” comparison to ignore changes which are not in scope, but in term of implementation the complete UML model gets loaded (two or three versions of it depending on whether we need to detect conflicts or not). Thanks to the Logical Model implementation we now have the ability to create the complete graph of files composing a model and their SCM status. From this information we will be able to implement a comparison scope which will only load the changed fragments, avoiding to load the complete UML model. It will lead to considerable cpu time and memory usage gains and will enable to handle the minimal set of model fragment during a comparison. To do so we need to implement a first analysis pass to build the minimal scope of the comparison, and then leverage this scope during the whole comparison process. In order to illustrate the expected gains, we can consider that a model is composed of F fragments (diagrams or semantic models' fragments alike) and that the size of all fragments is the same X MB. We also consider that all three versions (local, remote, ancestor) of the model have the same number F of fragments, and that all three versions' fragments share the same size X MB when loaded in memory. Currently, a comparison through EMF Compare will need to load the whole model for all three versions. It thus takes (3 * F * X) megabytes in memory for a single comparison; both for the comparison and the UI display of the comparison result. The described enhancement will allow us to determine beforehand which model fragments have changed, allowing us to only load and compare this minimal number n of fragments in memory. Such comparisons will thus be limited to (3 * n * X) megabytes in memory for the comparison process. However, displaying the result of these comparisons in the UI is dependent of the framework. Displaying these comparison results in EMF Compare's tree viewers will only show the changed fragments, thus limiting the UI occupation to (3 * n * X) megabytes; but displaying these results in graphical editors such as papyrus might necessitate loading the whole models, whatever the changed fragments are. It depends on the graphical framework: to display diagram D, papyrus might need to load more semantic model fragments that the "changed" set. In the worst case scenario, displaying graphical comparison results will take (3 * F * X) megabytes. In terms of performance, the improvement will be of a comparable level of magnitude than for memory as the use of Logical Models will result in a drastic reduction of processing from the current situation (we compare the whole model) to the comparison of the minimal set of consistent UML fragments. A performance evaluation report and a profiling report will be provided to illustrate these enhancements. A new API will be provided to resolve the minimum set of fragments for a two way compare of two different versions of a UML model / Diagram e.g. left and right related diagram and model fragments in order to enable a compare session independently of the projects loaded in the work space. Additionally to the implementation of Scoped comparisons, the two following tasks correspond to the full support and test of these scoped implementation in the Generic and UML engines.

Update the engine and UI to avoid any un-necessary proxy resolution

Once the scope is defined the comparison engine (responsible for the match and diff process) and the user interface presenting the result should never ever resolve proxies which are out of this scope. We need to update the implementation and the corresponding non regression tests in this regard.

Update the UML engine to avoid any un-necessary proxy resolution

The UML engine extends the generic engine to create higher level diffs and to manage UML specific diff dependencies. Through this extension the implementation might lead to un-necessary proxy resolutions, we would need to update the implementation to make sure that would not happen.