QVTd Relation Overriding

The QVT specification has a relatively clear specification that QVTr relation may override, but no clues as to how this is mapped to QVTc that has no overrides concrete syntax, even though it inherits an overrides capability from QVTb.

This working document considers how overriding might be supported. It takes over from

• https://bugs.eclipse.org/bugs/show_bug.cgi?id=508267 [qvts] Introduce MicroMapping Alternator/Switch
• https://bugs.eclipse.org/bugs/show_bug.cgi?id=515327 [qvtc] Support overrides / refines

QVTc Choices

QVTc refinement syntax is an additive capability and therefore not suitable for implementing the QVTr replacement semantics of QVTr overrides.

We could add overrides syntax and semantics to QVTc, which then passes the buck to QVTi. But since we already need an 'alternator' to dispatch multiple similar but differently predicated mappings efficiently, we may be able to kill two birds with one stone.

QVTc is relatively simple. It solves the mapping sequencing problem by inter-trace class references/dependencies. Can it solve the overrides problem as-is? Let's go with this.

QVTr2QVTc Overrides 'Rewrite'

There is a simple rewrite that reifies overrides in QVTc without requiring any new capabilities, although it may stress some existing ones.

Given a transformation comprising Mx mappings/relations, Gx guard functions, and Bx bottom actions:

MA: when { GA(); } BA();
MB overrides MA: when { GB(); } BB();
MC overrides MB: when { GC(); } BC();
MD overrides MA: when { GD(); } BD();

we can rewrite the polymorphs (relations that participate in an overrides hierarchy) as siblings (relations that share a similar structural interface), refined guard functions and dispatchers:

MAsibling: when { GAsibling(); } BA();
MBsibling: when { GBsibling(); } BB();
MCsibling: when { GCsibling(); } BC();
MDsibling: when { GDsibling(); } BD();

GAsibling() = !GBsibling() && !GDsibling() && GA();
GBsibling() = !GCsibling() && GB();
GCsibling() = GC();
GDsibling() = GD();

MAdispatcher: when { GAdispatcher(); } where { MAsibling(); MBsibling(); MCsibling(); MDsibling(); }
MBdispatcher: when { GBdispatcher(); } where { MBsibling(); MCsibling(); }
MCdispatcher: when { GCdispatcher(); } where { MCsibling(); }
MDdispatcher: when { GDdispatcher); } where { MDsibling(); }

GAdispatcher() = GAsibling() || GBsibling() || GCsibling() || GDsibling();
GBdispatcher() = GBsibling() || GCsibling();
GCdispatcher() = GCsibling();
GDdispatcher() = GDsibling();

• introduce Gxsibling() equal to Gx() anded with the Gxsibling()es of all directly overriding relations.
• introduce Mxsibling() equal to Mx() using Gxsibling() to replace the override.
• replace Mx by an Mxdispatcher to all the new siblings

Mxdispatcher and Gxdispatcher can be omitted if there is no direct invocation of Mx.

(The aggregating Gxdispatcher() operations are required to ensure that Mxdispatcher dispatch fails if no override matches.)

Rewrite reification in QVTr2QVTc

We need to synthesize Gx() as a Function/Operation invoked from the Mapping Guard rather than being inlined in the Mapping Guard. All type checks must use explicit oclIsKindOf's since we cannot exploit 'mismatch is predicate fail' semantics within Function/Operations.

Whether Function/Operation should be used to exploit/bypass uniqueness optimizations is unclear. Probably doesn't matter. If QVTi understands what's happening, QVTi can optimize merged invocations behind the uniqueness of the polymorphic dispatcher.

Should relations that are not overridden also have their predicates structured as guard functions?

• pro: a simplification reducing QVTr2QVTc complexity
• pro: sibling mappings are also exposed to QVTi dispatch optimization
• con: increases stress on QVTs deep operation analysis - needs to work anyway
• con: further deviation from RelToCore

2 strong pro's, 2 weak con's => always create guard functions.

A distinct guard function may allow a failed guard to have a distinct and more optimum trace class for incremental update.

In order to avoid recomputing all the intermediate guard/bottom pattern variables the Mxdispatcher's trace class must provide properties to pass context between Gxsibling, Mxdispatcher and Mxsibling. For the degenerate case of no dispatcher the sibling's trace class should serve the same function.

Rewrite reification in QVTc, QVTu, QVTm, QVTs

There should be no change, but deep operation dependency analysis will need to work for QVTs.

But, what about partitioning? Is it necessary to partition guard functions?

Rewrite reification in QVTi / run-time

Nothing necessary, but significant optimizations available.

The dispatch of one or Micromappings from a Connection currently invokes each relevant Micromapping. No change since each synthetic override has full exclusions in its own predicate. However there may be many available Micromappings each with a guard function. These can be hoisted into a dispatcher and CSE applied to dramatically reduce recomputation. Since the failed guard functions are invoked by the dispatcher, the failures do not need to be traced, incremental redispatch from the Connection will redetermine what needs to be done correctly. These optimizations apply to siblings as well as polymorphs.

If we add a QVTi syntax to support the decision tree, the optimized dispatch can work in interpreted as well as code generated execution.

The CSE will need to work on the OCL expressions and so we need to generalize CSE support from CG-only. [1]

It may be helpful to structure the guard functions in disjunctive normal form within a let-variable CSE hierarchy to facilitate partitioning.

QVTs Partitioning

The alternative to a QVTr2QVTc synthesis is to just propagate the 'overrides' semantic till much later.

Rather than worry about how to partition functions, perhaps the Partitioner could partition the Gx() of each Mx() withput ever needing to create the artificial Gx(). We have the flexibility to introduce QVTs/QVTi constructs to directly support the reified semantic rather than contort into standard QVTc whose idioms must be dismantled later.

Both approaches have the same semantic to resolve:

'QVTr2QVTc rewrite' adds unpleasant complexity to the QVTr2QVTc to express predicates overtly as functions so that another layer of functions defines the overrides. QVTs then has to struggle to make sense of the functions.

'Overrides partitioning' just passes 'overrides' through QVTc, then uses the Partitioner to perform the rewrites where rewrites are already performed. The predicates are partitioned as preliminary micromappings and not-success dependencies lock-out the unwanted executions.

In both cases QVTi/Connection synthesis optimizes the treatment of siblings. For the 'QVTr2QVTc rewrite' idiomatic functions need recognition, for the 'partitioner' shared state is possible.

synthresize