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

4 Vectorizing Integration Flows
4.3.4 Operator-Aware Cost-Based Vectorization
Although the cost-based vectorization described so far significantly improves performance,
it has one drawback. When rewriting an instance-based plan into a cost-based vectorized
plan, we take only the costs of originally existing operators into account. Thus, the optimization
objective is to minimize the number of execution buckets with lowest possible
maximum bucket execution costs. However, we neglected the overhead of additional operators
such as Copy, And or Xor that are only used within vectorized plans. In conclusion, an
operator-aware rewriting approach is required in order to improve the standard cost-based
vectorization approach.
In detail, we use explicit cost comparisons for operators that are only used for vectorized
plans. With this concept, we can ensure that the performance is not hurt by costs of those
additional operators. We explain this using the Copy operator as an example.
Example 4.9 (Operator-Aware Cost Comparison). Assume the instance-based subplan
illustrated in Figure 4.15(a) and the given operator costs.
o1
W(o1)=2
o2
W(o2)=3
o3
W(o3)=5
o4
W(o4)=4
W(P) = n · 14
Copy
W(cp)
o1 o2
W(o1)=2 W(o2)=3
o3
W(o3)=5
o4
W(o4)=4
W(cp) ≤ W(o3):
W(P) = (n + 2) · 5
W(cp) > W(o3):
W(P) = (n + 2) · W(cp)
(a) Instance-Based Subplan
(b) Cost-Based Vectorized Subplan
Figure 4.15: Example Operator Awareness
The costs of processing n messages are then determined by W (P ) = n · 14 ms. In contrast,
the cost-based vectorized subplan that is shown in Figure 4.15(b) uses k = 3 + 1 execution
buckets and hence, it usually increases the throughput. For the exact cost analysis, we need
to distinguish two cases. First, if the costs of the Copy operator W (cp) are lower than the
maximum operator costs W (o 3 ), we compute the total costs by W (P ) = (n + 2) · 5 ms.
Second, if W (cp) > W (o 3 ), we need to compute the costs by W (P ) = (n + 2) · W (cp).
While we always benefit from vectorization in the first case, we have a break-even point
for the vectorization benefit in the second case. In detail, if n → ∞ and W (cp) > 10 ms
(the costs for executing this subplan in an instance-based manner), it is advantageous to
execute the subplan (o 1 , o 2 , o 3 ) as a single execution bucket because the costs of the Copy
operator are not amortized by the vectorization benefit.
We use those explicit cost comparisons (optimality conditions) between costs of additional
operators and the instance-based execution of such a subplan whenever we determine
parallel pipelines. Therefore, only the subplan—from the beginning of those parallel
pipelines to the temporal join at the end—is used for comparison.
In conclusion, the operator-aware cost-based vectorization is used within both the exact
and the heuristic computation approach. We use explicit cost comparisons in case of
subplans consisting of parallel pipelines because those require additional operators, which
we can now take into account as well. If statistics are available, this is a binary decision
for each subplan and hence, it can be efficiently computed. As a result, this approach
adds awareness of specific cases, where vectorization should not be applied for a subplan.
This ensures robustness of the cost-based vectorization of a single plan, in the sense that
it will never be slower than the instance-based execution.
112