[Paper Review] Algorithms for Replica Placement in High-Availability Storage

K. Alex Mills, R. Chandrasekaran+1 more|arXiv (Cornell University)|Mar 9, 2015

Distributed systems and fault tolerance14 references8 citations

TL;DR

This paper proposes a novel causal failure model for high-availability storage systems, representing component dependencies as a directed tree to optimize replica placement. It presents an $O(n + ho^2)$ dynamic programming algorithm that ensures replicas are placed to avoid single-point-of-failure scenarios, with a key contribution being a linear-time algorithm for balanced replica placement on trees.

ABSTRACT

A new model of causal failure is presented and used to solve a novel replica placement problem in data centers. The model describes dependencies among system components as a directed graph. A replica placement is defined as a subset of vertices in such a graph. A criterion for optimizing replica placements is formalized and explained. In this work, the optimization goal is to avoid choosing placements in which a single failure event is likely to wipe out multiple replicas. Using this criterion, a fast algorithm is given for the scenario in which the dependency model is a tree. The main contribution of the paper is an $O(n + ρ\log ρ)$ dynamic programming algorithm for placing $ρ$ replicas on a tree with $n$ vertices. This algorithm exhibits the interesting property that only two subproblems need to be recursively considered at each stage. An $O(n^2 ρ)$ greedy algorithm is also briefly reported.

Motivation & Objective

• To address the problem of correlated component failures in data centers that can lead to widespread unavailability of data replicas.
• To model causal dependencies among system components explicitly, rather than relying on statistical correlation measures.
• To develop an algorithm that optimizes replica placement to minimize the risk of simultaneous replica loss due to a single failure event.
• To provide a fast, scalable solution for replica placement in tree-structured dependency graphs, which model real-world data center topologies.
• To demonstrate that optimal replica placement in trees must be balanced, enabling efficient algorithm design.

Proposed method

• Models system component dependencies as a directed tree, where nodes represent components and edges represent causal failure propagation.
• Introduces a failure model where a failure at a node propagates to all descendants, assuming a threshold of one for failure propagation.
• Applies dynamic programming with a divide-and-conquer strategy, recursively solving subproblems on subtrees and combining results.
• Uses a transformation phase to contract degenerate chains of nodes with single children, reducing the problem size and improving efficiency.
• Employs pseudonodes to represent chains of nodes, enabling efficient computation of failure aggregates using vectors $\vec{a}$, $\vec{b}$, and $\vec{f}$.
• Implements a conquer phase that combines results from children using vector arithmetic to compute optimal replica placement configurations.

Experimental results

Research questions

• RQ1 How can causal dependencies among system components be modeled to improve replica placement in high-availability storage systems?
• RQ2 What is the computational complexity of finding an optimal replica placement in a tree-structured dependency graph?
• RQ3 Can a dynamic programming approach be designed to ensure that replicas are placed such that a single failure does not compromise multiple replicas?
• RQ4 What structural properties (e.g., balance) must an optimal replica placement satisfy in a tree?
• RQ5 Can the running time of the replica placement algorithm be improved beyond $O(n^2\rho)$ through structural insights and data structure optimization?

Key findings

• The proposed $O(n + \rho^2)$ dynamic programming algorithm efficiently computes optimal replica placements in tree-structured dependency graphs.
• The algorithm exploits the structural property that any optimal placement in a tree must be balanced, enabling recursive decomposition.
• A faster $O(n + \rho\log\rho)$ algorithm is achieved by contracting degenerate chains and using pseudonodes to reduce computation time.
• The transform phase runs in $O(n + \rho\log\rho)$ time by processing degenerate chains and aggregating failure counts via vectors.
• The conquer phase runs in $O(\rho\log\rho)$ time due to the logarithmic depth of pseudonode levels, contributing to the overall improved complexity.
• The algorithm outperforms the baseline $O(n^2\rho)$ greedy approach by leveraging tree structure and failure propagation modeling.