Service Rate Region of Content Access from Erasure Coded Storage

TL;DR

This paper characterizes the service rate region for content access in erasure coded storage systems with systematic and coded nodes, providing a specific analysis for three files and a general algorithm for K files.

Contribution

It determines the request rate region for a 3-file coded storage system and introduces an algorithm to optimize request rates in a general K-file system.

Findings

Derived the request rate region for a 3-file system.

Provided an algorithm to maximize request rates for a specific file in K-file systems.

Enhanced understanding of content access capabilities in erasure coded storage.

Abstract

We consider storage systems in which $K$ files are stored over $N$ nodes. A node may be systematic for a particular file in the sense that access to it gives access to the file. Alternatively, a node may be coded, meaning that it gives access to a particular file only when combined with other nodes (which may be coded or systematic). Requests for file $f_k$ arrive at rate $\lambda_k$, and we are interested in the rate that can be served by a particular system. In this paper, we determine the set of request arrival rates for the a $3$-file coded storage system. We also provide an algorithm to maximize the rate of requests served for file $K$ given $\lambda_1,\dots, \lambda_{K-1}$ in a general $K$-file case.

Equations

$${\delta }_k(i,j):=\{\begin{array}{ll}1,& \text{if node j is in the fk–repair group Rki},\\ 0,& \text{else}.\end{array}$$

$$\sum _{i\in [{\gamma }_k]}{\alpha }_{ki}=1.$$

$$\sum _{k\in [K]}\sum _{i\in [{\gamma }_k]}{\alpha }_{ik}{\delta }_k(i,j){\lambda }_k.$$

$$\sum _{k\in [K]}\sum _{i\in [{\gamma }_k]}{\alpha }_{ki}{\delta }_k(i,j){\lambda }_k\le {\mu }_j,\text{for all }j\in [N].$$

$$\mathcal{S}=\{{\mathbf{\lambda }}_{\hat{K}}\times [0,L({\mathbf{\lambda }}_{\hat{K}})]:({\lambda }_1,\dots ,{\lambda }_{K-1},0)\in \mathcal{S}\}.$$

$${\lambda }_K=L({\lambda }_1,\dots ,{\lambda }_{K-1})=\frac{C}{K}\mu -\sum _{i=1}^{K-1}{\lambda }_i.$$

$$D:=r_1+r_2+\frac{(N_1\mu -r_1)+(N_2\mu -r_2)+C\mu }{3}+N_3\mu .$$

$$\{\begin{array}{ll}(\frac{C}{3}+\frac{N_1}{3}+\frac{N_2}{3}+N_3)\mu -\frac{{\lambda }_1}{3}-\frac{{\lambda }_2}{3},& 0\le \frac{{\lambda }_i}{\mu }\le N_i,i=1,2\\ (\frac{C}{3}+N_1+\frac{N_2}{3}+N_3)\mu -{\lambda }_1-\frac{{\lambda }_2}{3},& N_1<\frac{{\lambda }_1}{\mu }\le N_1+N_2+\frac{C}{3},\\ & 0\le \frac{{\lambda }_2}{\mu }\le N_2\\ (\frac{C}{3}+\frac{N_1}{3}+N_2+N_3)\mu -\frac{{\lambda }_1}{3}-{\lambda }_2,& 0\le \frac{{\lambda }_1}{\mu }\le N_1,\\ & N_2<\frac{{\lambda }_2}{\mu }\le N_1+N_2+\frac{C}{3}\\ (\frac{C}{3}+N_1+N_2+N_3)\mu -{\lambda }_1-{\lambda }_2,& N_1<\frac{{\lambda }_1}{\mu }\le N_1+N_2+\frac{C}{3},\\ & N_2<\frac{{\lambda }_2}{\mu }\le N_1+N_2+\frac{C}{3}\end{array}$$

$${\mu }_{\sigma (1)}^{\prime }{N}_{\sigma (1)}^{\prime }=\mu \left(N_{\sigma (1)}-\frac{{\lambda }_{\sigma (1)}}{\mu }\right)$$

$${\mu }_{\sigma (2)}^{\prime \prime }{N}_{\sigma (2)}^{\prime }=\mu \left(\left(N_{\sigma (2)}-\frac{{\lambda }_{\sigma (2)}}{\mu }\right)-\left(N_{\sigma (1)}-\frac{{\lambda }_{\sigma (1)}}{\mu }\right)\right)$$

$$=$$

$$L({\lambda }_1,{\lambda }_2)$$

$$=\frac{C}{3}\mu -({\lambda }_1-\mu N_1+{\lambda }_2-\mu N_2)+\mu N_3.\text{vspace}\ast -3ex$$

$${\mu }_j-\frac{{\mu }_m\left({\prod }_{\{i=1|N_i>0\text{ and }i\ne j\}}^{K-1}{N}_i\right)\left(\genfrac{}{}{0ex}{}{C}{K-K^{\prime }}\right)}{\left({\prod }_{\{i=1|N_i>0\text{ and }i\ne m\}}^{K-1}{N}_i\right)\left(\genfrac{}{}{0ex}{}{C}{K-K^{\prime }}\right)},$$

$${\mu }_C-\frac{{\mu }_m\left({\prod }_{\{i=1|N_i>0\}}^{K-1}{N}_i\right)\left(\genfrac{}{}{0ex}{}{C-1}{K-K^{\prime }-1}\right)}{\left({\prod }_{\{i=1|N_i>0\text{ and }i\ne m\}}^{K-1}{N}_i\right)\left(\genfrac{}{}{0ex}{}{C}{K-K^{\prime }}\right)},$$

Full text

††publicationid: pubid: ©2018 IEEE

I Introduction

The explosive growth in the amount of data stored in the cloud calls for new techniques to make cloud infrastructure fast, reliable, and efficient. Moreover, applications that access this data from the cloud are becoming increasingly interactive. Thus, in addition to providing reliability against node failures, service providers must be able to serve a large number of users simultaneously.

Content files are typically replicated at multiple nodes to cope with node failures. These replicas can also be used to serve a larger volume of users. To adapt to changes in popularity of content files, service providers can increase or decrease the number of replicates for each file, a strategy that has been widely used in content delivery networks [1]. The use of erasure coding, instead of replication, to improve the availability of content is not yet fully understood. Using erasure codes has been shown to be effective in reducing the delay in accessing a file stored on multiple servers [2, 3, 4]. However, only a few works have studied their use to store multiple files. Some recent works [5] have proposed new classes of erasure codes to store multiple files that allow a file to be read from from disjoint sets of nodes. Other works [6, 7] study the delay reduction achieved using these codes.

Besides download latency, it has recently been recognized that another important metric for the availability of stored data is the service rate [8, 9, 10]. Maximizing the service rate (or the throughput) of a distributed system helps support a large number of simultaneous system users. Rate-optimal strategies are also latency-optimal in high traffic. Thus, maximizing the service rate also reduces the latency experienced by users, particularly in highly contending scenarios.

This paper is one of the first to analyze the service rate region of a coded storage system. We consider distributed storage systems in which data for $\small K$ files is to be stored across $\small N$ nodes. A request for one of the files can be either sent to a systematic node or to one of the repair groups. We seek to maximize such systems’ service rate region, that is, the set of request arrival rates for the $\small K$ files that can be supported by a coded storage system.

The problem addressed in this paper should not be confused with the related problem of caching and pre-fetching of popular content at edge devices [11]. Caching benefits for the network are measured in reduction in the backhaul traffic it enables. Quality of service to the user measures include cache hit ratio and cache hit distance. Rather than with the backhaul, this paper is concerned with the access part of the network, namely, with potential service rate increase through work provided, jointly and possibly redundantly, by multiple network edge devices. Consequently, instead of measuring e.g., content download performance by the likelihood of an individual cache hit or cache memory and bandwidth usage, we strive to ensure that multiple caches are jointly in possession of content and can deliver it fast to multiple simultaneous users.

In [9], the achievable service rate region was found for some common classes of codes, such as maximum-distance-separable (MDS) codes and simplex codes. That paper also determined the service rate region when $\small K=2$, with arbitrary numbers of systematic and coded nodes. We generalize this service rate region result from $\small K=2$ files to $\small K=3$ files and provide an algorithm to maximize the requests served for a given file with general $\small K$. The paper begins with preliminary notions given in Sec. II. Sec. III addresses the general $\small K$ case where all nodes are coded, and Sec. IV addresses the $\small K=3$ case. We return to the general case in Sec. V.

II Preliminaries

Suppose files $\small f_{1},\ldots,f_{K}$ are stored across a system that consists of $\small N$ nodes labeled $\small 1,\ldots,N$. For $\small k\in[K]:=\left\{1,\dots,K\right\}$, there is a collection of minimal sets $\small R_{k1},\dots,R_{k\gamma_{k}}\subseteq[N]$ that each correspond to a set of nodes that gives access to file $\small f_{k}$. Each such minimal set of nodes is called an $\small f_{k}$–repair group.

Example 1**.**

Fig. 1 shows one possible way to store two files, $\small a$ and $\small b$, across four nodes. In this system, the $\small a$-repair groups are $\small\{1\},\{2\}$, and $\small\{3,4\}$. The $\small b$-repair groups are $\small\{4\},\{1,3\},$ and $\small\{2,3\}$.

For $\small(i,j)\in[\gamma_{k}]\times[N]$, define the function

[TABLE]

Suppose that when a request for file $\small f_{k}$ is received, that request is sent at random to an $\small f_{k}$–repair group according to a splitting strategy with $\small\alpha_{ki}\geq 0$ denoting the fraction of requests sent to repair group $\small R_{ki}$, so that for each $\small k\in[K]$,

[TABLE]

Let the demand for file $\small f_{k}$ be $\small\lambda_{k}$, so the arrival of requests for file $\small f_{k}$ to the storage system queue is Poisson with rate $\small\lambda_{k}$, and let $\small\boldsymbol{\lambda}=(\lambda_{1},\ldots,\lambda_{K})$ record the demand for files $\small f_{1},\ldots,f_{K}$.

The average rate that file requests arrive at a storage system node depends both on the splitting strategy for file requests and on the demand $\small\boldsymbol{\lambda}$. More precisely, the average rate that file requests are received at node $\small j\in[N]$ is

[TABLE]

Let $\small\mu_{j}$ denote the average rate of resolving received file requests at node $\small j$. Whenever demand is such that at least one node $\small j$ of the storage system receives requests at an average rate in excess of its $\small\mu_{j}$, the storage system queue will have a tendency to grow. With this in mind, it is appropriate to call $\small\mu_{j}$ the service rate of node $\small j$. We will consider uniform systems for which $\small\mu_{j}=1$ for $\small j=1,\dots,N$. If, at demand $\small\boldsymbol{\lambda}$, there exists a splitting strategy under which no storage system node receives requests at a rate in excess of its service rate, then $\small\boldsymbol{\lambda}$ is said to be in the achievable service rate region of the storage system. More formally, the storage system’s achievable service rate region $\small\mathcal{S}$ is the set of all $\small\boldsymbol{\lambda}\in\mathbb{R}^{K}_{\geq 0}$ such that there exists a splitting strategy with

[TABLE]

For any $\small\boldsymbol{\lambda}=(\lambda_{1},\dots,\lambda_{K})\in\mathbb{R}^{K}_{\geq 0}$, denote by $\small\boldsymbol{\lambda}_{\widehat{k}}$ the $\small(K-1)$-tuple $\small(\lambda_{1},\ldots,\lambda_{k-1},\lambda_{k+1},\ldots\lambda_{K})$, and for $\small x\in\mathbb{R}_{\geq 0}$ let $\small\boldsymbol{\lambda}_{\widehat{k}}\times\{x\}:=(\lambda_{1},\ldots,\lambda_{k-1},x,\lambda_{k+1},\ldots\lambda_{K}$). If $\small\boldsymbol{\lambda}\in\mathcal{S}$, then the same splitting strategy whose existence is guaranteed by (4) is also sufficient to give $\small\boldsymbol{\lambda}^{\prime}\in\mathcal{S}$ for every $\small\boldsymbol{\lambda}^{\prime}$ satisfying for all $\small k\in[K]$, $\small\lambda^{\prime}_{k}\leq\lambda_{k}$. Thus, given any pair $\small\boldsymbol{\lambda}_{\widehat{k}}\times\{0\}\in\mathcal{S}$ and $\small\boldsymbol{\lambda}_{\widehat{k}}\times\{\lambda_{k}\}\in\mathcal{S}$, the entire interval $\small\boldsymbol{\lambda}_{\widehat{k}}\times[0,\lambda_{k}]$ is in $\small\mathcal{S}$. Moreover, for any storage system (regardless of its coding), if $\small\boldsymbol{\lambda}$ is such that the demand for any file $\small f_{k}$ is in excess of $\small N\cdot\max_{j\in[N]}\{\mu_{j}\}$, then under all possible assignment strategies (4) is violated for at least one node $\small j$, and so $\small\boldsymbol{\lambda}_{\widehat{k}}\times\{x\}$ is not in $\small\mathcal{S}$ for any $\small x>N\cdot{\max_{j\in[N]}\{\mu_{j}\}}$ and $\small\boldsymbol{\lambda}_{\widehat{k}}\in\mathbb{R}^{K-1}_{\geq 0}$. In this way, $\small\mathcal{S}$ is a non-empty, closed, and bounded subset of $\small\mathbb{R}^{K}_{\geq 0}$. Therefore, given any $\small\boldsymbol{\lambda}_{\widehat{k}}\times\{0\}\in\mathcal{S}$, there exists a maximal value of $\small\lambda_{k}$ such that $\small\boldsymbol{\lambda}_{\widehat{k}}\times[0,\lambda_{k}]\subset\mathcal{S}$ and $\small\boldsymbol{\lambda}_{\widehat{k}}\times\{\lambda_{k}^{\prime}\}\not\in\mathcal{S}$ for any $\small\lambda_{k}^{\prime}>\lambda_{k}$. When $\small k=K$, we call this maximal value $\small L(\boldsymbol{\lambda}_{\widehat{K}})$. In this notation, the service rate region of any storage system can be described as:

[TABLE]

Example 2**.**

Three examples of how two files, $\small a$ and $\small b$ may be stored across three nodes are shown on the below on the left. The resulting service service rate regions for each system are shown below on the right.

\small a$$\small b$$\small b$$\small a$$\small a+b$$\small b$$\small a$$\small a$$\small b

\small\lambda_{a}$$\small\lambda_{b}$$\small 0$$\small\mu$$\small 2\mu$$\small\mu$$\small 2\mu

Coding schemes that use a mixture of replication and MDS coding are not conventional. However, if the service rate region is used as a performance metric, then a combination of coded and systematic nodes has been shown to be beneficial [6, 9]. In this paper, we consider storage systems for $\small K$ files whose coded nodes satisfy the following three conditions:

Each $\small K$–subset of coded nodes forms an $\small f_{k}$–repair group for every $\small k\in[K]$. 2. 2.

No subset of $\small k<K$ coded nodes forms an $\small f_{k}$–repair group, for any $\small k\in[K]$. 3. 3.

With addition of systematic nodes for any $\small n$ distinct files (naturally, $\small n<K$) every $\small(K-n)$–subset of coded nodes from the core completes these systematic nodes to form an $\small f_{k}$–repair group for every $\small k\in[K]$.

We say that such a system has an MDS core. We consider situations with uniform node capacities $\small\mu=\mu_{1}=\cdots=\mu_{N}$.

For convenience, we use $\small C$ to denote the number of coded nodes in such a core. When systematic nodes are also present, we use $\small N_{k}$ to denote the number of systematic nodes for file $\small f_{k}$. In this way, the total number of nodes in a storage system for $\small K$ files that has an MDS core is $\small N=C+\sum_{k=1}^{K}N_{k}$.

III All coded nodes

We begin by considering an MDS $\small K$-file core where there are no systematic nodes in the system. In this situation, all nodes form a repair group for each file, and $\small K$ nodes are required to recover any file.

Theorem 1**.**

Assume $\small N_{1}=\cdots=N_{K}=0$. If there are $\small C>K-1$ coded nodes, then the achievable service rate region $\small\mathcal{S}$ is the set of all $\small\boldsymbol{\lambda}$ with $\small\sum_{i=1}^{K}\lambda_{i}\leq\frac{C}{K}\mu$, and so $\small L(\lambda_{1},\ldots,\lambda_{K-1})=\frac{C}{K}\mu-\sum_{i=1}^{K-1}\lambda_{i}$. If there are $\small C\leq K-1$ coded nodes, then $\small\mathcal{S}$ is the point $\small(0,\ldots,0).$

Proof.

If $\small C\leq K-1$, then no file can be recovered and the service rate region is the point $\small(0,\ldots,0)$.

Assume $\small C>K-1$. Note that since every repair group requires $\small K$ nodes, the total demand that can be served is bounded above by $\small\frac{C\mu}{K}$. For each file, there are a total of $\small\binom{C}{K}$ repair groups, and each node is in $\small\binom{C-1}{K-1}$ repair groups. By sending demand $\small\frac{\mu}{\binom{C-1}{K-1}}$ to each repair group, requests to each node occur at the service rate and the system can serve demand $\small\frac{\binom{C}{K}}{\binom{C-1}{K-1}}\mu=\frac{C}{K}\mu$ . Since this demand can be for any file, the service rate region is $\small\sum_{i=1}^{K}\lambda_{i}\leq\frac{C}{K}\mu$. Therefore, the maximum achievable $\small\lambda_{K}$ is

[TABLE]

∎

The two file case is considered in [9]. The situation becomes increasingly complex depending on the number of files $\small K$ in the system. In the next section, we consider $\small K=3$.

IV Three files

In this section, we consider the service rate region of storage systems for $\small 3$ files with MDS cores. As a corollary to Theorem 1, we obtain the service rate region for the case when there are no systematic nodes, which is represented in Fig. 2. Note that when the demand for one file is zero, then this may be considered a system with only two files. For example, if $\small\lambda_{3}=0$, then the maximum achievable $\small\lambda_{2}$ is $\small\lambda_{2}=\frac{C}{3}\mu-\lambda_{1}$, which is the region shaded in Fig. 2.

We now consider storage systems that have both coded nodes and systematic nodes. Suppose that a coded storage system has $\small C$ coded nodes and $\small N_{i}$ systematic file $\small f_{i}$ nodes, $\small i=1,2,3$. Note that a systematic repair node may be in a repair group with a single node (serving requests for the file it stores) or three nodes (serving requests for any other file). Any repair group using a coded node contains three nodes. For $\small i=1,2$, if $\small r_{i}\leq N_{i}\mu$ requests for file $\small f_{i}$ are served using systematic $\small f_{i}$ nodes (and any other demand for file $\small f_{i}$ is served using a repair group of three nodes), then the total demand that can be served is bounded above by

[TABLE]

Given demand $\small\lambda_{1}$ for file $\small f_{1}$ and $\small\lambda_{2}$ for file $\small f_{2}$, the rate of requests that may be served for file $\small f_{3}$ is bounded above by $\small\max\{D-\lambda_{1}-\lambda_{2},0\}.$ This is maximized when $\small r_{i}=\min\{\lambda_{i},N_{i}\mu\}$ for $\small i=1,2$. The splitting strategy in the proof of the following theorem meets this bound.

Theorem 2**.**

Assume there are $\small N_{1}$, $\small N_{2}$, and $\small N_{3}$ systematic nodes for files $\small f_{1}$, $\small f_{2}$, and $\small f_{3}$, respectively, and $\small C$ coded nodes. Assume $\small\lambda_{1}+\lambda_{2}\leq\mu N_{1}+\mu N_{2}+\frac{C}{3}\mu$ and $\small C\geq\max\left(3,N_{1}-\frac{\lambda_{1}}{\mu},N_{2}-\frac{\lambda_{2}}{\mu}\right)$. Then $\small\mathcal{S}$ has $\small L(\lambda_{1},\lambda_{2})=$

[TABLE]

Proof.

Consider a system with $\small N_{1}$, $\small N_{2}$, and $\small N_{3}$ systematic nodes for files $\small f_{1}$, $\small f_{2}$, and $\small f_{3}$ and $\small C$ coded nodes.

Step 1: Send requests to systematic nodes at the service rate to serve demand for files $\small f_{1}$ and $\small f_{2}$, as possible. If any $\small f_{i}$ ($\small i=1,2$) systematic nodes remain available, distribute remaining file $\small f_{i}$ demand uniformly across those nodes.

Example 3**.**

Consider a $\small 3$-file system with $\small N_{1}=3$, $\small N_{2}=1$, $\small N_{3}=1$, and $\small C=3$.

\small f_{1}$$\small f_{1}$$\small f_{1}$$\small f_{2}$$\small f_{3}$$\small c$$\small c$$\small c

If $\small\lambda_{1}=\frac{3}{2}\mu$ and $\small\lambda_{2}=2\mu$ then $\small\mu$ requests for $\small f_{1}$ will be served by one of the $\small f_{1}$ systematic nodes, and the remaining $\small\frac{1}{2}\mu$ requests for $\small f_{1}$ will be split between the other $\small 2$ systematic nodes. Also, $\small\mu$ requests for $\small f_{2}$ will be served by the $\small f_{2}$ systematic node. After Step 1, the remaining demand for $\small f_{1}$ is $\small 0$ and the remaining demand for file $\small f_{2}$ is $\small\mu$. In the system, there are now two systematic $\small f_{1}$ nodes that can handle an additional $\small\frac{3}{4}\mu$ requests as well as one systematic $\small f_{3}$ node and three coded nodes each with available service rate $\small\mu$.

\small f_{1}$$\small f_{1}$$\small f_{1}$$\small f_{2}$$\small f_{3}$$\small c$$\small c$$\small c

At the end of Step 1, if $\small\lambda_{i}\leq\mu N_{i}$ for $\small i=1$ or $\small 2$, then there will be $\small N_{i}^{\prime}=N_{i}-\lfloor\frac{\lambda_{i}}{\mu}\rfloor$ systematic nodes remaining available for $\small f_{i}$, each with service rate reduced to $\small\mu_{i}^{\prime}=\mu-\frac{\lambda_{i}-\lfloor\frac{\lambda_{i}}{\mu}\rfloor\cdot\mu}{N_{i}^{\prime}}$. Since $\small\lambda_{i}\leq\mu N_{i}$, the remaining demand for file $\small f_{i}$ is $\small\lambda_{i}^{\prime}=0$.

If $\small\lambda_{i}\geq\mu N_{i}$ for $\small i=1$ or $\small 2$, we exhaust every $\small f_{i}$ systematic node. The remaining demand for file $\small f_{i}$ is then $\small\lambda_{i}^{\prime}=\lambda_{i}-\mu N_{i}$, and $\small N_{i}^{\prime}=0$ systematic $\small f_{i}$ nodes remain.

Step 2: Serve any remaining demand for files $\small f_{1}$ and $\small f_{2}$. Finally, serve demand for file $\small f_{3}$.

Example 4**.**

Consider the system in Example 3. In Step 2 we want to serve the remaining requests for file $\small f_{2}$ in a way that maximizes the requests that can be handled for $\small f_{3}$. In particular, we will reserve the use of systematic $\small f_{3}$ nodes for accessing file $\small f_{3}$. Note that there are $\small 2\cdot\binom{3}{2}=6$ repair groups for file $\small f_{2}$ that involve one systematic $\small f_{1}$ node and two coded nodes. If we send $\small\frac{\mu}{6}$ requests for file $\small f_{2}$ to each of these repair groups, then all the requests for file $\small f_{2}$ are served, each $\small f_{1}$ systematic node can serve $\small\frac{\mu}{4}$ more requests (as each $\small f_{1}$ node is in $\small 3$ repair groups) and each coded node can serve $\small\frac{\mu}{3}$ more requests (as each coded node is in $\small 4$ repair groups).

\small f_{1}$$\small f_{1}$$\small f_{1}$$\small f_{2}$$\small f_{3}$$\small c$$\small c$$\small c

Finally, requests for $\small f_{3}$ may be served. Sending $\small\frac{\mu}{12}$ requests to each of the $\small 6$ repair groups with one $\small f_{1}$ node and two coded nodes exhausts each $\small f_{1}$ node and each coded node. The full service rate of the systematic $\small f_{3}$ node may also be used to serve requests for $\small f_{3}$. Thus a total of $\small 6\cdot\frac{\mu}{12}+\mu=\frac{3}{2}\mu$ requests for $\small f_{3}$ may be served.

\small f_{1}$$\small f_{1}$$\small f_{1}$$\small f_{2}$$\small f_{3}$$\small c$$\small c$$\small c

How requests are served in Step 2 depends on the demand and number of systematic nodes for files $\small f_{1}$ and $\small f_{2}$. Let $\small\lambda$ be the total demand for files $\small f_{1}$ and $\small f_{2}$ that remains after Step 1; that is, $\small\lambda=\lambda_{1}^{\prime}+\lambda_{2}^{\prime}$.

Case 1 ($\small 0\leq\lambda_{1}\leq\mu N_{1}$, $\small 0\leq\lambda_{2}\leq\mu N_{2}$): In this case, $\small\lambda=0$, so all available system resources may be used to serve $\small f_{3}$ demand. The full service rate of file $\small f_{3}$ systematic nodes may be used, serving demand $\small\mu N_{3}$ for file $\small f_{3}$. Let $\small\sigma$ be a permutation on $\small\{1,2\}$ such that $\small\frac{\mu_{\sigma(1)}^{\prime}}{N_{\sigma(2)}^{\prime}}\leq\frac{\mu_{\sigma(2)}^{\prime}}{N_{\sigma(1)}^{\prime}}$.

There are $\small N_{1}^{\prime}N_{2}^{\prime}C$ $\small f_{3}$–repair groups with a systematic node for each of $\small f_{1}$ and $\small f_{2}$, and one coded node. Recall, $\small C\geq\max\left(3,N_{1}-\frac{\lambda_{1}}{\mu},N_{2}-\frac{\lambda_{2}}{\mu}\right)$. Since $\small C\geq N_{\sigma(1)}-\frac{\lambda_{\sigma(1)}}{\mu}$,

[TABLE]

demand for $\small f_{3}$ can be served by sending $\small\frac{\mu_{\sigma(1)}^{\prime}}{N_{\sigma(2)}^{\prime}C}$ demand to each of these repair groups. The service rate of each $\small f_{\sigma(1)}$ is reduced to $\small 0$, while $\small f_{\sigma(2)}$ systematic nodes have $\small\mu_{\sigma(2)}^{\prime\prime}=\mu_{\sigma(2)}^{\prime}-\frac{\mu_{\sigma(1)}^{\prime}}{N_{\sigma(2)}^{\prime}C}N_{\sigma(1)}^{\prime}C=\mu_{\sigma(2)}^{\prime}-\frac{\mu_{\sigma(1)}^{\prime}}{N_{\sigma(2)}^{\prime}}N_{\sigma(1)}^{\prime}$, and coded nodes have $\small\mu^{\prime}_{C}=\mu-\frac{\mu_{\sigma(1)}^{\prime}}{N_{\sigma(2)}^{\prime}C}N_{\sigma(1)}^{\prime}N_{\sigma(2)}^{\prime}=\mu-\frac{\mu_{\sigma(1)}^{\prime}}{C}N_{\sigma(1)}^{\prime}$.

There are $\small N^{\prime}_{\sigma(2)}\binom{C}{2}$ $\small f_{3}$–repair groups with one of the remaining systematic file $\small f_{\sigma(2)}$ nodes and $\small 2$ coded nodes. Since $\small C\geq N_{\sigma(2)}-\frac{\lambda_{\sigma(2)}}{\mu}$, similarly to before, we can serve

[TABLE]

demand for file $\small f_{3}$ by sending demand equally to each of these $\small f_{3}$–repair groups. Each coded node has remaining service rate $\small\mu^{\prime\prime}_{C}=\mu^{\prime}_{C}-\frac{\mu^{\prime\prime}_{\sigma(2)}}{\binom{C}{2}}(C-1)N_{\sigma(2)}^{\prime},$ and no systematic $\small f_{1},f_{2}$ nodes remain available.

Since $\small C\geq 3$, as in the case in Theorem 1 with $\small C$ coded nodes and no systematic nodes, the service rate $\small\mu_{C}^{\prime\prime}$ of these coded nodes can be used to serve $\small\frac{C}{3}\mu^{\prime\prime}_{C}$ demand for file $\small f_{3}$.

Thus, the maximum achievable $\small\lambda_{3}$ is $\small L(\lambda_{1},\lambda_{2})$

[TABLE]

Similar arguments can be used for Case 2: $\small\mu N_{1}<\lambda_{1}\leq\mu N_{1}+\mu N_{2}+\frac{C}{3}\mu$, $\small 0\leq\lambda_{2}\leq\mu N_{2}$ and Case 3: $\small 0\leq\lambda_{1}\leq\mu N_{1}$, $\small\mu N_{2}<\lambda_{2}\leq\mu N_{1}+\mu N_{2}+\frac{C}{3}\mu$ (see Example 4).

Case 4 ($\small\mu N_{1}<\lambda_{1}\leq\mu N_{1}+\mu N_{2}+\frac{C}{3}\mu$, $\small\mu N_{2}<\lambda_{2}\leq\mu N_{1}+\mu N_{2}+\frac{C}{3}\mu$): In this case, all available repair groups consist entirely of coded nodes. Since demand $\small\mu N_{i}$ for file $\small f_{i}$ ($\small i=1,2$) was satisfied in Step 1, the remaining total demand for files $\small f_{1}$ and $\small f_{2}$ is $\small\lambda<\frac{C}{3}\mu$. Since $\small C\geq 3$, this can be served by sending demand equally to every coded repair group. The coded nodes’ remaining ability to service can be used for file $\small f_{3}$. Thus, the maximum achievable $\small\lambda_{3}$ is

[TABLE]

∎

Note that $\small L(\lambda_{1},\lambda_{2})$ can be found for systems with $\small C<3$ coded nodes in a similar way. When $\small C<3$, all repair groups must contain systematic nodes for at least $\small 3-C$ distinct files.

V MDS $\small K$-file cores

Theorem 2 may be generalized to provide an algorithm for maximizing $\small\lambda_{k}$ for the general $\small K$-file case. Assume we have an MDS $\small K$-file core with $\small N_{1},N_{2},\ldots,N_{K}$ systematic nodes for files $\small f_{1},f_{2},\ldots,f_{K}$, respectively, and $\small C$ coded nodes, with demand $\small\lambda_{1},\lambda_{2},\ldots,\lambda_{K-1}$ for files $\small f_{1},f_{2},\ldots,f_{K-1}$. As in Theorem 2, we again assume $\small\lambda_{1}+\ldots+\lambda_{K-1}\leq\mu N_{1}+\ldots+\mu N_{K-1}+\frac{C}{K}\mu$. Our goal is to identify the maximal file $\small f_{K}$ request rate that can be served.

We can first serve file $\small f_{1},f_{2},\ldots,f_{K-1}$ demand using their respective systematic nodes. This process is analogous to Step 1 in Theorem 2. Note, in this algorithm, the same demand is sent to every file $\small f_{i}$ systematic node, and also to every coded node, so we can let $\small\mu_{i}$ and $\small\mu_{C}$ represent the updated service rate of systematic file $\small f_{i}$ nodes and coded nodes, respectively.

We can then serve any remaining total demand $\small\lambda=\lambda_{1}+\ldots+\lambda_{K-1}$ using $\small K$-tuples of coded and systematic nodes. This is analogous to Step 2 in Theorem 2. Let $\small K^{\prime}:=\sum_{i=1}^{K-1}\operatorname{sgn}(N_{i})$ denote the number of files (excluding file $\small f_{K}$) for which the system contains systematic nodes. There are $\small\left(\prod_{\{i=1\;|\;N_{i}>0\}}^{K-1}N_{i}\right)\binom{C}{K-K^{\prime}}$ repair groups with $\small K^{\prime}$ systematic nodes and $\small K-K^{\prime}$ coded nodes. Letting $\small m$ be the index minimizing $\small N_{i}\mu_{i}$ for positive $\small N_{i}\mu_{i}$, we can serve demand $\small\mu_{m}N_{m}$ by sending $\small\frac{\mu_{m}}{\left(\prod_{\{i=1\;|\;N_{i}>0\text{ and }i\neq m\}}^{K-1}N_{i}\right)\binom{C}{K-K^{\prime}}}$ demand to each of these repair groups. This exhausts file $\small f_{m}$ systematic nodes, while file $\small f_{j}$ systematic nodes ($\small j\neq m$, $\small N_{j}>0$, $\small 1\leq j\leq K-1$) have reduced service rate

[TABLE]

which is $\small\mu_{j}-\frac{\mu_{m}N_{m}}{N_{j}}.$ The remaining coded nodes have reduced service rate

[TABLE]

which is $\small\mu_{j}-\frac{\mu_{m}(K-K^{\prime})}{C}.$ We can continue in this way until the systematic node service rate is met for all but file $\small f_{K}$. Then, we can use repair groups that consist entirely of coded nodes, applying Theorem 1. Once all demand for files $\small f_{1},\dots,f_{K-1}$ has been satisfied, we can follow a similar process to utilize any remaining system resources to serve demand for file $\small f_{K}$. Note, once the coded nodes have been exhausted, or if there are too few coded nodes to form a $\small K$-tuple, no demand may be satisfied using only coded nodes. We may then serve demand for file $\small f_{K}$ using systematic file $\small f_{K}$ nodes.

Acknowledgment

The initial stages of this work were performed at ICERM (Institute for Computational and Experimental Research in Mathematics) in Providence, RI. We are indebted to the organizers of the ICERM 2017 Women in Data Science and Mathematics Research Collaboration Workshop.