Multi-Block Interleaved Codes for Local and Global Read Access

TL;DR

This paper introduces multi-block interleaved codes enabling efficient local and global data access, with constructions that balance speed and reliability while maintaining consistent information distribution across sub-blocks.

Contribution

It presents the first codes allowing multiple granularities of read access with specified correction capabilities and uniform information symbol distribution.

Findings

Codes match known distance properties of integrated-interleaving codes

They enable read access at multiple granularities with correction capabilities

Constructed for three sub-blocks, balancing speed and reliability

Abstract

We define multi-block interleaved codes as codes that allow reading information from either a small sub-block or from a larger full block. The former offers faster access, while the latter provides better reliability. We specify the correction capability of the sub-block code through its gap $t$ from optimal minimum distance, and look to have full-block minimum distance that grows with the parameter $t$. We construct two families of such codes when the number of sub-blocks is $3$. The codes match the distance properties of known integrated-interleaving codes, but with the added feature of mapping the same number of information symbols to each sub-block. As such, they are the first codes that provide read access in multiple size granularities and correction capabilities.

Equations

$$d⩽n-k+(m-1)t+1.$$

$$c(x)=i(x)g(x),$$

$$g(x)=(x-{\alpha }^{-s})(x-{\alpha }^{-(s+1)})\cdots (x-{\alpha }^{-(s+n-\ell -1)}),$$

$$RS([s:s+r-1{]}_n),$$

$$\overline{RS}([a:b{]}_n)\triangleq RS([0:n-1{]}_n\setminus [a:b{]}_n).$$

$$RS([k+t:n-1{]}_n)$$

$$\mathbf{v}=({\mathbf{v}}_1,{\mathbf{v}}_2,{\mathbf{v}}_3).$$

$${\mathbf{v}}_j=({\mathbf{v}}_{j,I},{\mathbf{v}}_{j,1},{\mathbf{v}}_{j,2}).$$

$$U_l=n^{-1}u({\alpha }^{-(a+l)})=n^{-1}c({\alpha }^{-(a+l)}),l\text{mathchar}12850[0:\ell -1].$$

$${\mathbf{v}}_j=({\mathbf{v}}_{j,I},{\mathbf{v}}_{j,1},{\mathbf{v}}_{j,2},{\mathbf{v}}_{j,3},{\mathbf{v}}_{j,4}).$$

Full text

I Introduction

The two central features sought in data-storage applications are extreme data reliability and fast data access. In data reliability we wish to avoid data loss in all conceivable circumstances, and in fast data access we want to read data with high throughput and low latency. Access considerations often dictate implementing an error-correcting code over a fixed (and not too large) data unit, which degrades the coding performance and the resulting reliability. An especially interesting instance of this happens in Flash storage, where a group of multi-level memory cells is divided to smaller data units called pages.

It is well known that coding over large block lengths gives the best reliability for a given coding rate. But adding access performance to the considerations, block lengths are tightly constrained by the granularity required for the read/write interface of the storage device. The standard approach of the storage industry is to fix the coding block length to be the basic access unit of the device (e.g. a page of a few KB), and come up with the best code for this block length. A conflict between coding efficiency and access performance thus emerges whenever the storage is required to deliver data at fine access granularities that imply short code blocks. Solving this conflict needs a multi-level read/write scheme with the following features:

Jointly writing $m$ data (sub-)units (e.g. pages), each with $k$ symbols, to a single write block. 2. 2.

Allowing random read access to a sub-unit, i.e., returning its $k$ symbols by physically reading a sub-block $1/m$ smaller than the write block. 3. 3.

In cases where a sub-unit read fails due to excess errors in the sub-block, reading the full write block succeeds in retrieving the data.

Feature 2 takes care of the fast-access requirement, and feature 3 improves reliability with only a minor adjustment of read performance in rare unfortunate instances. Note that focusing on random sub-unit read performance is in line with real applications that are much more sensitive to delayed reads than writes.

