Asymmetric LOCO Codes: Constrained Codes for Flash Memories

TL;DR

This paper introduces asymmetric LOCO codes tailored for flash memories, which improve data rate efficiency by forbidding only detrimental patterns, and provides low-complexity encoding and decoding algorithms.

Contribution

The paper proposes asymmetric LOCO codes that are capacity-achieving and more efficient for flash memories by selectively forbidding error-prone patterns.

Findings

A-LOCO codes outperform symmetric LOCO codes in rate for flash applications.

A-LOCO codes enable low-complexity encoding and decoding algorithms.

A-LOCO codes are capacity-achieving and tailored for flash memory constraints.

Abstract

In data storage and data transmission, certain patterns are more likely to be subject to error when written (transmitted) onto the media. In magnetic recording systems with binary data and bipolar non-return-to-zero signaling, patterns that have insufficient separation between consecutive transitions exacerbate inter-symbol interference. Constrained codes are used to eliminate such error-prone patterns. A recent example is a new family of capacity-achieving constrained codes, named lexicographically-ordered constrained codes (LOCO codes). LOCO codes are symmetric, that is, the set of forbidden patterns is closed under taking pattern complements. LOCO codes are suboptimal in terms of rate when used in Flash devices where block erasure is employed since the complement of an error-prone pattern is not detrimental in these devices. This paper introduces asymmetric LOCO codes (A-LOCO codes), which are lexicographically-ordered constrained codes that forbid only those patterns that are detrimental for Flash performance. A-LOCO codes are also capacity-achieving, and at finite-lengths, they offer higher rates than the available state-of-the-art constrained codes designed for the same goal. The mapping-demapping between the index and the codeword in A-LOCO codes allows low-complexity encoding and decoding algorithms that are simpler than their LOCO counterparts.

Tables

Table 1. TABLE I: The codewords of five A-LOCO codes, 𝒜 ​ 𝒞 m , 1 𝒜 subscript 𝒞 𝑚 1 \mathcal{AC}_{m,1} , m ∈ { 1 , 2 , … , 5 } 𝑚 1 2 … 5 m\in\{1,2,\dots,5\} and x = 1 𝑥 1 x=1 . The three different groups of codewords are shown for the code 𝒜 ​ 𝒞 5 , 1 𝒜 subscript 𝒞 5 1 \mathcal{AC}_{5,1} .

Codeword index $g\left(𝕔\right)$	Codewords of the code $𝒜{𝒞}_{m,1}$
	$m=1$	$m=2$	$m=3$	$m=4$	$m=5$
$0$	$0$	$00$	$000$	$0000$	$00000$	Group 1
$1$	$1$	$01$	$001$	$0001$	$00001$
$2$		$10$	$010$	$0010$	$00010$
$3$		$11$	$011$	$0011$	$00011$
$4$			$100$	$0100$	$00100$
$5$			$110$	$0110$	$00110$
$6$			$111$	$0111$	$00111$
$7$				$1000$	$01000$
$8$				$1001$	$01001$
$9$				$1100$	$01100$
$10$				$1110$	$01110$
$11$				$1111$	$01111$
$12$					$10000$	Group 3
$13$					$10001$
$14$					$10010$
$15$					$10011$
$16$					$11000$	Group 2
$17$					$11001$
$18$					$11100$
$19$					$11110$
$20$					$11111$
Code cardinality	$N(1,1)\triangleq 2$	$N(2,1)=4$	$N(3,1)=7$	$N(4,1)=12$	$N(5,1)=21$

Table 2. TABLE II: The codewords of the CA-LOCO code 𝒜 ​ 𝒞 5 , 1 c 𝒜 subscript superscript 𝒞 c 5 1 \mathcal{AC}^{\textup{c}}_{5,1} and the corresponding messages.

Message $𝕓$	Index $g\left(𝕔\right)$	Codeword $𝕔$
$0000$	$1$	$00001$
$0001$	$2$	$00010$
$0010$	$3$	$00011$
$0011$	$4$	$00100$
$0100$	$5$	$00110$
$0101$	$6$	$00111$
$0110$	$7$	$01000$
$0111$	$8$	$01001$
$1000$	$9$	$01100$
$1001$	$10$	$01110$
$1010$	$11$	$01111$
$1011$	$12$	$10000$
$1100$	$13$	$10001$
$1101$	$14$	$10010$
$1110$	$15$	$10011$
$1111$	$16$	$11000$

Table 3. TABLE III: Rates of CA-LOCO codes 𝒜 ​ 𝒞 m , x c 𝒜 subscript superscript 𝒞 c 𝑚 𝑥 \mathcal{AC}^{\textup{c}}_{m,x} for different values of m 𝑚 m and x ∈ { 1 , 2 } 𝑥 1 2 x\in\{1,2\} .

Code parameters	Rate	Adder size
$m=17$ and $x=1$	$0.7778$	$14$ bits
$m=44$ and $x=1$	$0.8000$	$36$ bits
$m=76$ and $x=1$	$0.8052$	$62$ bits
$m=113$ and $x=1$	$0.8070$	$92$ bits
$m=357$ and $x=1$	$0.8101$
$m=18$ and $x=2$	$0.6500$	$13$ bits
$m=28$ and $x=2$	$0.6667$	$20$ bits
$m=64$ and $x=2$	$0.6818$	$45$ bits
$m=123$ and $x=2$	$0.6880$	$86$ bits
$m=244$ and $x=2$	$0.6911$

Equations

$${\mathcal{A}}_x\triangleq \{101,1001,\dots ,10^{x}1\}.$$

$$N(m,x)\triangleq 1,m\le 0,\text{ and }N(1,x)\triangleq 2.$$

$$N(m,x)$$

$$+N(m-x-2,x),m\ge 2.$$

$$N_1(m,x)=N(m-1,x).$$

