[Paper Review] Parallel Database Recovery for Multicore Main-Memory Databases.

Yingjun Wu, Wentian Guo+2 more|arXiv (Cornell University)|Apr 12, 2016

Distributed systems and fault tolerance34 references3 citations

TL;DR

This paper proposes TARS, a parallel log-recovery mechanism for main-memory multicore databases that enables fast failure recovery without incurring logging overhead during online transaction processing. By combining static dependency analysis of stored procedures with dynamic, one-pass parameter scanning at recovery time, TARS achieves high parallelism in log replay, reducing recovery latency significantly compared to state-of-the-art approaches.

ABSTRACT

Main-memory database systems for multicore servers can achieve excellent performance when processing massive volume of OLTP workloads. But crash-resilience mechanism, or namely loggingand-replay, can either degrade the performance of transaction processing or slow down the process of failure recovery. In this paper, we show that, by exploiting application semantics, it is possible to achieve speedy failure recovery without introducing any costly logging overhead to the execution of online transactions. We propose TARS, a parallel log-recovery mechanism that is specifically designed for lightweight, coarse-grained command-logging approach. TARS leverages a combination of static and dynamic analyses to parallelize the log replay: at compile time, TARS decomposes stored procedures by carefully analyzing dependencies within and across programs; at recovery time, a re-execution schedule with a high degree of parallelism is attained through lightweight one-pass scans over transaction parameter values. As such, recovery latency is remarkably minimized. We evaluated TARS in a main-memory database prototype running on a 40-core server. Compared to the state-of-the-art mechanisms, TARS yields significantly higher recovery rate without compromising the efficiency of transaction processing.

Motivation & Objective

• To address the performance bottleneck of crash-recovery mechanisms in main-memory OLTP databases that rely on logging-and-replay.
• To eliminate logging overhead during online transaction processing while maintaining crash resilience.
• To minimize recovery latency in multicore environments by enabling high parallelism in log replay.
• To design a recovery mechanism that leverages application semantics and stored procedure structure for efficient parallel execution.

Proposed method

• TARS uses static analysis at compile time to decompose stored procedures by identifying data and control dependencies across procedures.
• It performs dependency analysis to determine safe parallel execution units for log replay during recovery.
• At recovery time, TARS conducts lightweight, one-pass scans over transaction parameter values to generate a high-paradigm re-execution schedule.
• The system exploits coarse-grained command logging to avoid costly logging during online transactions.
• It dynamically schedules replay operations based on parameter values to maximize parallelism during recovery.
• The approach integrates static decomposition with dynamic scheduling to balance correctness and performance in recovery.

Experimental results

Research questions

• RQ1 Can application semantics be leveraged to enable fast, low-overhead recovery in main-memory databases without logging during transaction execution?
• RQ2 How can stored procedure dependencies be analyzed statically to enable safe and efficient parallel log replay?
• RQ3 What dynamic scheduling strategy can maximize parallelism during recovery while ensuring correctness?
• RQ4 To what extent can recovery latency be reduced using a combination of static analysis and lightweight runtime scanning?
• RQ5 How does the proposed mechanism compare in performance to existing logging-and-replay mechanisms in multicore environments?

Key findings

• TARS achieves significantly higher recovery rates compared to state-of-the-art recovery mechanisms in a 40-core main-memory database prototype.
• The system eliminates logging overhead during online transaction processing, preserving transaction processing efficiency.
• Recovery latency is markedly reduced due to high parallelism enabled by static and dynamic analysis.
• The lightweight one-pass scan over transaction parameters enables efficient and scalable recovery scheduling.
• TARS successfully decouples recovery performance from transaction processing overhead, achieving both high throughput and low recovery latency.