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

4.2 Plan Vectorization
p1
o1 o2 o3
o4 o5 o6
p2
o1 o2 o3 o4 o5 o6
t0(p1)
t1(p1)
t0(p2)
time t
t1(p2)
(a) Instance-Based Execution of Plan P
p1
o1 o2 o3
o4 o5 o6
p2
o1 o2 o3 o4 o5 o6
t0(p1) t0(p2) t1(p1)
t1(p2)
possible improvement
due to vectorization
time t
(b) Fully Vectorized Execution of Plan P ′
Figure 4.3: Temporal Aspects of Instance-Based and Vectorized Plans
Definition 4.1 (Plan Vectorization Problem (P-PV)). Let P denote a plan, and p i ∈
{p 1 , p 2 , . . . , p n } denotes the plan instances with P ⇒ p i . Further, let the plan P contain a
sequence of atomic or complex operators o i ∈ {o 1 , o 2 , . . . , o m }. For serialization purposes,
the plan instances are executed in sequence, where the end time t 1 of a plan instance is
lower than the start time t 0 of the subsequent plan instance with t 1 (p i ) ≤ t 0 (p i+1 ). Then,
the P-PV describes the search for the vectorized plan P ′ (with data flow semantics) that
exhibits the highest degree of parallelism for the plan instances p ′ i such that the constraint
conditions (t 1 (p ′ i , o i) ≤ t 0 (p ′ i , o i+1)) ∧ (t 1 (p ′ i , o i) ≤ t 0 (p ′ i+1 , o i)) hold and the semantic correctness
(see Definition 3.1) is ensured.
The same rules of ensuring semantic correctness as used for inter-operator parallelism
in Chapter 3 also apply for vectorized plans. For example, this requires synchronization of
writing interactions. However, we assume independence of plan instances, which holds for
typical data-propagating integration flows. This means that we synchronize, for example,
a reading interaction with a subsequent writing interaction of plan instance p 1 but we
allow executing the reading interaction of p 2 in parallel to the writing interaction of p 1 .
Nevertheless, monotonic reads and writes are ensured. We will revisit this issue of intrainstance
synchronization when discussing the rewriting algorithm.
Based on the P-PV, we now reveal the static cost analysis of the best case (full pipelines),
where cost denotes the total execution time. Let P include an operator sequence o with
constant operator costs W (o i ) = 1, the costs of n plan instances are
W (P ) = n · m
W (P ′ ) = n + m − 1
∆(W (P ) − W (P ′ )) = (n − 1) · (m − 1),
// instance-based
// fully vectorized
(4.1)
where m denotes the number of operators. This is an idealized model only used for
illustration purposes. In practice, the improvement depends on the most time-consuming
operator o max with W (o max ) = max m i=1 W (o i) of a vectorized plan P ′ because the workcycle
of the whole data flow graph depends on this operator due to filled queues (with
maximum constraints) in front of this operator. We will revisit this effect when discussing
the cost-based vectorization in Section 4.3. The costs are then specified by:
W (P ) = n ·
m∑
W (o i )
i=1
W (P ′ ) = (n + m − 1) · W (o max ).
// instance-based
// fully vectorized
(4.2)
91