[Paper Review] Fast Updates on Read-Optimized Databases Using Multi-Core CPUs

Jens Krueger, Changkyu Kim+7 more|arXiv (Cornell University)|Sep 30, 2011

Distributed systems and fault tolerance21 references4 citations

TL;DR

This paper proposes a multi-core aware, linear-time merge algorithm that reduces merge overhead in read-optimized in-memory columnar databases by a factor of 30, enabling them to support high-volume transactional workloads without downtime. By exploiting CPU cache hierarchies and thread-level parallelism, the method efficiently merges delta updates into compressed main storage while preserving analytical query performance.

ABSTRACT

Read-optimized columnar databases use differential updates to handle writes by maintaining a separate write-optimized delta partition which is periodically merged with the read-optimized and compressed main partition. This merge process introduces significant overheads and unacceptable downtimes in update intensive systems, aspiring to combine transactional and analytical workloads into one system. In the first part of the paper, we report data analyses of 12 SAP Business Suite customer systems. In the second half, we present an optimized merge process reducing the merge overhead of current systems by a factor of 30. Our linear-time merge algorithm exploits the underlying high compute and bandwidth resources of modern multi-core CPUs with architecture-aware optimizations and efficient parallelization. This enables compressed in-memory column stores to handle the transactional update rate required by enterprise applications, while keeping properties of read-optimized databases for analytic-style queries.

Motivation & Objective

• To address the performance bottleneck of merge operations in read-optimized, compressed in-memory column stores used in enterprise systems.
• To enable real-time transactional workloads on databases traditionally optimized only for analytical queries.
• To reduce merge overhead and eliminate downtime in update-intensive environments.
• To design a system that supports both high update rates and high read performance simultaneously.
• To validate the approach using real enterprise workload data from 12 SAP Business Suite customer systems.

Proposed method

• The authors analyze real-world enterprise workloads from 12 SAP Business Suite systems to identify key performance bottlenecks in the merge process.
• They design a linear-time merge algorithm that processes compressed columnar data in-place using architecture-aware optimizations.
• The algorithm leverages multi-core CPU parallelism, cache-friendly data layouts, and efficient thread scheduling to maximize compute and memory bandwidth utilization.
• It performs online, incremental merging of delta partitions into the main compressed column store without requiring system downtime.
• The implementation uses dictionary encoding and avoids full decompression by operating directly on compressed data structures.
• A detailed analytical model is developed to predict compute and memory bandwidth requirements across current and future CPU architectures.

Experimental results

Research questions

• RQ1 What are the dominant performance bottlenecks in the merge process of read-optimized in-memory column stores under real enterprise workloads?
• RQ2 How can merge performance be improved to support high-velocity transactional workloads without sacrificing read performance?
• RQ3 To what extent can modern multi-core CPUs be leveraged to accelerate the merge process through architecture-aware optimizations?
• RQ4 Can a linear-time merge algorithm be designed that operates efficiently on compressed data without full decompression?
• RQ5 How does the performance of the optimized merge algorithm scale with increasing data volume and system load?

Key findings

• The merge process in current systems requires approximately 20 hours of downtime per month in enterprise environments, severely limiting real-time transactional workloads.
• The proposed algorithm reduces merge time by a factor of 30 compared to unoptimized serial implementations.
• The optimized implementation achieves a 30x speedup through multi-core parallelization and cache-aware memory access patterns.
• The algorithm maintains high read performance by preserving the compressed columnar format in the main store.
• The analytical model accurately predicts performance across current and upcoming CPU architectures, validating the scalability of the approach.
• The system supports up to ~1,000 updates per second in production environments, which is sufficient for enterprise transactional workloads when merged efficiently.