The formal model that fits the above three features now follows. Define a write block as $N=mn$ symbols, where $m$ is the number of sub-blocks and $n$ is the number of symbols in each sub-block. A write unit of $K=mk$ information symbols divides into $m$ sub-units of size $k$ each. In the write path, $K$ information symbols are encoded into $N$ code symbols and written to the memory. In the read path, we need to return a sub-unit of $k$ symbols by reading a sub-block of $n$ symbols. This operation is divided into decoding and reverse mapping, where the former corrects the errors/erasures in the $n$ sub-block symbols, and the latter retrieves the $k$ information symbols from the corrected sub-block. If sub-block decoding failed to correct the errors/erasures, we allow reading the entire write block and decode it as $[N,K]$ code. We define an $\langle N,K,m\rangle$ multi-block interleaved code as a code supporting these operations with the parameters $N,K,m$. Our objective in this paper is to construct $\langle N,K,m\rangle$ codes with good distance properties for both individual sub-block decoding and full write-block decoding.

The first place to look for multi-block interleaved codes is within the literature on integrated-interleaving (I-I) codes [6, 5] (see also [1]), which provide one minimum distance for sub-block codewords and a larger one for full codewords. While I-I codes give good (sometimes provably optimal) tradeoffs between sub-block and full-codeword distances, they cannot be readily used as multi-block interleaved codes. The issue with I-I codes is that it is not known how to reverse-map a sub-block codeword to $k$ information symbols. The encoder presented for I-I codes [1] maps different numbers of information symbols to different sub-blocks, and it is not clear how to re-organize the resulting $mk\times mn$ generator matrix to get $m$ full-rank $k\times n$ sub-matrices. Because of that, I-I codes fail to support the critical feature 2 in the read/write model. Another related coding framework is locally recoverable codes (LRC) [4, 7, 10]. LRC are focused on efficient local repair of individual code symbols, while here we are interested in local decoding of larger sub-blocks. The primary reason why known LRCs are not directly applicable to the proposed model is that they partition the code coordinates to disjoint sets that are each an MDS local code. Making each of the $m$ sub-blocks an $[n,k]$ MDS local code degenerates the problem, because all parity symbols are local in this case.

Our main contributions in the paper are two code constructions of multi-block interleaved codes providing flexible tradeoffs between sub-block and full-codeword correction capabilities. The flexibility is achieved by introducing an integer parameter $t$ specifying the gap of the sub-block code from minimum-distance optimality. As $t$ grows, the constructed codes enjoy better minimum distances for the full write-block codewords. This new view of the local vs. global correction tradeoff through the $t$ parameter allows their explicit joint-optimization, while in I-I codes this relation is much less transparent (in I-I codes there is no notion of sub-block dimension $k$, so $t$ is not even defined). One family of codes, presented in Section III, allows improvement in the full-block minimum distance (by growing $t$) reaching $d=1.5(n-k+1)$. An improved construction, presented in Section IV, can grow the full-block minimum distance further until $d=1.6(n-k+1)$. The proposed constructions are given for $m=3$ sub-blocks, but can be extended to additional $m$ with similar techniques. The key idea toward having sub-block reverse mapping is the specification of the codes through their generator matrices. This enables to carefully populate the generator matrix with constituent Reed-Solomon (RS) generators such that all distance properties are fulfilled simultaneously. Coincidentally, both constructions achieve the same distance properties as known I-I codes: the former meets 2-level I-I and the latter meets 3-level I-I. However, the constructed codes are not reformulations of these known I-I codes: the resulting codes are different, and there is no apparent transformation from the I-I codes to our codes that adds the desired sub-block access features. A previous use of constituent RS generators was in [3] to construct partial unit memory (PUM) convolutional codes [9, 8] (see also [2]).

II Definitions and Notations

Throughout the paper we denote the set $\{a,a+1,\ldots,b\}$ by $[a:b]$. Similarly, $[a:b]_{n}$ denotes the same set, but with element indices taken modulo $n$. For example, if $n=7$, then $[5:9]_{n}=[5:2]_{n}=\{5,6,0,1,2\}$. The operation $A\setminus B$ represents set difference between $A$ and $B$. We use the term distance to refer to the Hamming distance between vectors over the field GF$(q)$. For notational convenience, the statements in the paper on code minimum distances are written as some $d$ equal some number, even though in some cases we only prove (the important part) that $d$ is at least that number. We first define our principal object of study, which we call multi-block interleaved code.

Definition** 1****.**

.[multi-block interleaved code] An $[N,K]$ linear code $\mathcal{C}$ is a $\langle N,K,m\rangle$ multi-block interleaved code if its code coordinates are partitioned to $m$ disjoint sub-blocks of size $n=N/m$ each, and from each sub-block we can recover a disjoint size-$k=K/m$ sub-unit of information symbols.

