Fast Xor-based Erasure Coding based on Polynomial Ring Transforms

TL;DR

This paper introduces a novel method for reducing the complexity of finite field multiplication in erasure codes by leveraging polynomial ring transforms, leading to more efficient software implementations.

Contribution

It proposes a new approach using polynomial ring transforms to simplify finite field operations, improving the efficiency of erasure coding implementations.

Findings

Reduced finite field multiplication complexity

Efficient scheduling decreases operation count

Potential for faster erasure coding algorithms

Abstract

The complexity of software implementations of MDS erasure codes mainly depends on the efficiency of the finite field operations implementation. In this paper, we propose a method to reduce the complexity of the finite field multiplication by using fast transforms between a field and a ring to perform the multiplication in a ring. We show that moving to a ring reduces the complexity of the operations. Then, we show that this construction allows the use of simple scheduling to reduce the number of operations.

Tables

Table 1. TABLE I: Number of xor for Embedding and Parity transforms

	field to ring	ring to field
Embedding	0	$m.w$
Parity bits	$k.w$	0

Table 2. TABLE II: factor over optimal for w = 4 𝑤 4 w=4

k+m,k	12,8	16,10
average field matrix	1.79	1.90
best field matrix	1.73	1.85
average ring matrix	1.59	1.63
best ring matrix	1.5	1.58
average with scheduling	1.32	1.26
best with scheduling	1.19	1.20

Equations

$$R_{q,n}\simeq B_1\otimes B_2\otimes \dots B_r$$

$$\phi_{i}:\begin{array}[]{ccc}B_{i}&\rightarrow&A_{i}\\ b(x)&\rightarrow&b(x)\theta_{i}(x)\end{array}$$

$$\phi_{i}^{-1}:\begin{array}[]{ccc}A_{i}&\rightarrow&B_{i}\\ a(x)&\rightarrow&a(\alpha_{i})\\ \end{array}$$

$$p(x)=x^w+x^{w-1}+x^{w-2}+\dots +x+1$$

$${\varphi }_1^{-1}({\varphi }_1(u(x)).{\varphi }_1(v(x)))=u(x).v(x)$$

