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

5.5 Experimental Evaluation
the waiting time was adjusted according to the increased message rate, which led to
throughput improvements such that the optimized plan was able to process much higher
message rates 16 . Due to the lower bound of relative execution times, also the optimized
plan cannot cope with the increased message rate after a certain point. However, we
observe a slower degradation of the average latency due to more messages per batch,
decreasing relative execution time and thus, increased throughput.
Optimization Overhead
In addition to the end-to-end comparison, which already included all optimization overheads,
we now investigate the runtime overhead in more detail. Most importantly, the
partitioned enqueue operation depends on the selectivity of partitioning attributes. Therefore,
we analyzed the overhead of the (hash) partition tree compared to the commonly used
transient message queue (no partitioning) with and without serialized external behavior.
(a) Without Serialized External Behavior (SEB)
(b) With Serialized External Behavior (SEB)
Figure 5.22: Runtime Overhead for Enqueue Operations with Different Message Queues
We enqueued 20,000 messages (as required for the end-to-end comparison experiment)
with varying selectivities sel ∈ {0.0001, 0.001, 0.01, 0.1, 1.0} of the partitioning attribute
and measured the total execution time. This experiment was repeated 100 times. Figure
5.22 illustrates the results of this experiment using a log-scaled y-axis. Essentially, we
see that without serialized behavior (SEB), both the transient queue and the hash partition
tree show constant execution time with regard to the selectivity and the overhead of
the hash partition tree is negligible. In contrast, the execution time of the normal partition
tree linearly increases with decreasing selectivity due to the linear probing over all
existing partitions for each enqueued message. Furthermore, we observe a similar behavior
under serialized external behavior except the fact that also the execution time of the hash
partition tree increases linearly with decreasing selectivity. This is caused by the required
counting of outrun messages (counter-based serialization strategy), where we need to scan
over all partitions in order to determine this counter for each enqueued message. However,
for the whole comparison scenario, where 20,000 messages have been enqueued, the
overhead for this worst-case was 23.7 s (for 10,000 distinct partitions) which is negligible
compared to the achieved throughput. The enqueue operation is executed asynchronously
and hence, does not directly reduce the message throughput until a break-even point is
16 When further increasing the message rate, the average latency of both, unoptimized and optimized
execution, tend to different upper bounds that are determined by the case, where all |M| messages
arrive simultaneously. For a message rate of 100 msg /s, we observed average latency times of 40.2 s
(unoptimized) and 11.7 s (optimized).
163