For decoding a multi-block interleaved code we assume $m$ projections of the coordinates $[1:N]$ to disjoint subsets $[1:n]$, $[n+1:2n]$,… up to $[(m-1)n+1:mn]$. We assume that the projection of $\mathcal{C}$ onto any of these subsets gives the same $[n,\ell]$ code, which we denote $\mathcal{C^{\prime}}$. Next we define the distances of multi-block interleaved codes.

Definition** 2****.**

.[sub-block minimum distance] An $\langle N,K,m\rangle$ multi-block code $\mathcal{C}$ has sub-block minimum distance $\delta$ if the sub-block projected code $\mathcal{C^{\prime}}$ has minimum distance $\delta$.

The (full-block) minimum distance of an $\langle N,K,m\rangle$ multi-block code will be defined to be the usual minimum distance as $[N,K]$ block code.

II-A Bound on the minimum distance of multi-block interleaved codes

The following is a restatement of a known theorem from [5], but posed in different notation (using the $t$ parameter) that is helpful for the constructions in the sequel.

Theorem** 1****.**

. Let $\mathcal{C}$ be an $\langle N=mn,K=mk,m\rangle$ multi-block interleaved code with sub-block minimum distance $\delta=n-k-t+1$. If $t\leqslant(k-1)/(m-1)$ then the minimum distance of $\mathcal{C}$ is bounded by

[TABLE]

An optimal multi-block interleaved code is one meeting the bound (1) with equality. We note two interesting special cases of Theorem 1. For $m=1$ we get the usual Singleton bound; for $m=2$ we get $d\leqslant n-k+t+1$ when $t\leqslant k-1$. The upper bound reveals the tradeoff between the sub-block minimum distance and the minimum distance of the code. The parameter $t$ prescribes the gap of the sub-block distance from optimality, and in return increasing $t$ improves the upper bound on the distance of the full-block code.

II-B Short review of Reed-Solomon codes

The key building block for our constructions is Reed-Solomon (RS) codes, which are now defined.

Definition** 3****.**

.[Reed-Solomon code] Let $\alpha$ be an element of a finite field GF$(q)$ of order $n$. Then define a $[n,\ell]$ Reed-Solomon code as all polynomials $c(x)$ obtained as

[TABLE]

where $i(x)$ is an arbitrary information polynomial of degree $\leqslant\ell-1$, and

[TABLE]

and $s$ is some integer in $[0:n-1]$.

In simple words, an RS code is obtained by a generator polynomial $g(x)$ with $n-\ell$ roots whose reciprocals are consecutive powers of $\alpha$. As a useful compact notation, given $n$ and $q$, we define a RS code through its (cyclically) consecutive power set. In this representation, the code defined by the generator in (2) is

[TABLE]

where $r=n-\ell$ is called the redundancy of the code. It is well known that the minimum distance of $RS([s:s+r-1]_{n})$ is $r+1$. It will often be convenient to represent an RS code by the complement of its root power set, that is,

[TABLE]

The dimension of the code $\overline{RS}([a:a+\ell-1]_{n})$ is $\ell$, and its minimum distance is $n-\ell+1$.

III Construction of Multi-Block Interleaved Codes

Our focus in the paper is on codes with $m=3$, because this is the most useful case for Flash-based storage devices with $8=2^{3}$ representation levels. The constructions can be generalized to larger $m$ values. For the specific case of $m=3$ we add the following definitions.

Definition** 4****.**

.[$D_{i}$-minimum-distances] For $i{\,\mathchar 12850\relax\,}\{1,2,3\}$, an $\langle N,K,3\rangle$ multi-block interleaved code $\mathcal{C}$ has $D_{i}$-minimum-distance $d_{i}$ if the lowest weight of any codeword with exactly $i$ non-zero sub-blocks is $d_{i}$.

Note that according to Definition 4, the minimum distance of a $\langle N,K,3\rangle$ code is $\min_{i{\,\mathchar 12850\relax\,}\{1,2,3\}}d_{i}$. In addition to serving as upper bounds on the code minimum distance, the $D_{i}$-minimum-distances have important operational meanings: the $D_{1}$-minimum-distance gives the correction capability when $1$ sub-block suffers many errors/erasures, and the $D_{2}$-minimum-distance does the same when $2$ sub-blocks suffer many errors/erasures.

Construction** 1****.**

