An Update Model for Network Coding in Cloud Storage Systems

Transcription

1 An Update Model for Network Coding in Cloud Storage Systems Mohammad Reza Zakerinasab, Mea Wang Department of Computer Science University of Calgary {mrzakeri, Abstract The fast emerging cloud services have received a tremendous amount of attention in both industry and academia. Storage services such as Dropbox and icloud enabled us to share files among multiple users or devices. Providing the benefits of network coding in distributed systems such as Peerto-Peer file sharing and multimedia streaming, researchers have also been trying to apply network coding in storage systems. Existing works have been focusing on mechanisms for preserving the level of redundancy when one or more nodes fail or leave the system. However, file updates, the most frequent operations performed on files, pose challenges in maintaining coded information in the system up to date. In other words, any change in the file will impact all coded blocks in the system, so all traces of the file must be completely replaced. This becomes costly since recomputing coded blocks is very CPU intensive and replacing all the coded blocks consumes an excessive amount of bandwidth. To the best of our knowledge, there has been no work addressing this update problem. To this end, we propose a Differential Update Model () that will update coded blocks by delivering only the changes in the file. We also present our objective view of the model through a complete analysis on computational complexity and bandwidth saving and simulated experiments. I. INTRODUCTION The fast emerging cloud services have received a tremendous amount of attention in both industry and academia. Storage services such as Dropbox and icloud enabled us to share files among multiple users or devices. In contrast to local file systems, files in cloud storage systems should be available and accessible at any time and from anywhere. This expected reliability is one of the key benefits of a cloud storage system achieved through data redundancy. The key to data redundancy is distributing replicas of a file on multiple storage nodes or devices. There are different mechanisms for arranging file copies among storage nodes or devices, including the standard RAID architectures, erasure code, and network coding, each of which provides different levels of redundancy and fault tolerance. The introduction of network coding in cloud storage systems allows storage nodes to collectively host multiple copies of a file, i.e. each node hosts a portion of a file rather than the entire copy, resulting in simple and fast file retrievals. The concept of network coding has been originally proposed in the field of information theory [1], [2], [3], and has since emerged as one of the most promising information theoretic approaches for improving performance in distributed file sharing [4], [5] and multimedia streaming [6]. It has been shown that random linear codes using Galois fields are sufficient to implement network coding in a practical network [7]. In a network-coding-assisted cloud storage system, a file is divided into n blocks that are coded using random coefficients. The coded blocks are then distributed among storage nodes in the Cloud. A file may be retrieved by decoding the n coded blocks downloaded from any subset of the storage nodes. In addition to the reliable and flexible file access, cloud storage systems also allow users or systems to update the files. Furthermore, online collaborative office suites such as GoogleDocs let users create, edit and publish a document collaboratively from around the world. In these cases, the application of network coding poses challenges in keeping files in the system up to date. When a file is updated, even changing a single byte can outdate all coded blocks in the system. This leads to re-computations and re-deliveries of new coded blocks to replace all the existing coded blocks. Hereafter, we refer to such a problem as the update problem. Such a complication makes it impractical to apply network coding in a real cloud storage system. To address this problem, we propose a Differential Update Model () that conserves both bandwidth and CPU cycles by delivering only the changes in the files. In a nutshell, the update model operates like a diff update, i.e., sending only the modified parts with a minimum possible overhead. In this paper, we first propose the mathematical model of and then present the corresponding update algorithms to be performed on all nodes. To verify, we conduct both a numerical and an experimental analyses. Our simulation results show that the proposed differential update mechanism leads to a significant bandwidth saving in a network-coding-enabled cloud storage system, regardless of the network topology, the file size, and the amount of data being updated. The remainder of this paper is organized as follows. Sec. II reviews related work on cloud storage systems and practical network coding in such systems. Sec. III provides the preliminary model for network coding assisted cloud storage systems. In Sec. IV, we formally propose our differential update model () for file updates and the associated algorithms. Sec. V presents the complete analysis on communication and computational costs. Finally Sec. VI concludes the paper and provides some directions for further research.

2 II. RELATED WORKS Commercial cloud storage systems, such as Microsoft Azure [8] and Google Cloud [9], utilize source erasure codes to provide supports for data redundancy and fault tolerance. The update problem in such a cloud storage system has been investigated in several research works [1], [11], [12], [13]. Reed-Solomon codes originally are non-binary cyclic error correcting codes that have been used in many data storage and communication applications [14]. Utilizing Reed-Solomon codes for cloud storage, the content of a source data is divided into k blocks of a same size, and then n > k encoded blocks are generated by the source node, such that any k out of n encoded blocks can be used to recover the original file. To minimize the computational and communication cost of the file updates, the delta update of erasure codes have been examined and proposed in [15], [16]. Chesterfield et. al addressed the update problem in wireless broadcast channels using hierarchical decomposable homomorphic erasure hashes [15]. The rateless erasure encoder over Galois field GF (2 16 ) allows the receivers to use any received hash in place of any missing one. The proposed system conserves battery power while minimizing the synchronization time of the mobile devices. Irmak et. al proposed a single-round protocol based on rsync, an open source tool for file synchronization, that utilizes erasure code over compressed delta data to reduce network traffic [16]. In contrast to source erasure codes, network coding applies coding at intermediate relay nodes throughout the network, rather than at the terminal nodes (sender and receivers) only. Network coding was originally proposed in information theory in 2 [1], and has since received extensive research attention. The fundamental insight of network coding is that information to be transmitted from the source in a session can be inferred, or decoded, by the intended receivers, and does not have to be transmitted verbatim. The benefits for coding at intermediate nodes include high throughput [1], [3], efficient routing algorithm design [17], energy savings in wireless networking [18], and security [19]. Network coding may be performed over a large finite field, as in Reed- Solomon codes, or over a binary field, as in fountain codes [2], [21]. Recently, there are many efforts in practical network coding for storage systems [22], [23], [24]. However, there has been no work addressing the update problem defined in Sec. I. The closest related works are on the repair problem, providing mechanisms for preserving the level of redundancy when one or more nodes fail or leave the system [25]. To this end, different symmetric and asymmetric network and erasure coding mechanisms have been proposed [26], [22], [27] that either rebuild a node with the same functionality as the failed node (functional repair) from the surviving nodes [22], [27], or reconstruct an exact copy of the failed node (exact repair) [28]. In [22], the notion of regenerating codes has been introduced to decrease the repair bandwidth by allowing a new node to communicate functions of the stored data from the surviving nodes. Similarly, in [27], another solution for multiple node failures in a distributed storage system has been proposed. This solution is based on a mutually cooperative recovery (MCR) mechanism and it has been shown that this mechanism matches the lower bound maintenance bandwidth. A good survey on proposed solutions for repair problem can be found in [25]. We believe that the update problem is just as essential as the repair problem. Towards efficient and effective file synchronization, we propose the Differential Update Model () to update coded blocks by delivering only the blocks that are affected by the updates. Furthermore, we provide the corresponding update algorithm based on this model. In contrast to the delta update of erasure codes [15], [16], applies the update directly to coded blocks without decoding any of them. III. PRELIMINARY In this section, we present our model for the storage cloud system as well as the network coding setup in such a system. We conclude this section with the update problem found in the network coding enabled storage systems. A. Modeling the Storage Cloud System In this paper, we model the storage cloud system as a directional graph G = (V, E), where V is a set of nodes, and E is the set of edges connecting the nodes. As shown in Fig. 1, nodes V are further divided into three categories: source nodes (V S = S i ) that own the original copy of each file in the system, storage nodes (V N = N i ) that collectively store R copies of each file, and target nodes (V T = T i ) that are interested in accessing certain files. There are two types of edges, E S and E T, where an edge e i E S carries file updates from a source node to a storage node, an edge in e i E T carries file updates from a storage node to a target node. Hence, the direction of the edges indicates the flow of file updates. The network formed by the source nodes and the storage nodes models the storage cloud, where the target nodes model the end-hosts connecting to the Cloud. N1 T1 1 4 S1 1 2 S N2 N3 N4 T2 2 4 T3 3 Si Fig. 1. A sample cloud storage system The other important concept in such a cloud storage system is the files. As depicted in Fig. 1, a collection of files F is distributed among the source nodes. Each storage node stores portions of a random set of files F Ni, and each target node may be interested in a random set of files F Ti. Ni Ti 9

3 This setup requires that each storage node must be connected to a set of source nodes S such that F Ni S F i S S i. Each target node must be connected to a set of storage nodes from which a complete copy of the to-be-downloaded file can be reconciled. In order to keep our model simple, without loss of generality, we make the following three assumptions. A single original copy of each file is hosted among the source nodes in the Cloud, i.e., each source node V Si owns a disjoint set of files F Si. Each node can only be a source node, a storage, or a target node at a time, i.e., nodes of the same type do not connect to each other. In reality, a node can be a source node for file 1, a storage node for file 2, and a target node for file 3. We can reduce such a general case to our model by splitting the node into multiple nodes, one for each type. It is common for a storage system to distribute R 1 copies of each file to provide data redundancy, where R is the replication factor. We assume that the replication and retrieval protocols are already in place to determine edges in graph G. Please note that the edges in our model correspond to the flow of file updates rather than network links. Hence, reducing a general case to our model does not involve redistributing the link capacity. Since the target application is a storage system, the bandwidth will only impact the time required to download a file and its updates. B. Network Coding in the Storage Cloud System With randomized network coding, a file is divided into n original blocks B = [b 1, b 2,..., b n ], where b i has a fixed number of bytes s (referred to as the block size). When encoding a new block c i, the source node first independently and randomly chooses a set of coding coefficients ɛ i = [ε i,1, ε i,2,..., ε i,n ] in the Galois field GF(2 8 ), one for each original block. It then produces one coded block c i of s bytes: c i = ɛ i B = ε i,j b j (1), where b j is the j th column-vector of the matrix B, i.e., the j th byte of every block. For each file with n blocks, the source node produces R n coded blocks. The coded blocks are distributed among the storage nodes V N to provide R- redundancy in the system. For instance, as shown in Fig. 1, file 1 is divided into 4 blocks, and there are 8 coded blocks collectively hosted among storage nodes N 1, N 2, and N 3. Like [29], a coded block c j is self-contained. In order to minimize the overhead, only the seed used to generate the random coefficients are embedded in the header of the coded block, which leads to a header overhead of 4 bytes per coded block. Due to the randomness in generating the coding coefficients, with high probability, any n of the R n coded blocks are linearly independent and can be used to recover all original blocks of the corresponding file. Hence, when retrieving a file, a target node locates and downloads n coded blocks, C = [c 1, c 2,, c n ], from the storage nodes. In Fig. 1, in order to retrieve file 1, target node T 1 only needs to download 4 coded blocks from any two of the storage nodes N 1, N 2, and N 3. The encoding coefficients of each coded block can be reproduced using the embedded seed. Given the encoding matrix ξ = [ɛ 1, ɛ 2,, ɛ n ], the original blocks B = [b 1, b 2,..., b n ] can be recovered by: B = ξ 1 C (2) In this equation, the target node first computes the inverse of ξ, using Gaussian elimination. It then needs to multiply ξ 1 and C T, which takes n 2 s multiplications of two bytes in GF(2 8 ). C. The Update Problem The redundancy and the flexibility provided by network coding are obvious in the system described. However, the problem raises when a file is updated. Since each coded block is encoded based on all n original blocks, even a change of a single byte in the original file would make all existing coded blocks invalid. Hence, for every single update, we must transmit R n new coded blocks from the source nodes to the storage nodes, and K n coded blocks from the storage nodes to the target nodes, where K is the number of copies of the updated files found among target nodes. In this paper, we propose an efficient update mechanism, named Differential Update Model (), to reduce the update cost. IV. DIFFERENTIAL UPDATE MODEL In this section, we propose an efficient update mechanism, named Differential Update Model (), that effectively avoids retransmissions of the entire file for each update, unless all the file blocks are changed. We first present the baseline model for propagating the updates in a file, and then extend the model to support updates across multiple versions. A. Updating Coded Blocks We first begin with the simple case where all nodes are synchronized to the same version. In other words, when rolling from one version to the next, all storage nodes and target nodes that currently have portions or a copy of the file will be updated. Assume that the current version number of a file is v, then version v+1 involves arbitrary updates in n n blocks of the file, where n is the number of the original blocks in this file. Let B = [b 1, b 2,..., b n ] be the original blocks of the file in version v, and B = [b 1, b 2,..., b n] be the original blocks of the file in version v+1. For each block b i in version v + 1, we can express it as b i + δ i, where δ i is the differential vector, representing the difference between version v and v + 1{ in block i, and if b i,j = b i,j δ i,j = b i,j b i,j if b i,j b (3) i,j We refer to the matrix = [δ 1, δ 2,, δ n ] as the differential matrix. To encode a new block for version v + 1, the source node again randomly chooses a set of coding coefficients ɛ i = [ε i,1, ε i,2,, ε i,n ] in the Galois field

4 GF(2 8 ). According to Eqn. 1, we have a coded block c i of s bytes as in Eqn. 4. If we reuse the coding coefficients used when producing the coded blocks for version v, i.e., ɛ j = ɛ j, then the new coded block in Eqn. 4 can be expressed in terms of the old coded block in Eqn. 1, using the same coding coefficients. Based on this key mathematical property, we propose the update mechanism on both the storage nodes and the target nodes. c i = ɛ ib = = = ε i,jb j ε i,j(b j + δ j ) ε i,jb j + ε i,jδ j = c i + ɛ i if ɛ i = ɛ i (4) 1) Updating Storage Nodes: Given that the coded blocks {c i } of version v are already available on the storage nodes, providing is sufficient to update all c i s to c i s using Eqn. 4. Furthermore, Eqn. 3 indicates that there are only n non-zero δ vectors, i.e., only n blocks are affected when updating from version v to version v + 1. Therefore, sending only the non-zero rows of, denoted as = [δ 1, δ 2,, δ n ] is sufficient to update the any coded block. A significant amount of bandwidth can be saved here since most updates will affect only a smaller portion of a file. The n non-zero δ vectors can be coded using a set of n randomly chosen coding coefficients ɛ i = [ε i,1, ε i,2,, ε i,l ], as in Eqn. 5: n c δ i = ɛ i = ε i,jδ j (5) The coded δ-blocks (C δ ) are then transmitted to the storage nodes in the same way as a regular coded block would be. Similar to Eqn. 2, upon receiving n coded δ- blocks, a storage node can decode as follows: = ξ 1 C δ (6) We note that the old coded blocks can be updated by substituting into Eqn. 4. However, is the differential matrix without all the zero rows. In order to recover from, an update vector must be sent to the storage nodes for each update. We define the update vector (u v+1 = [u v+1,1, u v+1,2,, u v+1,n ]) as a bitvector, in which bit u v+1,i indicates whether block b i has been changed from version v to version v + 1, i.e., { if b i = b i u v+1,i =, δ i = 1 if b i b i, δ (7) i The differential vector may be reconstructed by inserting the zero δ- vectors into according to the update vector u. Now, the old coded blocks may be updated using Eqn. 4. The algorithm for updating a storage node is summarized in Alg. 1. Algorithm 1 Updating Coded Blocks on a Storage Node Require: the update vector u v+1 and n coded δ-blocks (C δ ) 1: Re-generate the coding coefficients for the n coded δ- blocks using the embedded seed in each block 2: Decode n coded δ-blocks using Eqn. 6 to obtain 3: Restore based on u v+1 and 4: for each coded block c i do 5: c i = c i + ɛ i, where ɛ i is the current coding coefficient vector of c i 6: end for 2) Updating Target Nodes: We must note that the target nodes maintains the actual files in their original form rather than coded blocks. However, storage nodes can provide coded blocks only. Update the target nodes becomes a problem of finding the differential matrix δ based on the update vector u and n new coded blocks {c i } from the storage nodes. As outlined in Alg. 2, using the embedded coefficients of the new coded blocks and the original blocks of the file in version v, the target node can reconstruct the coded blocks {c i } of version v. The target node can then infer each coded δ-block as c δ i = c i c i (see line 4 of Alg. 2). Again, we obtain using Eqn. 6, and then recover the differential vector based on the update vector u and. At last, in lines 7-8, by adding the non-zero δ-vectors to the corresponding old original blocks {b i }, the file copy is now successfully updated to version v + 1. Algorithm 2 Updating File Copies on a Target Node Require: the update vector u and n new coded blocks {c i } 1: for each of the n new coded block c i do 2: Re-generating the coding coefficients ɛ i for c i using the embedded seed 3: c i = ɛ i B 4: c δ i = c i c i 5: end for 6: Decode n coded δ-blocks using Eqn. 6 to obtain 7: Restore based on u and 8: for each original block b i do 9: b i = b i + δ i 1: end for B. Aggregating Updates Across Multiple Versions In reality, often storage nodes and target nodes may not be always synchronized to the latest version. A storage node or a target node may miss several updates due to various reasons. Assume that a storage node or a target node missed m updates, i.e., the node currently has version v, while the actual file has been updated to version v + m. In this case, it would be very inefficient to run Alg. 1 or Alg. 2 m times

5 to refresh the system version by version. For this reason, we modify so that only a single pass through the update mechanism is needed, regardless of the number of versions missed. Based on Eqn. 4, a coded block (c v i ) in version v may be expressed in terms of the coded blocks of version and the summation of coded δ-blocks from version to version m, as derived in Eqn. 8. c i = c i c 1 i = c i + ɛ i 1 = c i + ɛ i 1. c m i = m m c i + ɛ i j = c i + ɛ i j (8) Therefore, an aggregated differential vector from version v to v + m is m = v+m i=v+1 i. Upon receiving the aggregated update vector and n aggregated coded δ-blocks, a storage or a target node may update coded blocks or a file copy using Alg. 1. To support such an aggregated update, we introduce an update table that stores the update vectors and the coded δ- blocks used in each update. We let the version number begins at, so the index of the update table will be the version number that each entry is associated with. On a source node, every time it sends an update vector and the corresponding coded δ-blocks, it creates an entry in the update table. A storage node creates an update table entry for each update it receives. If a storage node misses one or more updates, then the corresponding update table entries would be empty, and the first non-empty entry following the empty entries contains the aggregated differential update matrix, encompassing changes across the missing versions. Correspondingly, the update vectors must be aggregated to reflect the relationship between and after the aggregation. Let U be the collection of update vectors for a particular file, i.e., U = [u 1, u 2,, u r ], where u r is the latest version, and u i is the update (bit)vector indicating the changes from version i 1 to version i, as defined in Eqn. 7. When updating a storage or target node from version v to version v + m, the source node or storage nodes construct an aggregated update vector u a as: v+m u a = u i (9) i=v+1, where is defined as the bitwise OR operation on two update (bit)vectors. This extension effectively eliminates the need to reproduce the coded blocks in Alg. 2 (line 1 to line 5), as the storage nodes can send differential matrices to target nodes now. Updating the storage nodes and the target nodes are now essentially the same (Alg. 1). The tradeoff is the extra storage requirement on both the source nodes and the target nodes. For each update, a new entry of the update table is generated. The new entry contains a n 8 -byte update vector and n s- byte coded δ-blocks. Computational wise, generating the aggregated update vector take O(m n 8 ) OR operations between two bytes, and the generation of n aggregated coded δ-vectors takes O(n s) additions of two bytes, where m is the number of missing versions, n i is the number of blocks involved in each update, and s is the size of a block in bytes. V. ANALYSIS, EVALUATION AND EMPIRICAL STUDY In this section, we first present a numerical analysis on the communication and computational costs of, and then evaluate under various parameter settings. We conclude the section with a case study on the effectiveness of against existing Diff programs for non-coded file updates. The goal is to quantify the saving achieved by and to identify cases that can benefit from. A. Numerical Analysis Claim 1. The bandwidth saving in updating the storage nodes using is (R n N n ) s N n 8. Proof: Assume that there are R n coded blocks distributed among N storage nodes. In order to update all existing coded blocks using Eqn. 4, each storage node must receive the n 8 -byte update vector u and n s-byte coded δ- blocks. Therefore, in total N (n s + n 8 ) bytes will be transmitted from the source node of the file to all affected storage nodes. Without, we must recode and retransmit R n s new coded blocks to the storage nodes. Therefore, the bandwidth saving is (R n N n ) s N n 8. Claim 2. The computational cost of on a storage node is O((n ) 3 + (n ) 2 (s + 1) + κ n s + κ s + n). Proof: In Alg. 1, the first step is to reproduce the coding coefficients for the n coded δ-blocks, which requires O((n ) 2 ) random number generations. Next, decoding the n coded δ-blocks takes O((n ) 3 ) operations to compute and O((n ) 2 s) operations to perform the matrix multiplication in Eqn. 6. The next step is to restore, which takes O(n) times. In the last step, each coded block is updated, which requires s additions of two bytes and n s multiplications of two bytes. Overall, the algorithm takes O((n ) 2 + (n ) 3 + (n ) 2 s + n + (s + n s) κ) = O((n ) 3 + (n ) 2 (s + 1) + κ n s + κ s + n) time, where κ n is the number of coded blocks of the to-be-updated file stored on a storage node. ɛ 1 Claim 3. The bandwidth saving in updating the target nodes using is K (n s l s n 8 ). Proof: Assume that there are K copies of the file to be updated among the target nodes. In order to update all file copies using Alg. 1, each target node must receive the n 8 -byte update vector u and l new s-byte coded blocks. Therefore, in total K (l s + n 8 ) bytes will be transmitted from the storage nodes to all affected target nodes. Without, a target node must receive n new coded blocks in order to update a file copy. Therefore, the bandwidth saving is K (n s l s n 8 ). Claim 4. The computational cost of on a target node is O((n ) 3 + (n ) 2 (s + 1) + 2n s + n).

6 Proof: Recall that the modification for aggregated updates effectively simplifies Alg. 2 with a computational and storage tradeoff on the storage nodes. On the storage node, the computation of the aggregated differential matrix for aggregated updates of m versions takes O(n s). According to Claim 2, reproducing the coding coefficients for the n coded δ-blocks, decoding the δ-blocks, and restoring takes O((n ) 3 + (n ) 2 (s + 1) + n) operations. In the last step of Alg. 2, it takes n s additions to update every block of the file. Overall, the algorithm takes O((n ) 3 + (n ) 2 (s + 1) + 2n s + n) time. Without, a target node simply decodes all n new coded blocks received from storage nodes, which takes O(n 3 + n 2 s) time. B. Evaluation Unless otherwise specified, we resort to a network topology that is similar to the construct presented in Fig. 1, with a single source node, 1 storage nodes, and 1 target nodes. We use a 2 MB file that is further divided into 1 blocks (2 MB in each block). According to [3], the number of blocks n should be no more than 1 to ensure that network coding operates at a rate faster than a typical transmission rate in a network. The replication factor is 5, large enough to generate sufficient traffic for each update. The file update affects 3% of the blocks in a file. We compare the performance of conventional network coding update () and when varying the number of storage nodes, the number of target nodes, the file size, the replication factor, and the number of blocks affected by an update in the system. First, we fix the number of target nodes to 1, and vary the number of storage nodes from 5 to 1 as well as the replication factor from 1 to 1. In Fig. 2(a), we observe that the traffic volume of depends on the replication factor rather than the number of storage nodes, whereas the traffic volume of grows linearly with the number of storage nodes since it must send n δ-blocks to each storage node. In fact, the performance of is independent of the replication factor, since regardless of the number of coded blocks on each storage node, exactly n δ -blocks are need to update each storage node. We next keep the number of storage nodes fixed at 1 and vary the number of target nodes from 5 to 1. As shown in Fig. 2(b), the bandwidth used by grows proportionally to the number of target nodes, as each additional target node requires an additional copy of the file. When using, each additional target node requires only n = 3 more coded δ -blocks, so the rate of the bandwidth usage increase is only half of the rate found in. In summary, the bandwidth usage of highly depends on the number of storage nodes and is relatively independent of the number of target nodes. We next vary the file size from 25 MB to 1.6 TB. The savings on bandwidth and computation are more obvious as the file size grows, as depicted in Fig. 3(a) and Fig. 3(b), respectively. Although the saving in computation is more significant than that of bandwidth, we observed that the Total Bandwidth Usage (GB) (R = 1) (R = 5) (R = 1) Number of Storage Nodes (a) Total Bandwidth Usage (GB) Number of Target Nodes Fig. 2. Bandwidth usages when varying the number of storage nodes and target nodes computational cost on storage nodes in is actually higher than that in. In the decomposition of the overall computational cost depicted in Fig. 4, we note that the computational cost on storage nodes dominates the overall cost. However, since there is a substantial saving on the target nodes, we are saving CPU cycles overall in the entire system. Total Bandwidth Usage (GB) Fig. 3. Fig. 4. File Size (MB) (a) Bandwidth usage Computational Cost 2.E+8 1.5E+8 1.E+8 5.E+7 (b) E File Size (MB) (b) Computational cost Bandwidth usage and complexity when varying the file size Computational Cost 1.5E+8 1.1E+8 7.5E+7 3.8E+7 On storage nodes On target nodes E File Size (MB) Breakdown of the computational cost when varying the file size Another parameter that may impact s performance is the number of versions aggregated in one update. For, regardless of the number of versions missed, all coded blocks are replaced by newly generated ones. For, the storage nodes must compute the aggregated update vector and δ- blocks before updating the target nodes. Fig. 5 exemplifies that has a linear growth as more versions of updates are aggregated together. However, it still exhibits less computational cost compared to, even when aggregating 1 updates. At last, we turn our attention to the number of blocks affected by an update, since avoiding transmissions of unchanged blocks is the key to savings in. Fig. 6(a) shows

7 Fig. 5. updates Computational Cost 2.5E+7 2.2E+7 1.9E+7 1.6E+7 1.3E+7 1.E Number of Aggregated Updates The computational cost when varying the number of aggregated that the bandwidth consumed by increases as more blocks are affected by the update, and eventually surpasses that of when the update affects more than 95% of the blocks. On the computational side, as shown in Fig. 6(b), conserves CPU cycles when the update affects less than 5% of the blocks. Further analyses show that this result highly depends on the number of coded blocks hosted on each storage node. The less coded blocks on each storage node leads to superior performance of. Total Bandwidth Usage (GB) Fig. 6. blocks 1% 2% 3% 4% 5% 6% 7% 8% 9% 1% Ratio of Updated Blocks (a) Bandwidth usage Computational Cost 6E+7 5E+7 4E+7 2E+7 1E+7 E+ 1% 2% 3% 4% 5% 6% 7% 8% 9% 1% Ratio of Updated Blocks (b) Complexity Bandwidth usage and complexity when varying the ratio of updated C. A Case Study In order to verify the feasibility of our proposed model, we further conduct a simulation study based on the cloud storage system described in Sec. III, with real network coding operations. We then developed two plug-in modules: module that uses pure network coding approach, i.e., for each file update, all the coded blocks are regenerated and redistributed in the system; and module that uses the differential update model, i.e., it constructs the differential matrices and distributes them as proposed in Sec. IV. For comparison purpose, we also developed two non-network-coding modules. The Diff module employs a modified version of standard diff algorithm [31] that calculates the difference file by solving the longest common subsequence problem, and then distributes the diff file using (offset,length,newcontent) tuples. The bsdiff module uses the bsdiff algorithm proposed in [32], a novel delta compression method proposed for binary executable files. This algorithm is an extension of the diff algorithm, utilizing different optimization and compression techniques, and is especially designed for binary files. It is considered the most efficient diff algorithm. The simulator was running on a DELL XPS M153 with 4GB of DDR2 physical memory and Intel Core2 2.5GHz CPU utilizing one CPU core due to its singlethread structure. The network topology was similar to the construct presented in Fig. 1 with a single source node for simplicity. Due to hardware limitation, the simulator, by default, consists of 1 storage nodes and 1 target nodes. The file size is reduced to 4 MB, with replication factor of 2. For network coding operations, the file is divided into 1 blocks of the same size. The percentage of bytes randomly modified in each block is 1%, and finally the percentage of blocks affected by an update is set to 5%. Furthermore when updating a file, the requests from a target node are evenly distributed among all qualified storage nodes for load balancing purpose. As the communication and computational costs were the concerns in the design of, we measured the sum of sending bandwidth and CPU usage of all participating nodes (including source node, storage nodes and target nodes) while varying the parameters. Due to the space limit, we show only the result from varying the percentage of blocks that is affected by the updates. Although the bandwidth consumed by is more than that of the Diff and the bsdiff models, as shown in Fig. 7(a), the saving is significant when compare with the pure network coding approach for file updates in less than 92.7% of the blocks. On the computational side, as shown in Fig. 7(b), compare to, conserves over 9% of the CPU usage. Furthermore, outperforms Diff and bsdiff, since our update model directly modified the affected bytes, where the Diff-based algorithms still requires a scan through the file. Most importantly, these results are consistent with the analysis presented earlier in this section. Total Bandwidth Usage (MB) Fig. 7. blocks Diff bsdiff 1% 2% 3% 4% 5% 6% 7% 8% 9% 1% Ratio of Updated Blocks 92.7% (a) Bandwidth usage Total CPU Usage (sec) Diff bsdiff 1% 2% 3% 4% 5% 6% 7% 8% 9% 1% Ratio of Updated Blocks (b) CPU Usage Bandwidth and CPU usage when varying the number of updated VI. COLUSION AND FUTURE WORKS In this paper, we address the update problem in the network-coding assisted cloud storage systems by proposing the Differential Update Model () that saves bandwidth and reduces computational complexity in network-codingenabled cloud storage systems. We analyzed the model to quantify the savings achieved by and to identify cases that can benefit from. We conclude that saves both the communication and computational costs, unless the update affects almost the entire file, and conserves CPU cycles for large files and when the data is more scattered in the Cloud. In summary, we believe that opens up

8 a new research direction in network coding for distributed storage systems. We plan to further optimize the model to be more computationally efficient and implement the model in a practical system to estimate the savings in real systems. REFEREES [1] R. Ahlswede, N. Cai, S. R. Li, and R. W. Yeung, Network Information Flow, IEEE Transactions on Information Theory, vol. 46, no. 4, pp , July 2. [2] S. Y. R. Li, R. W. Yeung, and N. Cai, Linear Network Coding, IEEE Transactions on Information Theory, vol. 49, no. 2, pp , February 23. [3] R. Koetter and M. Medard, An Algebraic Approach to Network Coding, IEEE/ACM Transactions on Networking, vol. 11, no. 5, pp , October 23. [4] C. Gkantsidis and P. Rodriguez, Network Coding for Large Scale Content Distribution, in Proc. of the 24th Conference of the IEEE Communications Society (INFOCOM), Miami, FL, March , pp [5] C. Gkantsidis, J. Miller, and P. Rodriguez, Anatomy of a P2P Content Distribution System with Network Coding, in Proc. of the 5th International Workshop on Peer-to-Peer Systems (IPTPS), no. 1-7, Santa Barbara, CA, February [6] Z. Liu, C. Wu, B. Li, and S. Zhao, UUSee: Large-Scale Operational On-Demand Streaming with Random Network Coding, in Proc. of the 29th Conference of the IEEE Communications Society (INFOCOM), no. 1-9, San Diego, CA, March [7] T. Ho, R. Koetter, M. Medard, D. Karger, and M. Effros, The Benefits of Coding over Routing in a Randomized Setting, in Proc. of International Symposium on Information Theory (ISIT), Yokohama, Japan, June 29 - July 4 23, p [8] B. Calder, J. Wang, A. Ogus, N. Nilakantan, A. Skjolsvold, S. McKelvie, Y. Xu, S. Srivastav, J. Wu, H. Simitci, J. Haridas, C. Uddaraju, H. Khatri, A. Edwards, V. Bedekar, S. Mainali, R. Abbasi, A. Agarwal, M. F. ul Haq, M. I. ul Haq, D. Bhardwaj, S. Dayanand, A. Adusumilli, M. McNett, S. Sankaran, K. Manivannan,, and L. Rigas, Windows Azure Storage: A Highly Available Cloud Storage Service with Strong Consistency, in Proc. of the 23rd ACM Symposium on Operating Systems Principles (SOSP), Cascais, Portugal, October , pp [9] D. Ford, F. Labelle, F. I. Popovici, M. Stokely, V.-A. Truong, L. Barroso, C. Grimes, and S. Quinlan, Availability in Globally Distributed Storage Systems, in Proc. of the 9th USENIX Symposium on Operating Systems Design and Implementation (OSDI), Vancouver, BC, October , pp [1] M. Blaum and R. Roth, On Lowest Density MDS Codes, IEEE Transactions on Information Theory, vol. 45, no. 1, pp , January [11] L. Xu and J. Bruck, X-Code: MDS Array Codes With Optimal Encoding, IEEE Transactions on Information Theory, vol. 45, no. 1, pp , January [12] Y. Cassuto and J. Bruck, Cyclic Lowest Density MDS Array Codes, IEEE Transactions on Information Theory, vol. 55, no. 4, pp , April 29. [13] I. Tamo, Z. Wang, and J. Bruck, MDS Array Codes With Optimal Rebuilding, in Proc. of IEEE International Symposium on Information Theory Proceedings (ISIT), July 31 - August 5 211, pp [14] S. B. Wicker, Error Control Systems for Digital Communication and Storage, ser Upper Saddle River, NJ, USA: Prentice- Hall, Inc., [15] J. Chesterfield and P. Rodriguez, DeltaCast: Efficient File Reconciliation in Wireless Broadcast Systems, in Proc. of the 3rd ACM International Conference on Mobile Systems, Applications, and Services (MobiSys), Seattle, WA, June , pp [16] U. Irmak, S. Mihaylov, and T. Suel, Improved Single-Round Protocols for Remote File Synchronization, in Proc. of the 24th Conference of the IEEE Communications Society (INFOCOM), Miami, FL, March , pp [17] D. S. Lun, N. Ratnakar, R. Koetter, M. Medard, E. Ahmed, and H. Lee, Achieving Minimum Cost Multicast: A Decentralized Approach Based on Network Coding, in Proc. of the 24th Conference of the IEEE Communications Society (INFOCOM), Miami, FL, March , pp [18] H. Rahul, W. Hu, D. Katabi, M. Medard, and J. Crowcroft, XORs in the Air: Practical Wireless Network Coding, IEEE/ACM Transactions on Networking, vol. 16, no. 3, pp , June 28. [19] C. Gkantsidis and P. Rodriguez, Cooperative Security for Network Coding File Distribution, in Proc. of the 25th Conference of the IEEE Communications Society (INFOCOM), Barcelona, Spain, April , pp [2] J. W. Byers, M. Luby, M. Mitzenmacher, and A. Rege, A Digital Fountain Approach to Reliable Distribution of Bulk Data, in Proc. of ACM SIGCOMM, September 1998, pp [21] J. W. Byers, J. Considine, M. Mitzenmacher, and S. Rost, Informed Content Delivery Across Adaptive Overlay Networks, IEEE/ACM Transactions on Networking, vol. 12, no. 5, pp , October 24. [22] A. G. Dimakis, P. B. Godfrey, Y. Wu, M. J. Wainwright, and K. Ramchandran, Network Coding for Distributed Storage Systems, IEEE Transaction of Information Theory, vol. 56, no. 9, pp , September 21. [23] A. Jiang, Network Coding for Joint Storage and Transmission with Minimum Cost, in Proc. of the International Symposium of Information Theory (ISIT), Seattle, WA, July , pp [24] C. Huang, M. Chen, and J. Li, Pyramid Codes: Flexible Schemes to Trade Space for Access Efficiency in Reliable Data Storage Systems, in Proc. of the 6th IEEE International Symposium on Network Computing and Applications, Cambridge, MA, July , pp [25] A. G. Dimakis and K. Ramchandran, A Survey on Network Codes for Distributed Storage, Proceedings of the IEEE, vol. 99, no. 3, pp , March 211. [26] R. Rodrigues and B. Liskov, High Vvailability in DHTs: Erasure Coding vs. Replication, in Proc. of the 4th International Workshop on Peer-to-Peer Systems, February 25. [27] Y. Hu, Y. Xu, X. Wang, C. Zhan, and P. Li, Cooperative Recovery of Distributed Storage Systems from Multiple Losses with Network Coding, IEEE Journal on Selected Areas in Communications, vol. 28, no. 2, pp , February 21. [28] K. Rashmi, N. Shah, P. Kumar, and K. Ramchandran, Explicit Construction of Optimal Exact Regenerating Codes for Distributed Storage, in Proc. of the 47th Annual Allerton Conference on Communication, Control, and Computing, Monticello, Illinois, September 3 - October 2 29, pp [29] P. Chou, Y. Wu, and K. Jain, Practical Network Coding, in Proc. of the 41st Allerton Conference on Communication, Control, and Computing, Monticello, Illinois, October 23, pp [3] M. Wang and B. Li, How Practical is Network Coding? in Proc. of the 14th IEEE International Workshop on Quality of Service (IWQoS 26), Passau, Germany, June , pp [31] J. W. Hunt and M. D. McIlroy, An Algorithm for Differential File Comparison, Bell Laboratories 41, Computing Science Technical Report, June [32] C. Percival, Matching with Mismatches and Assorted Applications, Ph.D. dissertation, Wadham College, University of Oxford, 26.