[Paper Review] Two Piggybacking Codes with Flexible Sub-Packetization to Achieve Lower Repair Bandwidth

Hao Shi, Zhengyi Jiang+3 more|arXiv (Cornell University)|Sep 20, 2022

Advanced Data Storage Technologies4 citations

TL;DR

This paper proposes two novel piggybacking codes that achieve lower repair bandwidth for single-node failures in distributed storage systems with flexible sub-packetization levels. The first code supports sub-packetization $ m $ from 2 to $ r $, while the second code uses a joint design of piggyback and transformation functions for $ m $ being a multiple of $ r $, achieving the lowest repair bandwidth among existing codes for $ k/n = 0.75, 0.8, 0.9 $ and $ r \geq 4 $.

ABSTRACT

As a special class of array codes, $(n,k,m)$ piggybacking codes are MDS codes (i.e., any $k$ out of $n$ nodes can retrieve all data symbols) that can achieve low repair bandwidth for single-node failure with low sub-packetization $m$. In this paper, we propose two new piggybacking codes that have lower repair bandwidth than the existing piggybacking codes given the same parameters. Our first piggybacking codes can support flexible sub-packetization $m$ with $2\leq m\leq n-k$, where $n - k > 3$. We show that our first piggybacking codes have lower repair bandwidth for any single-node failure than the existing piggybacking codes when $n - k = 8,9$, $m = 6$ and $30\leq k \leq 100$. Moreover, we propose second piggybacking codes such that the sub-packetization is a multiple of the number of parity nodes (i.e., $(n-k)|m$), by jointly designing the piggyback function for data node repair and transformation function for parity node repair. We show that the proposed second piggybacking codes have lowest repair bandwidth for any single-node failure among all the existing piggybacking codes for the evaluated parameters $k/n = 0.75, 0.8, 0.9$ and $n-k\geq 4$.

Motivation & Objective

• Address the challenge of minimizing repair bandwidth in high-rate MDS array codes with low sub-packetization.
• Design piggybacking codes that support flexible sub-packetization levels $ m $, particularly for $ 2 \leq m \leq r $, where $ r = n-k $.
• Develop a joint design of piggyback and transformation functions to reduce repair bandwidth for both data and parity node repairs.
• Outperform existing piggybacking codes in repair bandwidth for the same parameters, especially under practical sub-packetization constraints.
• Enable efficient repair for both data and parity nodes with minimal repair ratio while maintaining MDS property.

Proposed method

• Propose first piggybacking codes $ \mathcal{C}_1(n,k,m,L) $ with flexible sub-packetization $ m $ satisfying $ 2 \leq m \leq r $, where $ r = n-k \geq 4 $.
• Design piggyback functions that jointly reduce repair bandwidth for both data and parity node repairs, unlike prior works that optimize them separately.
• Introduce a transformation function for parity node repair that works in tandem with the piggyback function to further reduce repair load.
• Use a structured design where $ L $ is a factor of $ k $, enabling analytical derivation of repair bandwidth ratios.
• Apply a joint optimization of piggyback and transformation functions to achieve minimal average repair bandwidth for parity nodes.
• Derive closed-form expressions for average repair bandwidth ratios $ \gamma^{\text{sys}} $ and $ \gamma^{\text{parity}} $, with bounds and asymptotic analysis as $ k \to \infty $.

Experimental results

Research questions

• RQ1 How can piggybacking codes be designed to support flexible sub-packetization levels $ m $ in the range $ 2 \leq m \leq r $ while minimizing repair bandwidth?
• RQ2 What is the impact of jointly designing piggyback functions for data nodes and transformation functions for parity nodes on overall repair bandwidth?
• RQ3 How does the repair bandwidth of the proposed codes compare to existing piggybacking codes for $ m < r $, particularly when $ r = 8,9 $ and $ m = 6 $?
• RQ4 What is the performance gain of the second code class when $ m $ is a multiple of $ r $, especially for code rates $ k/n = 0.75, 0.8, 0.9 $ and $ r \geq 4 $?
• RQ5 Can the joint design of piggyback and transformation functions achieve lower repair bandwidth than existing codes with similar parameters?

Key findings

• Our first piggybacking codes $ \mathcal{C}_1 $ achieve lower repair bandwidth than all existing piggybacking codes for $ r = 8,9 $, $ m = 6 $, and $ 30 \leq k \leq 100 $, with flexible sub-packetization $ 2 \leq m \leq r $.
• The second piggybacking codes $ \mathcal{C}_2 $ achieve the lowest repair bandwidth among all existing piggybacking codes for $ k/n = 0.75, 0.8, 0.9 $ and $ r \geq 4 $, when $ m $ is a multiple of $ r $.
• For $ \mathcal{C}_1 $, the average repair bandwidth ratio $ \gamma^{\text{sys}} $ approaches its minimum value $ \gamma_{\text{min}}^{\text{sys}} $ as $ k \to \infty $, indicating strong asymptotic optimality.
• The average repair bandwidth ratio for parity nodes in $ \mathcal{C}_2 $ is given by $ \gamma_{\text{parity}} = \frac{2}{r} + \frac{1}{k} - \frac{1}{kr} - \frac{L+1}{2sr} $, which is minimized through joint function design.
• Comparative evaluations in Fig. 5 and Fig. 6 confirm that $ \mathcal{C}_1 $ and $ \mathcal{C}_2 $ outperform REPB [15], $ \mathcal{C}_3 $ [20], $ \mathcal{C} $ [21], OOP [16], $ \mathcal{C}_4 $ [1], and $ \mathcal{C}_5 $ [19] across all evaluated parameters.
• The joint design of piggyback and transformation functions in $ \mathcal{C}_2 $ leads to a measurable reduction in repair bandwidth compared to codes that optimize data and parity repair functions independently.