. Let $\mathcal{C}_{3}$ be defined by a generator matrix G=\left[\begin{array}[]{c}G_{1}\\ G_{2}\\ G_{3}\end{array}\right], where $G_{1}$, $G_{2}$ and $G_{3}$ are the $k\times 3n$ matrices given in Fig. 1. Now we define the component matrices of Fig. 1; blank rectangles represent all-zero sub-matrices.

• •

$G1$ is a generator matrix for the code $\overline{RS}([0:t-1]_{n})$.

• •

$G2$ is a generator matrix for the code $\overline{RS}([t:2t-1]_{n})$.

• •

$GI$ is a generator matrix for the code $\overline{RS}([2t:k-1]_{n})$.

• •

$GE$ is a generator matrix for the code $\overline{RS}([k:k+t-1]_{n})$.

First note that the dimensions of the codes specified for $G1,G2,GI,GE$ fit their corresponding sub-matrices in Fig. 1. It is straightforward to write a generator matrix for any code of the type $\overline{RS}([a:a+\ell-1]_{n})$, because the codewords of this code are evaluations of polynomials of the form $x^{a}U(x)$, where $U(x)$ is a polynomial of degree $\ell-1$ or less. As required, the dimension of $\mathcal{C}_{3}$ is $3k$, and its length is $3n$. We defer the discussion on encoding and decoding till after we prove the minimum distances in the following.

Proposition** 2****.**

. When $t<k/2$, $\mathcal{C}_{3}$ has sub-block minimum distance $\delta=n-k-t+1$.

Proof: Looking at any length-$n$ sub-block, we observe from the structure of $G$ that the codeword projected on the sub-block is a linear combination of codewords generated by $G1,G2,GI,GE$. Noting the root power sets of these codes (the complements of the sets listed in Construction 1), we get: $G1\rightarrow RS([t:n-1]_{n})$, $G2\rightarrow RS([2t:t-1]_{n})$, $GI\rightarrow RS([k:2t-1]_{n})$, and $GE\rightarrow RS([k+t:k-1]_{n})$. If a power index lies in the intersection of these sets, then every polynomial of a codeword in the sub-block code has this power index as root. Taking the intersection of these sets we obtain that the projected sub-block code is a

[TABLE]

code, and thus its minimum distance is $n-k-t+1$.  ∎

Given the sub-block minimum distance of Proposition 2, the next lemma shows that the $D_{1}$-minimum-distance of Construction 1 is optimal with respect to the bound111The bound is given on the minimum distance, but from the proof of Theorem 1 it readily applies to the $D_{1}$-minimum-distance as well. of Theorem 1.

Lemma** 3****.**

. A code $\mathcal{C}_{3}$ from Construction 1 has $D_{1}$-minimum-distance $d_{1}=n-k+2t+1$, for all $t<k/2$.

Proof: Denote the length $3k$ information vector as $\boldsymbol{v}$, and partition it as

[TABLE]

Each sub-vector $\boldsymbol{v}_{j}$ has length $k$, and we further partition it to

[TABLE]

The lengths of the $m=3$ constituent vectors are from left to right: $k-2t,t,t$. Consider a codeword of $\mathcal{C}_{3}$ with one non-zero sub-block. Assume (wlog due to symmetry) that the left sub-block is non-zero. It is clear from the structure of $G$ in Fig. 1 that all sub-vectors except $\boldsymbol{v}_{1,I}$ must be all-zero. In this case, the codeword weight is at least the minimum weight of a non-zero codeword from $\overline{RS}([2t:k-1]_{n})$ (spanned by $GI$), which is $n-k+2t+1$ as required by the lemma statement.  ∎

The behavior of the $D_{2}$-minimum-distance as a function of $t$ is quite different, as we now see.

Lemma** 4****.**

. A code $\mathcal{C}_{3}$ from Construction 1 has $D_{2}$-minimum-distance $d_{2}=2(n-k-t+1)$.

The proof of Lemma 4 is trivial from the fact that $\delta=n-k-t+1$. Unfortunately, the construction does not exclude codewords with two minimum-weight sub-block codewords. The problem lies in the fact that both $\boldsymbol{v}_{1,1}$ and $\boldsymbol{v}_{2,2}$ are multiplied by the same matrix $GE$ in the right column, which may cancel their contribution to the right sub-block. We now summarize the distance properties in the following theorem (proof immediate).

