Cost-Based Optimization of Integration Flows - Datenbanken ...

4 Vectorizing Integration Flows
Invoke (o5)
[service s6, in: msg2, out: msg4]
δ msg4
D
Invoke (o6)
[service s6, in: msg3, out: msg5]
Invoke (o5)
[service s6, in: msg2, out: msg4]
Invoke (o6)
[service s6, in: msg3, out: msg5]
Assign (o7)
[in: msg4, out: msg6]
δ msg5
D
Assign (o7)
[in: msg4, out: msg6]
Assign (o8)
[in: msg5, out: msg7]
δ msg6
D
Assign (o8)
[in: msg5, out: msg7]
Invoke (o9)
[service s7, in: msg6]
δ msg7
D
Invoke (o9)
[service s7, in: msg6]
AND (oa)
[in: msg7, out: msg7]
Invoke (o10)
[service s7, in: msg7]
Invoke (o10)
[service s7, in: msg7]
(a) Dependency Graph DG(P 8) of Subplan P 8
(b) Vectorized Subplan P ′ 8
Figure 4.7: Rewriting Invoke Operators
4.2.3 Cost Analysis
We already discussed the cost analysis of sequences of operators, where each operator o i
has a single data dependency with the previous operator o i−1 . In addition, we investigate
the costs with regard to the specific rewriting results. Therefore, we reuse the idealized
model where each operator exhibits constant costs with W (o i ) = 1. Similar to the case of
operator sequences, this can be extended to the case of arbitrary operator costs.
Parallel data flow branches. In the case of different data flow branches, messages are
processed by |r| concurrent pipelines within one vectorized plan, where a single pipeline
r i contains |r i | operators. Examples for this type of branches are simply overlapping
data dependencies, as well as the Switch and the Fork operator. In this case of multiple
branches with |r| ≥ 2, the idealized costs for processing n messages are
{
n · m instance-based (unoptimized)
W (P ) =
n · max |r|
i=1 (|r i|) instance-based (optimized, if applicable)
|r|
W (P ′ ) = n + max (|r i|) − 1 fully vectorized,
i=1
(4.6)
where max |r|
i=1 (|r i|) denotes the longest branch. The benefit compared to inter-operator
(horizontal) parallelism depends on the optimization techniques that could be applied on
the instance-based representation because not all operators without data dependencies can
be parallelized (e.g., sequence of writing interactions). Furthermore, in the case of |r| = 1
and thus, |r 1 | = m, the general cost analysis stays true. The improvement is caused by the
higher degree of parallelism. However, the presence of parallel data flow branches may also
cause overhead for vectorized plans with regard to splitting and merging those branches.
An example for the splitting of branches is the Copy operator that is used for multiple
dependencies on one message. Further, examples for the merging of branches are the And
operator for synchronizing external writes as well as the Xor operator for synchronizing
the Switch operator.
Rolled-out Iteration. Further, the rewriting of Iteration operators with foreach
semantics needs some consideration. Here, we split messages according to the foreach
condition and execute the iteration body as inner pipeline without cyclic dependencies.
Finally, the processed sub messages are merged using the Setoperation operator (UNION
98