$$\phi_{1}(b_{B}(x))=b_{A}(x)=\left\{\begin{array}[]{cl}b_{B}(x)&\textrm{if }W(b_{B}(x))\textrm{ is even}\\ b_{B}(x)+p(x)&\textrm{else}\end{array}\right.$$

$$\phi_{i}^{-1}(b_{A}(x))=b_{B}(x)=\left\{\begin{array}[]{cl}b_{A}(x)&\textrm{ if }b_{w}=0\\ b_{A}(x)+p(x)&\textrm{else}\end{array}\right.$$

$${\bar{\varphi }}_1^{-1}({\varphi }_E(u(x)).{\varphi }_E(v(x)))=u(x).v(x)$$

$${\varphi }_S(b_B(x))=b_A(x)={\varphi }_1(b_B(x))+\delta .p(x)$$

$${\bar{\varphi }}_1^{-1}({\varphi }_S(u(x)).{\varphi }_S(v(x)))=u(x).v(x)$$

$$(k+m-1).w+(k-1).(m-1).w.w_{{\varphi }_S}$$

$$(\min (k,m)+k+m-1).w+(k-1).(m-1).w.w_{{\varphi }_S}$$

$$w_{\phi_{S}}=\frac{w+1}{2^{w+1}-2}.\Big{(}2^{w}-\binom{w}{w/2}\Big{)}$$

$$V=\big{(}x^{i.j}\big{)}_{i=0,\ldots,4;j=0,\ldots,4}$$

$$(\min (k,m)+k+m-1).w+(k-1).(m-1).w=k.w+k.m.w$$

Full text

I Introduction

Most of practical Maximum Distance Separable (MDS) packet erasure codes are implemented in software. In the various applications like packet erasure channels [1] or distributed storage systems [2], the coding/decoding process performs operations over finite fields. The efficiency of the implementation of these finite field operations is thus critical for these applications.

To speedup this operation, [1] described an implementation of finite field multiplications which only uses simple xor operations, contrarily to classic software multiplications which are based on lookup tables (LUT). The complexity of multiplying by an element, i.e. the number of xor operations, depends on the size of the finite field and also on the element itself. This kind of complexity is studied for Maximum-Distance Separable (MDS) codes in [3]. Other work has been done to reduce redundant xor operations by applying scheduling [4].

Independently, in the context of large finite field for cryptographic applications, [5] proposed a xor-based method to perform fast hardware implementations of multiplications by transforming each element of a field into an element of a larger ring. In this polynomial ring, where the operations on polynomials are done modulo $x^{n}+1$, the multiplication by a monomial is much simpler as the modulo is just a cyclic shift. The authors identified two classes of fields based on irreducible polynomials with binary coefficients allowing to transform each field element into a ring element by adding additional ”ghost bits”.

In this paper, we extend their approach to define fast software implementations of xor-based erasure codes. We propose an original method called PYRIT (PolYnomial RIng Transform) to perform operations between elements of a finite field into a bigger ring by using fast transforms between these two structures. Working in such a ring is much easier than working in a finite field. Firstly, it reduces the coding complexity by design. And secondly, it allows the use of simple scheduling to reduce the number of operations thanks to the properties of the ring structure.

The next section presents the algebraic framework allowing to define the various transforms between the finite field and some subsets of the ring. Then we discuss about the choice of these transforms and their properties. We also detail the complexity analysis before introducing some scheduling results.

II Algebraic context

The algebraic context of this paper is finite fields and ring theory. More detailed presentation of this context including the proofs of the following propositions can be found in [6] or [7].

Definition 1**.**

Let $\mathbb{F}_{q^{w}}$ be the finite field with $q^{w}$ elements.

Definition 2**.**

Let $R_{q,n}=\mathbb{F}_{q}[x]/(x^{n}-1)$ denote the quotient ring of polynomials of the polynomial ring $\mathbb{F}_{2}[x]$ quotiented by the ideal generated by the polynomial $x^{n}-1$.

Definition 3**.**

Let $p_{1}^{u_{1}}(x)p_{2}^{u_{2}}(x)\ldots p_{r}^{u_{r}}(x)=x^{n}-1$ be the decomposition of $x^{n}-1$ into irreducible polynomials over $\mathbb{F}_{q}$.

When $n$ and $q$ are relatively prime, it can be shown that $u_{1}=u_{2}=\ldots=u_{n}=1$ (see [7]). In other words, if $q=2$, and $n$ is odd, we simply have $p_{1}(x)p_{2}(x)\ldots p_{r}(x)=x^{n}-1$.

In the rest of this document, we assume that $n$ and $q$ are relatively prime.

Proposition 1**.**

The ring $R_{q,n}$ is equal to the direct sum of its $r$ minimal ideals of $A_{i}=((x^{n}-1)/p_{i}(x))$ for $i=1,\ldots,r$.

Moreover, each minimal ideal contains a unique primitive idempotent $\theta_{i}(x)$. A construction of this idempotent is given in [6], Chap. 8, Theorem 6.

Since $\mathbb{F}_{q}[x]/(p_{i}(x))$ is isomorphic to the finite field $B_{i}=\mathbb{F}_{q^{w}_{i}}$, where $p_{i}(x)$ is of degree $w_{i}$, we have:

Proposition 2**.**

$R_{q,n}$* is isomorphic to the following Cartesian product:*

[TABLE]

For each $i=1,\ldots,r$, $A_{i}$ is isomorphic to $B_{i}$. The isomorphism is:

[TABLE]

and the inverse isomorphism is:

[TABLE]

where $\alpha_{i}$ is a root of $p_{i}(x)$.

Let us now assume that $q=2$. Let us introduce a special class of polynomials:

Definition 4**.**

The All One Polynomial (AOP) of degree $w$ is defined as

[TABLE]

The AOP of degree $w$ is irreducible over $\mathbb{F}_{2}$ if and only if $w+1$ is a prime and $w$ generates $\mathbb{F}^{*}_{w+1}$, where $\mathbb{F}^{*}_{w+1}$ is the multiplicative group in $\mathbb{F}_{w+1}$ [8]. The values $w+1$, such that the AOP of degree $w$ is irreducible is the sequence A001122 in [9]. The first values of this sequence are: $3,5,11,13,19,29,\ldots$. In this paper, we only consider irreducible AOP.

According to Proposition 2, $R_{2,w+1}$ is equal to the direct sum of its principal ideals $A_{1}=((x^{w+1}+1)/p(x))=(x+1)$ and $A_{2}=((x^{w+1}+1)/x+1)=(p(x))$ and $R_{2,w+1}$ is isomorphic to the direct product of $B_{1}=\mathbb{F}_{2}[x]/(p(x))=\mathbb{F}_{2^{w}}$ and $B_{1}=\mathbb{F}_{2}[x]/(x+1)=\mathbb{F}_{2}$.

It can be shown that the primitive idempotent of $A_{1}$ is $\theta_{1}=p(x)+1$. This idempotents is used to build the isomorphism $\phi_{1}$ between $A_{1}$ and $B_{1}$.

III Transforms between the field and the ring

This section presents different transforms between the field $B_{1}=\mathbb{F}_{2^{w}}=\mathbb{F}_{2}[x]/(p(x))$ and the ring $R_{2,w+1}=\mathbb{F}_{2}[x]/(x^{w+1}+1)$.

III-A Isomorphism transform

The first transform is simply the application of the basic isomorphism between $B_{1}$ and the ideal $A_{1}$ of $R_{2,w+1}$ (see Prop. 2).

By definition of the isomorphism, we have:

[TABLE]

So, $\phi_{1}$ can be used to send the elements of the field in the ring, then, to perform the multiplication, and then, to come back in the field. We show in the following Proposition that the isomorphism admits a simplified version.

Let $W(b(x))$, the weight of $b(x)$, defined as the number of monomials in the polynomial representation of $b(x)$.

Proposition 3**.**

[TABLE]

[TABLE]

where $b_{w}$ is the coefficient of the monomial of degree $w$ of $b_{A}(x)$.

Proof:

For the first point, we have $\phi_{1}(b(x))=b(x)\theta_{1}(x)=b(x)(p(x)+1)=b(x)p(x)+b(x)$. We can observe that $b(x)p(x)=0$ when $W(b(x))$ is even and $b(x)p(x)=p(x)$ when $W(b(x))$ is odd. The first point is thus obvious.

For the second point, it can be observed that, from the first point of this proposition, if an element of $A_{1}$ has a coefficient $b_{w}\not=0$, then it was necessarily obtained from the second rule, i.e. by adding $p(x)$. Then, its image into $B_{1}$ can be obtained by subtracting (adding in binary) $p(x)$. If $b_{w}=0$, then nothing has to be done to obtain $b_{B}(x)$. ∎

III-B Embedding transform

Let us denote by $\phi_{E}$ the embedding function which simply consists in considering the element of the field as an element of the ring without any transformation. This function was initially proposed in [5].

Note that the images of the elements of $B_{1}$ doesn’t necessarily belong to $A_{1}$. However, let us define the function $\bar{\phi}_{1}^{-1}$ from $R_{2,w+1}$ to $A_{1}$ by $\bar{\phi}_{1}^{-1}(b_{A}(x))=b_{A}(\alpha)$, where $\alpha$ is a root of $p(x)$. This function can be seen as an extension of the function $\phi_{1}^{-1}$ to the whole ring.

Proposition 4**.**

[5*]**

For any $u(x)$ and $v(x)$ in $B_{1}$, we have:*

[TABLE]

Proof.

The embedding function corresponds to a multiplication by $1$ in the ring. In fact, $1$ is equal to the sum of the idempotents $\theta_{i}(x)$ of the ideals $A_{i}$, for $i=1,\ldots,l$ [6, chapter 8, thm. 7]. Thus, $\phi_{E}(u(x))=u(x).\sum_{i=0}^{l}\theta_{i}(x)$. Then, $\phi_{E}(u(x)).\phi_{E}(v(x))$ is equal to $u(x).v(x).(\sum_{i=0}^{l}\theta_{i}(x))^{2}$. Thanks to the properties of idempotents, $\theta_{i}(x).\theta_{j}(x)$ is equal to $\theta_{i}(x)$ if $i=j$ and [math] else. Thus, $\phi_{E}(u(x)).\phi_{E}(v(x))$ is equal to $u(x).v(x).(\sum_{i=0}^{l}\theta_{i}(x))$. The function $\bar{\phi}_{i}^{-1}$ is the computation of the remainder modulo $p_{i}(x)$. The irreducible polynomial $p_{i}(x)$ corresponds to the ideal $A_{i}$. Thus $\theta_{i}(x)\textrm{ mod }p(x)$ is equal to $1$ if $i=1$ and [math] else. ∎

This proposition proves that the Embedding function can be used to perform a multiplication in the ring instead of doing it in the field. The isomorphism also has this property, but the complexities of the transforms between the field and the ring are more complex.

III-C Sparse transform

Let us define the transform $\phi_{S}$ from $B_{1}$ to $R_{2,w+1}$:

[TABLE]

where $\delta=1$ if $W(\phi_{1}(b_{B}(x))+p(x))<W(\phi_{1}(b_{B}(x)))$ and [math] else.

Proposition 5**.**

For any $u(x)$ and $v(x)$ in $B_{1}$, we have:

[TABLE]

Proof.

As observed in the proof of Prop. 4, $\bar{\phi}_{i}^{-1}$ is just the computation of the remainder modulo $p(x)$. Moreover, according to the definition of $\phi_{S}$, $\phi_{S}(u(x)).\phi_{S}(v(x))$ is equal to $u(x).v(x)$ plus a multiple of $p(x)$ (possibly equal to [math]). Thus, the remainder of $\phi_{S}(u(x)).\phi_{S}(v(x))$ modulo $p(x)$ is equal to $u(x).v(x)$. ∎

This proposition shows that $\phi_{S}$ can be used to perform the multiplication in the ring. The main interest of this transform is that the weight of the image of $\phi_{S}$ is small, which reduce the complexity of the multiplication in the ring.

III-D Parity transform

Proposition 6**.**

The ideal $A_{1}$ is composed of the set of elements of $R_{2,w+1}$ with even weight.

Proof:

We can observe from Proposition 3 that all the image of $\phi_{1}$ have even weight. Since the number of even-weight element of $R_{2,w+1}$ is equal to the number of elements of $A_{1}$, $A_{1}$ is composed of the set of elements of $R_{2,w+1}$ with even weight. ∎

Let us consider the function $\phi_{P}$, from $B_{1}$ to $R_{2,w+1}$, which adds a single parity bit to the vector corresponding to the finite field element. The obtained element has an even weight (by construction), and thus, according to the previous Proposition, it belongs to $A_{1}$.

Since the images by $\phi_{P}$ of two distinct elements are distinct, $\phi_{P}$ is a bijection between $B_{1}$ and $A_{1}$. The inverse function, $\phi_{P}^{-1}$, consists just in removing the last coefficient of the ring element.

It should be noted that $\phi_{P}$ is not an isomorphism, but just a bijection between $B_{1}$ and $A_{1}$. However it will be shown in next Section that this function can be used in the context of erasure codes.

IV Application of transforms

In typical xor-based erasure coding systems [1], the encoding process consists in multiplying an information vector by the generator matrix. Since in software, xor are performed using machine words of $l$ bits, $l$ interleaved codewords are encoded in parallel.

We consider a system with $k$ input data blocks and $m$ output parity blocks.

The total number of xor of the encoding is thus defined by the generator matrix which must be as sparse as possible. First, we use a $k\times(k+m)$-systematic generator matrix built from a $k\times k$-identity matrix concatenated to a $k\times m$ Generalized Cauchy (GC) matrix [10]. A GC matrix generates a systematic MDS code and it contains only $1$ on its first row and on its first column. Then, to improve the sparsity of the generator matrix in the ring, we use the Sparse transform $\phi_{S}$. This has to be done only once since the ring matrix is the same for all the codewords.

For the information vectors, it is not efficient to use $\phi_{S}$ since the xors of machine words do not take into account the sparsity of the xor-ed vectors. We thus use Embedding or Parity transforms, which are less complex than $\phi_{1}$.

When Embedding is used for information vectors and Sparse is used for the generator matrix, the obtained result in the ring can be sent into the field by using $\phi_{1}^{-1}$ (proof similar to the proofs of Propositions 4 or 5).

When Parity is used for the information vector, the image of the vector in the ring only contains elements of the ideal $A_{1}$. Since these elements are multiplied by the generator matrix (in the ring), the obtained result only contains elements of the ideal $A_{1}$. These elements have even weight, so it is not necessary to keep the parity bit before sending them on the ”erasure channel”. Since Parity transform is not an isomorphism, these data can not be decoded by another method. Indeed, to decode, it is necessary to apply $\phi_{P}$ (add the parity bit), then to decode by multiplying by the inverse matrix, and then to to apply $\phi_{P}^{-1}$ (remove the parity bit on the correct information vector).

V Complexity analysis

In this section, we determine the total number of xor operations done in the coding and the decoding processes.

V-A Coding complexity

The coding process is composed of three phases: the field to ring transform, the matrix vector multiplication and the ring to field transform. We assume that the information vector is a vector of $k$ elements of the field $\mathbb{F}_{2^{w}}$.

For the first and the third phases, Table I gives the complexities of Embedding and Parity transforms obtained from their definition in Section III.

The choice between the two methods thus depends on the values of the parameters: if $k>m$, Parity transform has lower complexity. Else, ”Embedding” complexity is better.

For the matrix vector operation, let us first consider the multiplication of two ring elements. As explained in the previous section, the first element (which corresponds to an information symbol) is managed by the software implementation by machine words. So the complexity of the multiplication only depends on the weight of the second element, denoted by $w_{2}\in\{0,1,\ldots,w+1\}$. The complexity of this multiplication is thus $(w+1).w_{2}$.

Now, we can consider the specificities of the various transforms. In the Parity transform, the last bit of the parity blocks is not used ( i.e. it is not transmitted on the erasure channel). So it is not necessary to compute it. It follows that the complexity of the multiplication is only $w.w_{2}$.

Similarly, for the Embedding transform, the last bit of the input vector is always equal to [math]. So, we also have a complexity equal to $w.w_{2}$.

To have an average number of operations done in the multiplication of the generator matrix by the input data blocks, we have to evaluate the average weight of the entries of the generator matrix in the ring.

The generator matrix is a $k\times m$-GC matrix with the first column and the first row are filled by $1$. The other elements can be considered as random non zero elements. They are generated by $\phi_{S}$ which chooses the lowest ring element among the two ones corresponding to the field element. Let us denote their average weight by $w_{\phi_{S}}$. For this case, the average number of xors is thus:

[TABLE]

This leads to the following general expression of the coding complexity:

[TABLE]

To estimate the complexity on a practical example, we fix the value of $w$ to $4$. Classic combinatorial evaluation (not presented here) gives the average weight for nonzeros images of $\phi_{S}$:

[TABLE]

So, $w_{\phi_{S}}=1.66$. We plot in Figure 1 the evolution of the factor over optimal (used e.g. in [2], table III) which is the density of the matrix normalized by the minimal density, $k.m.w$. We vary the value of $k$ for three values of $m$: $3$, $5$ and $7$. For each pair $(k,m)$, we generate 10000 random GC matrices and keep the best we found.

We can observe that the values are very low. For example, [2] gives the lowest density of Cauchy matrices for the field $\mathbb{F}_{2^{4}}$ and we can observe that our values are always lower than these ones.

To reduce the complexity in specific cases, we can observe that the ring contains $w$ elements whose the corresponding matrix is optimal (one diagonal). By using these elements, we can search by brute force MDS matrices built only with these optimal elements. For example, let us consider the elements of the field $\mathbb{F}_{2^{4}}$ sent into the ring $R_{2,5}$. The Vandermonde matrix defined by:

[TABLE]

where $x$ is a monomial in $R_{2,5}$ has the minimal number of $1$. It can be verified that this matrix can be used to build a systematic a MDS code. For this matrix, the total number of xors done in the generation of the parity packets (including the field-to-ring and ring-to-field transforms) is

[TABLE]

Its factor over optimal is equal to $1.2$ which is lower than the values given in Figure 1 and which is close to the lowest bound given in [3].

V-B Decoding complexity

As the decoding is a matrix inversion and a matrix vector multiplication, we can use the same approach to perform the multiplication. We first invert the sub-matrix in the field, then we transform each entry of this matrix into ring elements. Then, we perform the ring multiplication.

The complexity of the decoding thus depends on the complexity of the matrix inversion and on the complexity of the matrix vector multiplication.

The complexity of the matrix vector multiplication was studied in the previous paragraph.

The complexity of the a $r\times r$-matrix inversion is generally in $O(r^{3})$ operations in the field. But if the matrix has a Cauchy structure, this complexity can be reduced to $O(r^{2})$ [1].

Note that, contrarily to the matrix vector multiplication, the matrix inversion complexity does not depend on the size of the source and parity blocks. And thus, it becomes negligible when the size of the blocks increase.

VI Scheduling

An interesting optimization on MDS erasure codes under xor-based representation is the scheduling of xor operations.

Such techniques are proposed in [11], [12], [2] and [13]. The general principle consists in ”factorizing” some xor operations which are done several times to generate the parity blocks.

We show in the two next paragraphs that these techniques can be used very efficiently on the ring elements.

However, it can be observed that the matrices defined over rings have two main advantages.

VI-A Complexity reduction

Over finite fields, the scheduling consists in searching common patterns on the binary representation of the generator matrices. The $w\times w$-matrices representing the multiplication by the field elements does not have particular structure and thus, they must be entirely considered in the scheduling algorithm.

This is not the case for the $(w+1)\times(w+1)$-matrices corresponding to a ring element because, thanks to the form of the polynomial $x^{w+1}+1$, they are composed of diagonals either full of [math] or $1$. This means that they can be represented in the scheduling algorithm just by their first column or, equivalently, by the ring polynomial.

This allows to drastically reduce the algorithm complexity and thus to handle bigger matrices. From a polynomial point of view, the search of scheduling just consist in finding some common patterns in the equations generating the parity blocks.

Example .

Let us assume that $n=5$ and that three data polynomials $a_{0}(x),\ a_{1}(x)$ and $a_{2}(x)$ are combined to generate the three parities $p_{0}(x)=(1+x^{4})a_{0}(x)+x^{2}a_{1}(x)+x^{3}a_{2}(x)$, $p_{1}(x)=a_{0}(x)+x^{3}a_{1}(x)+(1+x^{3})a_{2}(x)$ and $p_{2}(x)=a_{0}(x)+a_{1}(x)+x^{3}a_{2}(x)$.

In this case, the scheduling just consists in computing $p^{\prime}(x)=a_{0}(x)+x^{3}a_{2}(x)$ and then $p_{0}(x)=p^{\prime}(x)+x^{4}a_{0}(x)+x^{2}a_{1}(x)$, $p_{1}(x)=p^{\prime}(x)+x^{3}a_{1}(x)+a_{2}(x)$ and $p_{2}=p^{\prime}(x)+a_{2}(x)$.

To estimate the complexity, we can consider the number of sums of polynomials. Without scheduling, we need $11$ sums ($4$ for $p_{0}(x)$, $4$ for $p_{1}(x)$, and $3$ for $p_{2}(x)$) instead of with scheduling, we only need 10 sums ($2$ for $p^{\prime}(x)$, $3$ for $p_{0}(x)$, $3$ for $p_{1}(x)$ and $2$ for $p_{2}(x)$). ∎

VI-B Additional patterns

Ring-based matrices allow to find more common patterns than field-based matrices. The main idea is to observe that, in the ring, we can ”factorize” not only common operations, but also operations which are multiple by a monomial (i. e. cyclic-shift) of operations done in some other equations. This is possible only because the multiplications are done modulo $x^{w+1}+1$.

Example .

Let us assume that $n=5$ and that three data polynomials $a_{0}(x),\ a_{1}(x)$ and $a_{2}(x)$ are combined to generate the parities $p_{0}(x)=a_{0}(x)+x^{2}a_{1}(x)+(1+x^{2})a_{2}(x)$, $p_{1}(x)=x^{2}a_{0}(x)+x^{3}a_{1}(x)+(x+x^{4})a_{2}(x)$ and $p_{2}(x)=x^{2}a_{0}(x)+a_{1}(x)+(x^{2}+x^{3})a_{2}(x)$. We can observe that, with a ”simple” scheduling, it is not possible to factorize some operations.

However, by rewriting the polynomials, we can reveal factorizations: $p_{1}(x)=x^{2}a_{0}(x)+x(x^{2}a_{1}(x)+a_{2}(x))+x^{4}a_{2}(x)$ and $p_{2}(x)=x^{2}a_{0}(x)+x^{3}(x^{2}a_{1}(x)+a_{2}(x))+x^{2}a_{2}(x)$. So, if $p^{\prime}(x)=x^{2}a_{1}(x)+a_{2}(x)$, we have $p_{0}(x)=p^{\prime}(x)+a_{0}(x)+x^{2}a_{2}(x)$, $p_{1}(x)=xp^{\prime}(x)+x^{2}a_{0}(x)+x^{2}a_{2}(x)$ and $p_{2}(x)=x^{3}p^{\prime}(x)+x^{2}a_{0}(x)+x^{2}a_{2}(x)$.

To estimate the complexity by the same method than in the previous example, we need $11$ polynomial additions with scheduling compared to $12$ additions necessary without scheduling. ∎

VI-C Scheduling results

To evaluate the potential gain of the scheduling, we have implemented an exhaustive search of the best patterns on generator matrices.

This algorithm was applied on several codes for the field $\mathbb{F}_{2^{4}}$. Table II presents the results in term of ”factor over optimal” which is defined as the total number of 1 in the matrix over the number of 1 for the optimal MDS matrix , i.e $k.m.w$.

When working in a ring, we include to the complexity the operations needed to apply the transforms. In this case, Embedding transform has a lower complexity. So we added $m.w$ to the number of 1 in the matrix resulting from the scheduling algorithm.

For each case, we have generated $100$ random Generalized Cauchy matrices.

The measured parameters are:

• •

average field matrix: average number of $1$ in the GC matrices divided by $k.m.w$

• •

best field matrix: lowest number of $1$ among the GC matrices divided by $k.m.w$

• •

average ring matrix: average number of $1$ in the ring matrices (without scheduling) + ring-field correspondence divided by $k.m.w$

• •

best ring matrix: best number of $1$ among the ring matrices (without scheduling) + ring-field correspondence divided by $k.m.w$

• •

average with scheduling: average number of xors with scheduling + ring-field correspondence divided by $k.m.w$

• •

best with scheduling: best number of xors with scheduling + ring-field correspondence divided by $k.m.w$

This table confirms that, even without scheduling, ring matrices have a lower density than field matrices, thanks to the Sparse transform. Applying scheduling to these matrices allows a significant gain of complexity. Indeed, it reduces the complexity by more than $20\%$ on the best matrices. The final results are similar to the results obtained (without scheduling) on the optimal matrix in Section V-A. To the best of our knowledge, other scheduling approaches do not reach this level of sparsity for these parameters.

VII Conclusion

In this paper, we have presented a new method to build MDS erasure codes with low complexity. By using transforms between a finite field and a polynomial ring, sparse generator matrices can be obtained. This allows to significantly reduce the complexity of the matrix vector multiplication. It also allows simple schedulers that drastically improve the complexity by reducing the number of operations.

Similar results can be obtained with Equally-Spaced Polynomials (ESP) [5], but they are not presented here due to lack of space.