Theorem** 5****.**

. A code $\mathcal{C}_{3}$ from Construction 1 has sub-block minimum distance $\delta=n-k-t+1$, $D_{1}$-minimum-distance $d_{1}=n-k+2t+1$, and $D_{2}$-minimum-distance $d_{2}=2(n-k-t+1)$. For $t\leqslant(n-k+1)/4$, $\mathcal{C}_{3}$ has minimum distance $d=d_{1}$ (optimal), and for $(n-k+1)/4<t$ it has minimum distance $d=d_{2}$ (not optimal).

Similar to the case here, all the known I-I constructions in the literature with optimal $D_{1}$-minimum-distance (given $t$) suffer from the same problem of having codewords with two minimum-weight sub-block codewords. In [5] the authors address this exact problem, but give no explicit constructions. The implication of Theorem 5, in particular the terms $2t$ in $d_{1}$ and $-2t$ in $d_{2}$, is that there is a ratio of $1$ between the loss in $d_{2}$ to the gain in $d_{1}$ as we increase $t$. This high ratio compromises the code’s ability to address high error/erasure events in both one and two sub-blocks. In our next construction we solve this by proving a much lower ratio of $2/3$. But before that, we want to show the good property of Construction 1 having an extremely efficient reverse mapping from the sub-block codeword to the $k$ information symbols of the input sub-unit $\boldsymbol{v}_{j}$. We now write the encoding and reverse-mapping functions explicitly.