$$N_2(m,x)=N(m-1,x)-N_1(m-1,x).$$

$$N_2(m,x)=N(m-1,x)-N(m-2,x).$$

$$N_3(m,x)=N_1(m-x-1,x).$$

$$N_3(m,x)=N(m-x-2,x).$$

$$N(m,x)=\sum _{\ell =1}^3{N}_{\ell }(m,x)$$

$$=2N(m-1,x)-N(m-2,x)+N(m-x-2,x),$$

$$N(-1,1)\triangleq 1,N(0,1)\triangleq 1,N(1,1)\triangleq 2,$$

$$N(2,1)=2N(1,1)-N(0,1)+N(-1,1)=4,$$

$$N(3,1)=2N(2,1)-N(1,1)+N(0,1)=7,\text{allowdisplaybreaks}$$

$$N(4,1)=2N(3,1)-N(2,1)+N(1,1)=12,$$

$$N(5,1)=2N(4,1)-N(3,1)+N(2,1)=21,$$

$$N_1(5,1)$$

$$N_2(5,1)$$

$$N_3(5,1)$$

$$N(5,1)$$

$$a_i\triangleq \{\begin{array}{cc}1,& c_i=1,\\ 0,& c_i=0,\end{array}$$

$$g(c)=\sum _{i=0}^{m-1}{a}_{i}N(i-a_{i+1}x,x).$$

$$g(c_0)$$

$$g(c_1)$$

$$g(c_2)$$

$$g(c_3)$$

$$=N(1-0,x)+N(0-1,x)=2+1=3.$$

$$g(\overline{m},x,\overline{c})=\sum _{i=0}^{\overline{m}-1}{\overline{a}}_{i}N(i-{\overline{a}}_{i+1}x,x),$$

$$g(m+1,x,c^{\prime })=\sum _{i=0}^m{a}_i^{\prime }N(i-a_{i+1}^{\prime }x,x),$$

$$g(m+1,x,c^{\prime })-g(m,x,c)=0.$$

$$g(m+1,x,c^{\prime })=g(m,x,c)=\sum _{i=0}^{m-1}{a}_{i}N(i-a_{i+1}x,x).$$

$$g(m+1,x,c^{\prime })=\sum _{i=0}^m{a}_i^{\prime }N(i-a_{i+1}^{\prime }x,x).$$

$$g(m+1,x,c^{\prime })-g(m,x,c)$$

$$=N_1(m+1,x)+N_3(m+1,x)-N_1(m,x)$$

$$=N(m,x)+N(m-x-1,x)-N(m-1,x),$$

$$g(m+1,x,c^{\prime })$$

$$=N(m,x)+N(m-x-1,x)-N(m-1,x)$$

$$+\sum _{i=0}^{m-1}{a}_{i}N(i-a_{i+1}x,x).$$

$$g(m+1,x,c^{\prime })$$

Full text

I Introduction

Constrained codes are widely applied in various data storage systems to improve their performance. These codes were first employed in magnetic recording (MR) systems. Run-length-limited (RLL) codes [1] were used to extend the lifetime of peak detection in early IBM disk drives [2]. Binary RLL codes are typically used with bipolar non-return-to-zero inverted (NRZI) signaling, where a [math] is represented by no transition, while a $1$ is represented by a transition. RLL codes are used to control the separation between consecutive transitions. Small separation exacerbates inter-symbol interference (ISI) while large separation results in losing synchronization at the receiver. Constrained codes also find application in modern MR systems [3] to improve sequence detection [4].

We define the set $\mathcal{S}_{x}\triangleq\{010,101,\allowbreak 0110,1001,\dots,0\mathbb{1}^{x}0,\allowbreak 1\mathbb{0}^{x}1\}$, where we denote a run of $r$ consecutive [math]’s (resp., $1$’s) as $\mathbb{0}^{r}$ (resp. $\mathbb{1}^{r}$) for brevity. Note that the set $\mathcal{S}_{x}$ is closed under taking pattern complements and has size $2x$. We define a binary symmetric $\mathcal{S}_{x}$-constrained code to be a code that forbids any pattern in the set $\mathcal{S}_{x}$ from appearing in any of its codewords. $\mathcal{S}_{x}$-constrained codes are used with bipolar non-return-to-zero (NRZ) signaling to control the separation between consecutive transitions. In NRZ signaling, a [math] is represented by level $-A$ or the erasure level $E$ in Flash, while a $1$ is represented by level $+A$. Many applications, e.g., optical recording, require constrained codes to be balanced [5]; a frequency domain approach is in [6].

In Flash systems employing block erasure, the error-prone patterns, i.e., the patterns that contribute the most to inter-cell interference (ICI), for NRZ signaling are somewhat different. It was demonstrated in [7] that for Flash memories, the pattern $(q-1)0(q-1)$ should be eliminated, where $q$ is the number of levels in the cell and also the Galois field (GF) size111We directly map the GF elements to consecutive integers representing threshold voltage levels in order to follow the references.. Balanced and constant-weight codes were designed to eliminate this pattern in [7] and [8], respectively. The authors of [9] showed that the set of patterns to eliminate in multi-level cell (MLC) Flash memories is $\{303,313,323\}$, which can be generalized to $\{(q-1)0(q-1),(q-1)1(q-1),\dots,(q-1)(q-2)(q-1)\}$ for $q$-level cell Flash memories as shown in [10]. The problem originates from the phenomenon that increasing the charge at the outer two cells causes the middle cell to have its charge also increased unintentionally because of the parasitic capacitances. Prior work only considered adjacent cells [7, 8, 9, 10]. However, parasitic capacitances may also result in charge propagation between non-adjacent cells, which means patterns like $(q-1)\mathbb{0}^{x}(q-1)$, $x>1$, can also be problematic (investigated here in the binary case).

We define the set $\mathcal{A}_{x}\triangleq\{101,1001,\dots,1\mathbb{0}^{x}1\}$ and note that $\mathcal{A}_{x}$ has size $x$. We define a binary asymmetric $\mathcal{A}_{x}$-constrained code to be a code that forbids any pattern in the set $\mathcal{A}_{x}$ from appearing in any of its codewords. The code is said to be asymmetric because $\mathcal{A}_{x}$ is not closed under taking pattern complements. Here, NRZ signaling is adopted. For magnetic recording channels having the extended partial-response 4 (EPR4) target, the authors of [11] showed that asymmetric $\mathcal{A}_{1}$-constrained codes (forbidding $\{101\}$) achieve the same performance as symmetric $\mathcal{S}_{1}$-constrained codes (forbidding $\{010,101\}$) with $20\%$ rate increase.

The idea of constructing constrained codes based on lexicographic indexing (also called enumerative coding) was first presented in [1] for RLL codes. The framework introduced in [12] inspired more recent developments such as [13] and [14]. These developments have the drawback that the code length needs to be large for rates approaching capacity, resulting in limited rate-complexity trade-off advantages. The asymmetric constrained codes in [10], designed for Flash systems, are enumerative constant-composition codes with high rates and average encoding-decoding complexity. However, these codes are limited in the sense that only the effect of the two adjacent cells is taken into account, i.e., for a single-level cell (SLC) Flash memory device (inaccurate nomenclature; it is a single-bit cell), they are only $\mathcal{A}_{1}$-constrained codes.

Recently, we introduced a new family of symmetric constrained codes, which we named lexicographically-ordered $\mathcal{S}_{x}$-constrained codes (LOCO codes) [15]. LOCO codes are capacity-achieving, and they offer up to $10\%$ rate gain, with low complexity encoding-decoding, compared with practical RLL codes designed for the same goal. A combination of LOCO codes and spatially-coupled graph-based codes [16] resulted in significant density gains with limited rate reduction. Balancing LOCO codes was also proved to result in the minimum penalty in code rate. See [15] for details.

In this paper, we propose and analyze a new family of asymmetric constrained codes, which we name asymmetric lexicographically-ordered $\mathcal{A}_{x}$-constrained codes (A-LOCO codes), that improve performance by eliminating the error-prone patterns in Flash memories. Our A-LOCO codes can be constructed, encoded, and decoded for any set $\mathcal{A}_{x}$, making them capable of taking into account the effect of non-adjacent cells when needed. A-LOCO codes are capacity-achieving codes, and we establish a mapping-demapping formula between the lexicographic index and the codeword in order to enable simple, practical encoding and decoding algorithms. Compared with other practical asymmetric and symmetric constrained codes designed for the same purpose, A-LOCO codes offer higher rates at low complexity. In this paper, we only consider binary asymmetric constrained codes for SLC Flash memories. However, we expect to be able to develop non-binary asymmetric constrained codes for Flash memories with $q=2^{y}$, $y\geq 2$, levels. High rate non-binary asymmetric constrained codes will encourage the development of quad-level cell (QLC) Flash memories.

The rest of the paper is organized as follows. In Section II, we enumerate the codewords in an A-LOCO code. In Section III, we establish the encoding-decoding rule of A-LOCO codes. In Section IV, we discuss bridging, self-clocking, and rates of A-LOCO codes. In Section V, we introduce the algorithms, complexity analysis, and comparisons with other constrained codes. We conclude the paper in Section VI.

II Cardinality of A-LOCO Codes

In this section, we formally define A-LOCO codes, and then derive a recursive relation that gives the cardinality, i.e., the number of codewords, of these codes.

Definition 1**.**

An A-LOCO code $\mathcal{AC}_{m,x}$, with parameters $m\geq 1$ and $x\geq 1$, is defined via the following properties:

Codewords in $\mathcal{AC}_{m,x}$ are binary and of length $m$. 2. 2.

Codewords in $\mathcal{AC}_{m,x}$ are ordered lexicographically. 3. 3.

Any pattern in the asymmetric set $\mathcal{A}_{x}$ does not appear in any codeword $\mathbb{c}$ in $\mathcal{AC}_{m,x}$, where:

[TABLE] 4. 4.

The code $\mathcal{AC}_{m,x}$ contains all the codewords satisfying the previous three properties.

Lexicographic ordering of codewords means that they are ordered in an ascending manner following the rule $0<1$ for any bit, and the bit significance reduces from left to right.

Our main application in this work is Flash memories. In SLC devices, a $1$ results in a programmed cell, while a [math] results in an unprogrammed cell, i.e., NRZ signaling. Thus, patterns of the form $1\mathbb{0}^{x}1$ are error-prone since they give rise to ICI on the inner cell(s) (the unprogrammed cell(s)).

Table I shows the codewords of the A-LOCO codes $\mathcal{AC}_{m,1}$, $m\in\{1,2,\dots,5\}$. The table demonstrates that an A-LOCO code with $m\notin\{1,2\}$ is not closed under taking codeword complements. Moreover, the table also exhibits the increase in the A-LOCO code cardinality compared with the corresponding LOCO code. For example, the cardinality of the A-LOCO code with $m=5$ and $x=1$ is $21$, while it is only $16$ for the corresponding LOCO code [15].

Next, we introduce a group structure for A-LOCO codes that helps us not only derive the cardinality recursively, but also devise the encoding-decoding rule of A-LOCO codes, which is based on lexicographic indexing.

For $m\geq 2$, the codewords in an A-LOCO code $\mathcal{AC}_{m,1}$ are classified into the following three groups:

Group 1: Codewords in this group start with [math] from the left, i.e., at the left-most bit (LMB).

Group 2: Codewords in this group start with $11$ from the left, i.e., at the LMBs.

Group 3: Codewords in this group start with $1\mathbb{0}^{x+1}$ from the left, i.e., at the LMBs222In Group 3 and with $2\leq m\leq x+1$, there exists only a single codeword, which has fewer bits than these LMBs, in the group. The following analysis also applies for such codewords..

This group structure is shown explicitly in Table I for $\mathcal{AC}_{5,1}$. Additionally, the horizontal lines in each column of codewords separate different groups. Note that bridging bits/symbols are required in order to guarantee that the forbidden patterns do not appear in streams of consecutive A-LOCO codewords. Bridging will be discussed later.

Theorem 1 derives the cardinality of A-LOCO codes.

Theorem 1**.**

Denote the cardinality of an A-LOCO code $\mathcal{AC}_{m,x}$ by $N(m,x)$ with:

[TABLE]

The following recursive equation gives $N(m,x)$:

[TABLE]

Proof:

We use the group structure illustrated above in order to prove Theorem 1.

Group 1: Each codeword from Group 1 in $\mathcal{AC}_{m,x}$ corresponds to a codeword in $\mathcal{AC}_{m-1,x}$ that shares the $m-1$ right-most bits (RMBs) with the codeword in $\mathcal{AC}_{m,x}$. This applies to all the codewords in $\mathcal{AC}_{m-1,x}$. Recall that patterns of the form $0\mathbb{1}^{y}0$, $1\leq y\leq x$, are not forbidden in A-LOCO codes. Thus, the cardinality of Group 1 in $\mathcal{AC}_{m,x}$ is:

[TABLE]

Group 2: Each codeword from Group 2 in $\mathcal{AC}_{m,x}$ corresponds to a codeword in $\mathcal{AC}_{m-1,x}$ that starts with $1$ from the left and shares the $m-2$ RMBs with the codeword in $\mathcal{AC}_{m,x}$. This applies to all the codewords starting with $1$ from the left in $\mathcal{AC}_{m-1,x}$. Thus, the cardinality of Group 2 in $\mathcal{AC}_{m,x}$ is:

[TABLE]

Using (4) to compute $N_{1}(m-1,x)$ gives:

[TABLE]

Group 3: Each codeword from Group 3 in $\mathcal{AC}_{m,x}$ corresponds to a codeword in $\mathcal{AC}_{m-x-1,x}$ that starts with [math] from the left and shares the $m-x-2$ RMBs with the codeword in $\mathcal{AC}_{m,x}$. This applies to all the codewords starting with [math] from the left in $\mathcal{AC}_{m-x-1,x}$. Thus, the cardinality of Group 3 in $\mathcal{AC}_{m,x}$ is:

[TABLE]

Using (4) to compute $N_{1}(m-x-1,x)$ gives:

[TABLE]

Adding (4), (6), and (8) gives:

[TABLE]

which completes the proof. ∎

Example 1**.**

The cardinalities of $\mathcal{AC}_{m,1}$, $m\in\{2,3,4,5\}$, are computed using Theorem 1 as follows:

[TABLE]

which are also given in the last row of Table I. The cardinalities of the three groups can be used to compute $N(5,1)$, for example, as follows:

[TABLE]

These numbers are also consistent with the groups shown in the last column of Table I.

Theorem 1 is important because, for a given length $m$, the number of codewords determines the rate of the code. This is true for all coding techniques based on lexicographic ordering (true for enumerative coding techniques in general). Theorem 1 is also essential for devising the encoding-decoding rule of A-LOCO codes as we shall see next section, and consequently, the encoding-decoding algorithms.

III Encoding-Decoding Rule of A-LOCO Codes

In this section, we devise the encoding-decoding rule of A-LOCO codes, which is based on lexicographic indexing. This rule is what enables simple, low complexity encoding and decoding algorithms for A-LOCO codes.

We first introduce some notation. Define an A-LOCO codeword of length $m$ as $\mathbb{c}\triangleq[c_{m-1}\textup{ }c_{m-2}\textup{ }\dots\textup{ }c_{0}]\in\mathcal{AC}_{m,x}$. The index of an A-LOCO codeword $\mathbb{c}$ in $\mathcal{AC}_{m,x}$ is denoted by $g(m,x,\mathbb{c})$, which is sometimes abbreviated to $g(\mathbb{c})$, as in Table I, for simplicity. We also define an integer variable $a_{i}$ for each binary $c_{i}$ as follows:

[TABLE]

with $a_{m}\triangleq 0$. The same notation applies for an A-LOCO codeword of length $m+1$, $\mathbb{c}^{\prime}$ in $\mathcal{AC}_{m+1,x}$, and an A-LOCO codeword of length $m-x$, $\mathbb{c}^{\prime\prime}$ in $\mathcal{AC}_{m-x,x}$.

Theorem 2 gives the encoding-decoding rule of A-LOCO codes. The indexing is trivial for the case of $m=1$

Theorem 2**.**

The lexicographic index $g(m,x,\mathbb{c})$ of an A-LOCO codeword $\mathbb{c}$ in $\mathcal{AC}_{m,x}$, $m\geq 2$ and $x\geq 1$, is computed from the codeword itself according to the following rule:

[TABLE]

Proof:

We prove Theorem 2 by induction.

Base: Our base case is the case of $m=2$. For $\mathcal{AC}_{2,x}$, we always have four codewords, say $\mathbb{c}_{0}$, $\mathbb{c}_{1}$, $\mathbb{c}_{2}$, and $\mathbb{c}_{3}$ in order, for any value of $x$. These four codewords are listed in Table I. We want to prove that $g(\mathbb{c}_{j})=j$, for all $j\in\{0,1,2,3\}$, using (10). The bits of a codeword $\mathbb{c}_{j}$ are $c_{j,i}$, $i\in\{0,1\}$, and $a_{j,i}$ is defined for each $c_{j,i}$ as in (9).

[TABLE]

Recall that $N(1,x)\triangleq 2$, for all $x\in\{1,2,\dots\}$.

Assumption: We assume that the following is correct:

[TABLE]

where $\overline{\mathbb{c}}\in\mathcal{AC}_{\overline{m},x}$ and $\overline{m}\in\{2,3,\dots,m\}$ with the same notation defined before Theorem 2 applied to $\overline{\mathbb{c}}$. The assumption here basically means (10) is correct for all A-LOCO codes $\mathcal{AC}_{\overline{m},x}$, $\overline{m}\in\{1,2,\dots,m\}$.

To be proved: We prove that:

[TABLE]

which means we prove that given the base and the assumption, (10) is also correct for the A-LOCO code $\mathcal{AC}_{m+1,x}$.

One more time, we use the group structure introduced in Section II to prove (13). Note that the group structure can be defined for $\mathcal{AC}_{m+1,x}$ as defined for $\mathcal{AC}_{m,x}$. We use the same codeword correspondence in the proof of Theorem 1 for the three groups (with $m+1$ replacing $m$).

Group 1: The codewords in Group 1 in $\mathcal{AC}_{m+1,x}$ start at index [math], and the corresponding codewords in $\mathcal{AC}_{m,x}$ also start at index [math]. Thus, for this group, the shift in codeword indices between a codeword $\mathbb{c}^{\prime}$ in $\mathcal{AC}_{m+1,x}$ and the corresponding codeword $\mathbb{c}$ in $\mathcal{AC}_{m,x}$ is:

[TABLE]

Consequently, and using (12):

[TABLE]

Since $\mathbb{c}^{\prime}$ starts with [math] from the left, $a^{\prime}_{m}=0$. Additionally, $\mathbb{c}^{\prime}$ and $\mathbb{c}$ share the $m$ RMBs. Thus, (15) can be written as:

[TABLE]

Group 2: The codewords in Group 2 in $\mathcal{AC}_{m+1,x}$ start right after Groups 1 and 3, and the corresponding codewords in $\mathcal{AC}_{m,x}$ start right after all the codewords that start with [math] from the left. Thus, for this group, the shift in codeword indices between a codeword $\mathbb{c}^{\prime}$ in $\mathcal{AC}_{m+1,x}$ and the corresponding codeword $\mathbb{c}$ in $\mathcal{AC}_{m,x}$ is:

[TABLE]

where the second equality follows from using (4) and (8). Consequently, and using (12):

[TABLE]

Observe that $c_{m-1}=1$; thus, $a_{m-1}=1$, while $a_{m}\triangleq 0$. Using these observations in (III) results in:

[TABLE]

Since $\mathbb{c}^{\prime}$ starts with $11$ from the left, $a^{\prime}_{m}=a^{\prime}_{m-1}=1$, same as $a_{m-1}$, while $a^{\prime}_{m+1}\triangleq 0$. Consequently,

[TABLE]

Additionally, $\mathbb{c}^{\prime}$ and $\mathbb{c}$ share the $m-1$ RMBs. Thus, aided by (III), (III) can be written as:

[TABLE]

Group 3: The codewords in Group 3 in $\mathcal{AC}_{m+1,x}$ start right after Group 1, and the corresponding codewords in $\mathcal{AC}_{m-x,x}$ start at index [math]. Thus, for this group, the shift in codeword indices between a codeword $\mathbb{c}^{\prime}$ in $\mathcal{AC}_{m+1,x}$ and the corresponding codeword $\mathbb{c}^{\prime\prime}$ in $\mathcal{AC}_{m-x,x}$ is:

[TABLE]

Consequently, and using (12):

[TABLE]

where the second equality follows from that $\mathbb{c}^{\prime\prime}$ starts with [math] from the left; thus, $a^{\prime\prime}_{m-x-1}=0$. Since $\mathbb{c}^{\prime}$ starts with $1\mathbb{0}^{x+1}$ from the left, $a^{\prime}_{m}=1$ and $a^{\prime}_{m-1}=a^{\prime}_{m-2}=\dots=a^{\prime}_{m-x-1}=0$, while $a^{\prime}_{m+1}\triangleq 0$. Additionally, $\mathbb{c}^{\prime}$ and $\mathbb{c}^{\prime\prime}$ share the $m-x-1$ RMBs. Thus, (III) can be written as:

[TABLE]

From (16), (III), and (24), (13) is proved, which completes the proof by induction for any A-LOCO code $\mathcal{AC}_{m,x}$, $m\geq 2$ and $x\geq 1$. ∎

Example 2**.**

We illustrate Theorem 2 by applying (10) on two different codewords in $\mathcal{AC}_{5,1}$, given in Table I, to compute their indices. The first codeword is $01111$; thus, $a_{4}=0$ and $a_{3}=a_{2}=a_{1}=a_{0}=1$. Consequently,

[TABLE]

which is indeed the index of this codeword in Table I. The second codeword is $11001$; thus, $a_{4}=a_{3}=a_{0}=1$ and $a_{2}=a_{1}=0$, while $a_{5}\triangleq 0$. Consequently,

[TABLE]

which is indeed the index of this codeword in Table I.

Theorem 2 gives the encoding-decoding rule of A-LOCO codes. In particular, this theorem provides a simple mapping-demapping (both are one-to-one) from the index to the codeword and vice-versa. This simple mapping-demapping represented by (10) is what enables low-complexity encoding and decoding algorithms for A-LOCO codes as we shall see later. The main advantage offered by A-LOCO codes is that they are capacity-achieving asymmetric constrained codes with simple encoding-decoding.

IV Bridging, Clocking, and Achievable Rates

In this section, we discuss the bridging patterns and the self-clocking of A-LOCO codes. Then, we introduce the rates of A-LOCO codes in the finite-length regime and show that they are capacity-achieving codes.

In fixed-length constrained codes [13], given any two consecutive codewords, bridging patterns are needed to prevent forbidden patterns from appearing on the transition from the first codeword to the following codeword [15]. For example, consider the A-LOCO code $\mathcal{AC}_{5,1}$ given in Table I, if the codewords having indices $13$ and $8$ are to be written consecutively without bridging, we get the following substream of bits $1000\textit{101}001$ in which, the forbidden pattern $101$ does appear (the pattern is shown in italic).

For symmetric LOCO codes, it was shown in [15] that upon deciding the bridging method, there is a compromise between the maximum protection of the bits at the codeword transitions and the minimum number of bits/symbols to be used for bridging. The optimal bridging method for a symmetric LOCO code with parameter $x$ in terms of bits protection was shown to require $2x$ bridging bits, which results in significant rate loss [15]. Thus, we adopted a suboptimal bridging method for symmetric LOCO codes that is bridging by $x$ no writing, or no transmission, symbols.

For an A-LOCO code with parameter $x$, only patterns of the form $\{101,1001,\dots,1\mathbb{0}^{x}1\}$ are forbidden. Thus, bridging with $x$ [math]’s, i.e., with the pattern $\mathbb{0}^{x}$, ensures that forbidden patterns do not appear on the codeword transitions except for the case when the RMB of a codeword and the LMB of the next codeword to be written are both $1$’s. In this case, bridging with $x$ $1$’s, i.e., with the pattern $\mathbb{1}^{x}$, is used instead. In summary, our bridging method for A-LOCO codes is:

If the RMB of a codeword and the LMB of the next codeword to be written are both $1$’s, bridge with $\mathbb{1}^{x}$. 2. 2.

Otherwise, bridge with $\mathbb{0}^{x}$.

It is important here to highlight that the proposed bridging methods is one of the advantages of A-LOCO codes over other constrained codes. In particular, the bridging method is not only optimal in terms of bits protection, but also requires the minimum number of added bits for bridging, which is only $x$ bits for an A-LOCO code $\mathcal{AC}_{m,x}$. Observe that this bridging method is also easy to implement.

Next, we discuss the self-clocking of A-LOCO codes. This feature is required in order to have clock recovery and system calibration [2, 15]. A constrained code is said to be self-clocked if any stream of codewords to be written contains a sufficient number of appropriately-separated transitions after bridging and signaling are applied. Since NRZ signaling is adopted for A-LOCO codes, these transitions are the $0-1$ and $1-0$ transitions in A-LOCO codewords. To achieve self-clocking, we just need to remove the two codewords $\mathbb{0}^{m}$ and $\mathbb{1}^{m}$ from an A-LOCO code $\mathcal{AC}_{m,x}$ as this guarantees at least one transition in each A-LOCO codeword.

Definition 2**.**

A self-clocked A-LOCO code (CA-LOCO code) $\mathcal{AC}^{\textup{c}}_{m,x}$, $m\geq 2$, is the A-LOCO code $\mathcal{AC}_{m,x}$ after removing the all [math]’s and the all $1$’s codewords. Mathematically,

[TABLE]

Thus, the cardinality of $\mathcal{AC}^{\textup{c}}_{m,x}$ is:

[TABLE]

We define $k^{\textup{c}}_{\textup{eff}}$ as the maximum number of consecutive cells between two consecutive transitions (all programmed or all unprogrammed) after a stream of CA-LOCO codewords separated by bridging patterns is written; one bit per cell. Thus, $k^{\textup{c}}_{\textup{eff}}$ is the length of the longest run of consecutive $1$’s or [math]’s in a stream of CA-LOCO codewords separated by bridging patterns. The scenarios under which $k^{\textup{c}}_{\textup{eff}}$ is achieved are:

[TABLE]

Consequently, $k^{\textup{c}}_{\textup{eff}}$ is given by:

[TABLE]

which is the same equation satisfied by LOCO codes [15].

Given the cardinality of a CA-LOCO code $\mathcal{AC}^{\textup{c}}_{m,x}$, the size of the messages $\mathcal{AC}^{\textup{c}}_{m,x}$ encodes is:

[TABLE]

Consequently, the rate of a CA-LOCO code $\mathcal{AC}^{\textup{c}}_{m,x}$, where $x$ bits are used for bridging as illustrated above, is given by:

[TABLE]

Observe the following:

A CA-LOCO code $\mathcal{AC}^{\textup{c}}_{m,x}$ contains all the codewords satisfying the $\mathcal{A}_{x}$ constraint except the two codewords in $\{\mathbb{0}^{m},\mathbb{1}^{m}\}$. This follows from Definitions 1 and 2. 2. 2.

The number of bits added for bridging is $x$, which does not grow with the code length $m$. Thus, as $m\rightarrow\infty$, the $x$ in the denominator of (29) can be ignored.

From the above two observations, we conclude that CA-LOCO codes are capacity-achieving constrained codes. Shortly, we will show that rates approaching the capacity can be achieved with low complexity encoding-decoding.

Example 3**.**

Consider again the A-LOCO code $\mathcal{AC}_{5,1}$ in Table I. The CA-LOCO code $\mathcal{AC}^{\textup{c}}_{5,1}$ is obtained by removing the codewords $\mathbb{0}^{m}$ (with index [math]) and $\mathbb{1}^{m}$ (with index $20$) from $\mathcal{AC}_{5,1}$. For this CA-LOCO code, we have:

[TABLE]

The size of the messages $\mathcal{AC}^{\textup{c}}_{5,1}$ encodes is:

[TABLE]

where $N(5,1)=21$ from Example 1 and Table I. All the $16$ codewords of $\mathcal{AC}^{\textup{c}}_{5,1}$ that have corresponding messages are shown in Table II. From (29), the rate is:

[TABLE]

Note that this is a relatively low rate because of the small value of the code length $m$.

Table III lists the rates of multiple CA-LOCO codes $\mathcal{AC}^{\textup{c}}_{m,x}$ for different values of $m$ and $x\in\{1,2\}$. For the case of $x=1$, at length $m=44$ (resp., $76$), the rate is $0.8000$ (resp., $0.8052$). The capacity of $\mathcal{A}_{1}$-constrained codes is $0.8114$ [11, 10]. Thus, at length $76$ (resp., $113$) bits, the CA-LOCO code is within just $0.8\%$ (resp., $0.6\%$) from the capacity. In fact, for the larger length of $357$ bits, the CA-LOCO code is within only $0.2\%$ from the capacity. For the case of $x=2$, at length $m=28$ (resp., $64$), the rate is $0.6667$ (resp., $0.6818$). The capacity of $\mathcal{A}_{2}$-constrained codes is $0.6942$ from the finite-state transition diagram (FSTD). Thus, at length $64$ (resp., $123$) bits, the CA-LOCO code is within just $1.8\%$ (resp., $0.9\%$) from the capacity. In fact, for the larger length of $244$ bits, the CA-LOCO code is within only $0.5\%$ from the capacity.

Remark 1**.**

A-LOCO codes do not satisfy the complement rule of symmetric LOCO codes in [15, Lemma 3]. Thus, balancing A-LOCO codes incurs a higher rate penalty. To reduce this penalty, almost-balanced A-LOCO codes, where no strict guarantee exists on the maximum magnitude of the running disparity, can be designed in a way similar to balanced LOCO codes. The balancing requirement is more important in optical recording systems than it is in Flash systems.

V Algorithms, Complexity, and Comparisons

In this section, we introduce practical encoding and decoding algorithms of A-LOCO codes. We then discuss the complexity of these algorithms, and make comparisons with other asymmetric and symmetric constrained codes that mitigate ICI in Flash systems.

In coding techniques based on indexing points (here representing codewords), devising simple algorithms to perform the mapping-demapping between the index and the associated point is critical to avoid look-up tables; and thus, to make the technique practical for large sizes. For example, motivated by this observation, the authors of [17] developed simple algorithms to index the points of multi-dimensional constellations. The simple, practical algorithms we introduce in this section are also motivated by the same observation.

Algorithm 1 is the encoding algorithm. While generating a specific codeword $\mathbb{c}$ in the algorithm, we define the RMB of the previous codeword as $\zeta_{0}$.

Example 4**.**

We apply Algorithm 1 to encode the message $1010$ using the CA-LOCO code $\mathcal{AC}^{\textup{c}}_{5,1}$ ($m=5$ and $x=1$). Recall that $N(1,1)\triangleq 2$, $N(2,1)=4$, $N(3,1)=7$, $N(4,1)=12$, and $N(5,1)=21$ (see Example 1). From Step 6, $g(\mathbb{c})=\textup{decimal}(1010)+1=11$, which is the initial value of residual. The bits of the codeword $\mathbb{c}$ are generated as follows:

For $i=4$, and since $c_{5}$ is set to [math], $\textup{subt\_index}=i=4$ from Step 10. Now, $\textup{residual}=11<N(4,1)=12$. Thus, $c_{4}$ is encoded to [math] from Step 15. Then, the if condition in Step 20 is satisfied, and because $c_{4}\neq 1$, we bridge with $\mathbb{0}^{x}$ before $c_{4}$ assuming that this is not the first codeword. 2. 2.

For $i=3$, and since $c_{4}=0$, $\textup{subt\_index}=i=3$ from Step 10. Now, $\textup{residual}=11>N(3,1)=7$. Thus, $c_{3}$ is encoded to $1$ from Step 17, and residual becomes $11-7=4$ from Step 18. 3. 3.

For $i=2$, and since $c_{3}=1$, $\textup{subt\_index}=i-x=1$ from Step 12. Now, $\textup{residual}=4>N(1,1)\triangleq 2$. Thus, $c_{2}$ is encoded to $1$ from Step 17, and residual becomes $4-2=2$ from Step 18. 4. 4.

For $i=1$, and since $c_{2}=1$, $\textup{subt\_index}=i-x=0$ from Step 12. Now, $\textup{residual}=2>N(0,1)\triangleq 1$. Thus, $c_{1}$ is encoded to $1$ from Step 17, and residual becomes $2-1=1$ from Step 18. 5. 5.

For $i=0$, and since $c_{1}=1$, $\textup{subt\_index}=i-x=-1$ from Step 12. Now, $\textup{residual}=1=N(-1,1)\triangleq 1$. Thus, $c_{0}$ is encoded to $1$ from Step 17, and residual becomes $1-1=0$ from Step 18.

As a result of this procedure, the message $1010$ is encoded using the CA-LOCO code $\mathcal{AC}^{\textup{c}}_{5,1}$ to the codeword $01111$, which is consistent with Table II.

Observe that Algorithm 1 has less steps and less computations compared with [15, Algorithm 1] for symmetric LOCO codes. The reason is that all the steps required to avoid the patterns in $\{010,0110,\dots,0\mathbb{1}^{x}0\}$ are not needed here since these patterns are not forbidden for A-LOCO codes. Thus, the encoding complexity of an A-LOCO code is less than that of the LOCO code with the same $m$ and $x$.

Algorithm 2 is the decoding algorithm.

Since Algorithm 2 is a direct consequence of Theorem 2, we refer the reader to Example 2 for more understanding of how the algorithm works.

On the level of a single message-codeword pair, there exists a single for loop on $m$ distinct values for the variable $i$ in both Algorithm 1 (the encoding algorithm) and Algorithm 2 (the decoding algorithm). For each value of $i$, at most one major arithmetic operation is performed. Thus, the complexity of both algorithms has $O(m)$ on that level. Moreover, the main operations in Algorithm 1 are comparisons/subtractions, while the main operations in Algorithm 2 are additions. The largest result of these operations is the maximum value the index $g(\mathbb{c})$ can take, which is $2^{s^{\textup{c}}}-1$. Consequently, the size of the used adders, which is $s^{\textup{c}}$, dictates the complexity of the encoding and decoding algorithms of CA-LOCO codes.

Table III links various finite-length rates of CA-LOCO codes $\mathcal{AC}^{\textup{c}}_{m,x}$ for different values of $m$ and $x\in\{1,2\}$ to the associated size of adders required to achieve these rates, which is a crucial complexity measure. For example, for the case of $x=1$, to achieve a rate $\geq 0.8000$ (resp., $\geq 0.8050$), adders of size $36$ bits (resp., $62$ bits) suffice. Moreover, for the case of $x=2$, to achieve a rate $\geq 0.6667$ (resp., $\geq 0.6800$), adders of size $20$ bits (resp., $45$ bits) suffice. Note that the two cases of $\mathcal{AC}^{\textup{c}}_{357,1}$ and $\mathcal{AC}^{\textup{c}}_{244,2}$ are given in the table only to show how close to capacity CA-LOCO codes can get; that is why the adder size is skipped for both.

Next, we compare A-LOCO codes with other constrained codes used for the same purpose. First, we compare with constrained codes based on finite-state machines (FSMs) and sliding window decoders. FSM-based constrained codes are designed by developing an FSTD that represents infinite sequences satisfying the required constraint. Then, multiple steps are performed to generate the encoding-decoding FSM from the FSTD [2, 11]. To construct FSM-based constrained codes with capacity-approaching rates, typically the FSM gets quite complicated, and so are the encoding and decoding procedures.

As a result, we compare with FSM-based $\mathcal{A}_{x}$-constrained codes that are known to be practical in terms of complexity. A practical FSM-based $\mathcal{A}_{1}=\{101\}$-constrained code has a rate of $0.8000$ [11], while practical CA-LOCO codes that are $\mathcal{A}_{1}$-constrained achieve rates $\geq 0.8050$ at moderate lengths. Additionally, a practical FSM-based $\mathcal{A}_{2}=\{101,1001\}$-constrained code has a rate of $0.6667$, while practical CA-LOCO codes that are $\mathcal{A}_{2}$-constrained achieve rates $\geq 0.6800$ at moderate lengths. The gain in rate achieved by low-complexity CA-LOCO codes (with adder sizes $\leq 64$ bits) compared with practical FSM-based constrained codes reaches $3\%$, which is a significant rate increase for high rates. Techniques raising the rate with similar or less amounts are highly appreciated in the literature, e.g., raising the rate of FSM-based constrained codes forbidding the patterns in $\{0101,11101\}$ from $\frac{5}{6}$ to $\frac{6}{7}$, which gives a $2.85\%$ gain [11].

A-LOCO codes also have other advantages over FSM-based constrained codes designed for the same purpose. A-LOCO codes are fixed-length codes. Thus, they do not allow errors to propagate from a codeword into another. Additionally, they also enable parallel encoding and decoding in applications where runtime operations speed is critical.

Second, we compare with the binary asymmetric constrained codes in [10]. In [10], the encoding and decoding are based on the unrank and rank procedures described in [10, Algorithm 1] and [10, Algorithm 2]. While these codes are also enumerative, and thus, can achieve high rates, their encoding and decoding algorithms are more complex than those of A-LOCO codes, which are based on a simple rule described in Theorem 2. Additionally, the codes in [10] only consider the effect of adjacent Flash cells, i.e., can only eliminate the pattern $101$ for SLC Flash devices.

Third, we compare with symmetric LOCO codes used for the same goal. In particular, we compare an $\mathcal{A}_{x}$-constrained code (A-LOCO code) of length $m$ with the $\mathcal{S}_{x}$-constrained code (LOCO code) of length $m$. For Flash devices where the goal is only to eliminate the patterns in $\{101,1001,\allowbreak\dots,1\mathbb{0}^{x}1\}$, the gain in rate achieved by A-LOCO codes over LOCO codes at the same low complexity and achieving nearly the same performance reaches $16\%$ (resp., $25\%$) for $x=1$ (resp., $x=2$). This gain is expected knowing that the capacity of $\mathcal{S}_{1}$-constrained (resp., $\mathcal{S}_{2}$-constrained) codes is $0.6942$ (resp., $0.5515$) [15]. More details are available in Table III and [15, Table IV]. We note that a similar observation was stated in [11] in the context of MR systems.

Like LOCO codes [15], A-LOCO codes are reconfigurable, that is, the same hardware can be used to support multiple constraints if the size of the adders is appropriately chosen.

VI Conclusion

We introduced a new family of asymmetric constrained codes, A-LOCO codes, to improve the performance in Flash memories. Only the detrimental patterns in Flash systems are eliminated in A-LOCO codewords. We derived a recursive formula to compute the cardinality of A-LOCO codes. We presented a simple rule for the mapping-demapping between the lexicographic index and the codeword. This rule allowed practical, low-complexity encoding and decoding algorithms of A-LOCO codes. We illustrated how to optimally bridge and to self-clock A-LOCO codes. We showed that A-LOCO codes are capacity-achieving. The complexity of encoding-decoding A-LOCO codes was studied and comparisons with other constrained codes were presented. These comparisons demonstrated that A-LOCO codes offer a rate-complexity trade-off that is better than other constrained codes used for the same purpose. Non-binary constrained codes for Flash devices with more than two levels and multi-dimensional constrained codes for multi-dimensional storage devices are among the near future research directions. QLC Flash memory evolution is expected to benefit from efficient high rate non-binary asymmetric constrained codes.

Acknowledgment

This research was supported in part by NSF under grant CCF 1717602.