Encoding: The encoder input is an information vector $\boldsymbol{v}=(\boldsymbol{v}_{1},\boldsymbol{v}_{2},\boldsymbol{v}_{3})$, where each $\boldsymbol{v}_{j}$ is a vector of $k$ GF$(q)$ symbols holding the information sub-unit for sub-block $j$. The output of the encoder is simply the vector $\boldsymbol{v}\cdot G$, which is a codeword of $\mathcal{C}_{3}$. The matrices $G1,G2,GI,GE$ are chosen as the standard polynomial-evaluation matrices of the respective RS codes (mapping $\ell$ polynomial coefficients to $n$ code symbols). For a code $\overline{RS}([a:a+\ell-1]_{n}$, the corresponding generator matrix maps an information sub-vector $\boldsymbol{u}$ to a codeword by evaluating the polynomial $\tilde{U}(x)=x^{a}U(x)$ on $n$ elements of GF$(q)$, where $U(x)$ is the polynomial whose coefficients are the elements of $\boldsymbol{u}$, and it has degree at most $\ell-1$. Note that this is not the way the RS code was defined in Definition 3, but it is true by an equivalent definition of RS codes.

Reverse mapping: The reverse-mapping operation returns the information sub-unit $\boldsymbol{v}_{j}$ from the codeword of sub-block $j$. Denote by $u(x)$ the polynomial whose coefficients are the codeword symbols corresponding to $\boldsymbol{u}$. From the property given in Definition 3, $u(\alpha^{-i})$ is zero for all $i$ except those in $[a:a+\ell-1]_{n}$. Since these sets are not overlapping between $G1,G2,GI,GE$, we can take the combined sub-block codeword polynomial $c(x)$ (which is a sum of different polynomials like $u(x)$ above), and get that for each $i{\,\mathchar 12850\relax\,}[0:k-1]$, that $c(\alpha^{-i})=u(\alpha^{-i})$ for one of the sub-vectors $\boldsymbol{u}$ in $\boldsymbol{v}_{j}$. Now we can use the well known property of RS codes (inverse DFT) and obtain

[TABLE]

Since $c(x)$ is given, we can find the coefficients of all the polynomials $U(x)$ and thus all the vectors $\boldsymbol{u}$.

Neither the I-I codes from [6] nor the ones in [5] have a known way to map $k$ information symbols to each sub-block codeword, such that it is possible to retrieve these $k$ symbols back from the sub-block codeword. The encoder specified for I-I codes [1] (corresponding to the parameters of Construction 1) maps $k+t$ information symbols to each of two sub-blocks, and $k-2t$ to the third.

IV An Improved Construction with Larger Minimum Distance

To get codes $\langle N,K,m\rangle$ with larger minimum distances beyond what Construction 1 can achieve, we present the following improved construction. In the sequel we define $s=t/2$, assuming even $t$.

Construction** 2****.**

. Let $\mathcal{K}_{3}$ be defined by a generator matrix G=\left[\begin{array}[]{c}G_{1}\\ G_{2}\\ G_{3}\end{array}\right], where $G_{1}$, $G_{2}$ and $G_{3}$ are $k\times 3n$ matrices specified in Fig. 2 as follows. The figure specifies $4s$ rows of each $G_{i}$, which are populated by the generator matrices specified below, or combinations thereof. The figure omits the top $k-4s$ rows of each $G_{i}$ that host the $GI$ matrix given below, in the corresponding sub-block 222same as in Fig. 1..

• •

$G1$ is a generator matrix for the code $\overline{RS}([0:s-1]_{n})$.

• •

$G2$ is a generator matrix for the code $\overline{RS}([s:2s-1]_{n})$.

• •

$G3$ is a generator matrix for the code $\overline{RS}([2s:3s-1]_{n})$.

• •

$G4$ is a generator matrix for the code $\overline{RS}([3s:4s-1]_{n})$.

• •

$GI$ is a generator matrix for the code $\overline{RS}([4s:k-1]_{n})$.

• •

$GE$ is a generator matrix for the code $\overline{RS}([k:k+s-1]_{n})$.

• •

$GF$ is a generator matrix for the code $\overline{RS}([k+s:k+2s-1]_{n})$.

As in the previous construction the dimensions of the codes specified for $G1,G2,G3,G4,GI,GE,GF$ fit their corresponding sub-matrices in Fig. 2. The code dimension of $\mathcal{K}_{3}$ is $3k$, and its length is $3n$. We prove the minimum distances in the following.

Proposition** 6****.**

. When $t<k/2$, $\mathcal{K}_{3}$ has sub-block minimum distance $\delta=n-k-t+1$.

Proof: The proof is identical to Proposition 2: at each sub-block there is a codeword of an RS code with $n-k-2s=n-k-t$ roots with consecutive powers.  ∎

Lemma** 7****.**

. The code $\mathcal{K}_{3}$ has $D_{1}$-minimum-distance $d_{1}=n-k+3t/2+1$.

Proof: Recall the partition $\boldsymbol{v}=(\boldsymbol{v}_{1},\boldsymbol{v}_{2},\boldsymbol{v}_{3})$. Now we partition each $\boldsymbol{v}_{j}$ to

[TABLE]

The lengths of the constituent sub-vectors are from left to right: $k-4s,s,s,s,s$. Consider a codeword of $\mathcal{K}_{3}$ with one non-zero sub-block, for which we seek a lower bound on the Hamming weight. Assume (wlog due to symmetry) that the one non-zero sub-block is the left one. Then it is clear from Fig. 2 that the only sub-vectors that can be non-zero are $\boldsymbol{v}_{1,I}$, $\boldsymbol{v}_{1,3}$, and $\boldsymbol{v}_{1,4}$. Setting any other sub-vector to non-zero implies a non-zero codeword in at least one other sub-block. Further, if $\boldsymbol{v}_{1,3}$ or $\boldsymbol{v}_{1,4}$ are non-zero, then they must satisfy $\boldsymbol{v}_{1,3}+\boldsymbol{v}_{1,4}=0$. Otherwise the codeword in the right sub-block will be non-zero as well. It can be seen that this last condition implies that only $G4$ contributes to the non-zero codeword, and together with the contribution of $GI$ from $\boldsymbol{v}_{1,I}$, we get $n-k+3s$ consecutive roots and $d_{1}=n-k+3t/2+1$.  ∎

Lemma** 8****.**

. The code $\mathcal{K}_{3}$ has $D_{2}$-minimum-distance $d_{2}=2(n-k-t/2+1)$.

Proof: We use the definition of $\boldsymbol{v}$ from the proof of Lemma 7. Consider a codeword of $\mathcal{K}_{3}$ with two non-zero sub-blocks, for which we seek a lower bound on the total Hamming weight. Assume (wlog due to symmetry) that the two non-zero sub-blocks are the left and center ones. Then it is clear from Fig. 2 that the only sub-vectors that can be non-zero are $\boldsymbol{v}_{1,I}$, $\boldsymbol{v}_{1,1}$, $\boldsymbol{v}_{1,2}$, $\boldsymbol{v}_{1,3}$, $\boldsymbol{v}_{1,4}$ from $\boldsymbol{v}_{1}$, and $\boldsymbol{v}_{2,I}$, $\boldsymbol{v}_{2,2}$, $\boldsymbol{v}_{2,3}$, $\boldsymbol{v}_{2,4}$ from $\boldsymbol{v}_{2}$. Other non-zero sub-vectors would imply a non-zero codeword on the right sub-block. The above restriction on the sub-vectors that can be non-zero implies that there is no contribution of $F$ in the left sub-block codeword and no contribution of $G1$ in the center sub-block codeword. So each of the sub-block codewords has $n-k-s$ consecutive-power roots, and thus $d_{2}=2(n-k-s+1)$.  ∎

Combining Proposition 6 and Lemmas 7,8, we summarize the distance properties of Construction 2 in the following theorem (proof omitted).

Theorem** 9****.**

. A code $\mathcal{K}_{3}$ from Construction 2 has sub-block minimum distance $\delta=n-k-t+1$, $D_{1}$-minimum-distance $d_{1}=n-k+3t/2+1$, and $D_{2}$-minimum-distance $d_{2}=2(n-k-t/2+1)$. For $t\leqslant 2(n-k+1)/5$, $\mathcal{K}_{3}$ has minimum distance $d=d_{1}$, and for $2(n-k+1)/5<t\leqslant(n-k+1)/2$ it has minimum distance $d=d_{2}$.

Theorem 9 demonstrates the value of Construction 2: it allows to use large values of $t$ that give minimum distances higher than Construction 1 can reach. It can be calculated that when $t>2(n-k+1)/7$, Construction 2 has superior minimum distance compared to Construction 1. From $t=2(n-k+1)/7$ we can increase $t$ in Construction 2 up to $t=2(n-k+1)/5$, and get minimum distance as high as $d=1.6(n-k+1)$, while Construction 1 has a cutoff at $d=1.5(n-k+1)$.

Erasure decoding: We chose to prove the code correction properties by lower bounding the minimum distances. However, an alternative way is by giving an explicit erasure-decoding algorithm, which we do now. First, suppose that one sub-block has $n-k+3t/2$ erasures and the other two have each $n-k-t$ erasures or less. From symmetry assume that the left sub-block has the largest number. Then decoding the center sub-block with a $[n,k+t]$ code gives $\boldsymbol{v}_{2,1},\ldots,\boldsymbol{v}_{2,4}$, and similarly the right block gives $\boldsymbol{v}_{3,1},\ldots,\boldsymbol{v}_{3,4}$. In addition, we get $\boldsymbol{v}_{1,1}$ as the reverse map of $GF$ in the center sub-block, and then $\boldsymbol{v}_{1,2}$ by canceling $\boldsymbol{v}_{3,3}$ and $\boldsymbol{v}_{3,4}$ from the reverse map of $GE$ in the center sub-block. Finally, we can find $\boldsymbol{v}_{1,3}+\boldsymbol{v}_{1,4}$ by canceling $\boldsymbol{v}_{2,2}$ from the reverse map of $GE$ in the right sub-block. Now we can decode the left sub-block with a $[n,k-3t/2]$ code having contributions from only $GI$ and $G4$. Second, suppose that two sub-blocks have each $n-k-t/2$ erasures and the third one has $n-k-t$ erasures or less. From symmetry assume that the right sub-block has the smaller number. Then decoding the right sub-block with a $[n,k+t]$ code gives $\boldsymbol{v}_{2,1}$, and $\boldsymbol{v}_{3,1}$ (among all $\boldsymbol{v}_{3,l}$). Now after canceling these two we can decode each of the left and center sub-blocks with a $[n,k+t/2]$ code and recover their erased symbols.

V Conclusion

The constructions in this paper are the first known ones to offer read access in both sub-blocks and full blocks. The first construction has optimal $D_{1}$-minimum-distance given $t$, but a limiting reduction in the $D_{2}$-minimum-distance as $t$ grows. The second construction has slower growth of the $D_{1}$-minimum-distance, but in return also slower reduction in $D_{2}$, and altogether a higher maximal minimum distance. Future work is needed to extend these constructions, and find others with similar tradeoffs, to additional $m$ values. While the codes suffice to use finite fields with sizes as small as the sub-block size, further reducing the field size is an important future direction, e.g. through using BCH codes as the constituents.

VI Acknowledgement

This work was supported in part by the German-Israel Foundation and by the Israel Science Foundation.