Extending TCP for Accelerating Replication on Cluster File Systems over SDNs

TL;DR

This paper proposes extensions to TCP to enable parallel data replication in SDN-connected cluster file systems like HDFS, significantly reducing replication time and network usage through a prototype implementation.

Contribution

It introduces TCP modifications that support parallel transfer, facilitating efficient replication in SDN environments, which was not previously possible.

Findings

Data replication time reduced by 25%

Network utilization substantially decreased

Feasibility demonstrated with Linux kernel prototype

Abstract

This paper explores the changes required of TCP to efficiently support cluster file systems such as Hadoop Distributed File System (HDFS) where the storage nodes are connected through a software defined networking (SDN). Traditional chain replications in these file systems incur large delay and cause inefficient network use. But SDN can cooperate with the cluster file systems to address the problems by pre-arranging a distribution tree, which opens the possibility of parallel replication. Unfortunately, it cannot be realized without extending TCP, to accommodate the parallel transfer on the transport layer. This paper discusses how to extend TCP to make it possible, and demonstrates the feasibility by implementing a prototype in the Linux kernel. The prototype saves the data replication time by 25% while substantially reducing network use.

Figures

Tables

Table 1. TABLE I: Forwarding interfaces at each switches

	$I_c$	$I_{𝐃}$	Forwarding interface(s)
$S_a$	$I_{S_b}$	$\{I_{D_1},I_{D_2}\}$	$\{I_{D_1},I_{D_2}\}$
$S_b$	$I_{S_c}$	$\left\{I_{S_a}\right\}$	$\left\{I_{S_a}\right\}$
$S_c$	$I_I$	$\{I_{S_b},I_{S_d}\}$	$\{I_{S_b},I_{S_d}\}$
$S_d$	$I_{S_c}$	$\{I_{S_c},I_{S_e}\}$	$\left\{I_{S_e}\right\}$
$S_e$	$I_{S_d}$	$\{I_{S_d},I_{D_3}\}$	$\left\{I_{D_3}\right\}$

Table 2. TABLE II: Comparison between TCP and TCP-MR from the perspective of D j subscript 𝐷 𝑗 D_{j} ( 2 ≤ j ≤ k 2 𝑗 𝑘 2\leq j\leq k )

	TCP	TCP-MR
Non-retransmitted data segment from	$D_{j-1}$	Client
Retransmitted data segment from	$D_{j-1}$
TCP ACK to	$D_{j-1}$

Equations

$${\delta }_j=n_j-n_1$$

$$T_{vtx}>T_{ack}$$

$$T_{vtx}=T_{c,j-1}+T_{p(j-1)}$$

$$T_{ack}=T_{c,j}+T_{p(j)}+T_{j,j-1}$$

$$L_{tot}=L_{c,s_1}+L_{s_1,D_1}+L_{D_1,s_2}+\cdots +L_{s_k,D_k}$$

$$L_{tot}=\sum _{j=0}^k\left(L_{D_j,s_{j+1}}+L_{s_{j+1},D_{j+1}}\right)$$

$$\sum _{j=1}^k{L}_{D_j,s_{j+1}}/L_{tot}$$

Full text

I Introduction

Today, the data volume stored in data centers is growing explosively. Managing large volumes of data inevitably requires highly automated and efficient technologies. Prominent technologies among them are the large-scale cluster file systems such as Hadoop Distributed File System (HDFS) [1], Google File System (GFS) [2], and Windows Azure Storage [3]. Among the prime management concerns for the cluster file systems is data storing operation for its heavy demand. For instance, more than 50% of Facebook tasks in data centers spend their time storing data [4] and the amount of traffic to store data accounts for 50% of the total traffic produced in Hadoop clusters [5] [6]. In this paper, we show that there is an opportunity for optimizing the data storing operation by considering the cooperation of cluster file systems and the SDN, using HDFS as a guiding example for its wide adoption in many data-parallel infrastructures.

In HDFS, fault tolerance is provided by replicating copies in multiple data nodes, with some copies situated on the same rack and others on different racks. Copies are made from node to node using a chain of TCP connections, or ‘pipeline’ [1]. This traditional chain replication not only incurs sequential delay but also increases network traffic as the same data may traverse common network paths multiple times. In Figure 1, for example, two of the copies are stored in the rack under the top-of-rack (ToR) switch $s_{a}$, and one copy in the rack under $s_{e}$. Suppose the client that writes the data is in the Internet. If the former copies are made first, the same data traverses twice the link between the data node $D_{1}$ and $s_{a}$ for the in-rack copies. Also, in the transfer from $D_{2}$ to $D_{k}$ for the third copy, three links (i.e., 7,8,9) are duplicately traversed. Even if other paths are taken, the number of traversed links remains the same.

If we let a SDN application consult with the Name Node of HDFS to identify the selected data nodes, however, we can open the possibility of parallel transfer, thereby reducing the cost incurred by the time-consuming and spatially inefficient serial transfers. Specifically, when the client asks the HDFS to store a file, the file system can in turn ask the SDN controller to create a distribution tree (e.g. the thick edges in Figure 1) among the involved SDN switches that connect the racks for the selected data nodes. Then the HDFS can transmit the data towards the first node in the pipeline for the chain replication as before, but the pre-arranged SDN distribution paths will mirror them to all data nodes simultaneously, saving time for itself and network resource for other tasks. This arrangement between the Hadoop Name Node and the SDN controller application can be made even in the current standard framework.

Sounding straightforward, however, such parallel transfer cannot be realized without extending TCP. This is because cluster file systems such as HDFS, GFS, and Windows Azure Storage use TCP as the transport protocol, and the SDN-level distribution is done on a lower layer than TCP. Thus the TCP receiver at $D_{j}(j\neq 1)$ would balk with a reset (RST) upon the data segment directly distributed from the client, as it establishes the connection not with the client but with $D_{j-1}$, its direct predecessor in the pipeline. Although one could imagine devising a specialized transport protocol [7] [8] for this purpose, it would cause backward-compatibility problems. In other words, deployment base for today’s widespread cluster file systems would need transition to the new protocol and the application programmers would need to adapt to the model provided by the new protocol. It would be prohibitively expensive, if not impossible. Therefore, we investigate how the TCP protocol can be extended to accommodate the parallel transfer model above, but no change required to the cluster file systems, not to mention the application programmers for them, using HDFS as a guiding example. Furthermore, we implement a proof-of-concept prototype in the Linux kernel, and demonstrate that it indeed leads to significant savings in both time and network use. Specifically, it improves the data transfer time by 25% and saves 15 to 40% traffic for the typical replication factor of 3. But first, we discuss below previous solutions for parallel transfer and their limitation.

II Related Work

II-A Reliable Multicast Protocol

There have been a bunch of researches on reliable multicast protocol for a long time, which provides a reliable sequence of packets to multiple recipients simultaneously. Previous reliable multicast solutions fall into three categories: network-based, sender-based, and receiver-based. ARM [9] represents the first category (network-based), which requires the assistance from the network equipment such as routers to support reliable multicast. In ARM, routers suppress duplicate NACKs from multiple receivers to control the implosion problem in the upstream direction and limit the delivery of repair packets to receivers experiencing loss in the downstream direction. In the second category (sender-based), the sender maintains the receivers’ information to initiate multicast (e.g. TCP-XM [10] and MCTCP [8]). Thus, it is usually suitable for the small group. TCP-SMO [11], RMTP [12] and RDCM [13] represent the last category (receiver-based), where the receivers need to acquire the multicast address in advance so that they can subscribe the multicast group. Especially, in RDCM [13], the author emphasizes on reliable multicast for data centers and points out that existing reliable multicast solutions for the Internet are not suitable for the data center environment. It exploits diverse path existing in data center networks to build backup overlays for peer-to-peer packet repair.

II-B Multicast over SDNs

Researches on multicast over SDNs usually focus on multicast routing and management to improve efficiency. MCDC [14] suggests multicast routing, in which a SDN controller selects the core routers with the least load. Avalanche [15] proposes multicast system, leveraging SDN to take advantage of the rich path diversity commonly available in data center networks while minimizing the size of the routing tree for any given multicast group. Recently, more comprehensive multicast protocols over SDNs are proposed in MCTCP [8] and ATHENA [16]. The authors in MCTCP [8] propose multicast TCP in SDN-based data centers. They exploit SDN as a means of managing IP multicast group and routing. The sender maintains each TCP connections with multiple receivers and moves its sliding window after the slowest receiver sends the acknowledgement (ACK). ATHENA [16] enables reliable multicast and congestion control inside SDN based data centers so that no data is lost and other TCP flows in the network are not starved.

II-C Existing Problems in the Previous Solutions

Previous solutions break the distributed, or ‘pipeline’, structure originally designed for the cluster file systems and replace it with the multicast structure. To be specific, even the HDFS-specific protocols [7] [8], not to mention the reliable multicast protocols for the general purpose, insist the multicast structure not only for the data transfer, but also for the ACK transfer including the TCP ACK and the HDFS ACK, which is sent for every HDFS packet in the application layer. It causes realistic problems to exploit previous solutions for parallel transfer in today’s widespread cluster file systems. Deployment base for them would need to transition to the new protocol and the application programmers would need to adapt to the model provided by the new protocol. It would be prohibitively expensive, if not impossible and cause backward-compatibility problems. Also, this structure makes the first sender, or the client, take over the distributed ACK processing responsibility from all data nodes in the pipeline, leading to the following problem.

From the perspective of the network, the cost for sending the ACKs becomes more expensive. Especially, the TCP incast problem at the gateway switch ($S_{c}$ in Figure 1) would arise and TCP performance would degrade if the number of data nodes, trying to send the HDFS ACK to the client, reaches only six [17], meaning two clients in the Internet, with the default replication factor of 3. This is because the HDFS ACK is the data from the perspective of TCP. Furthermore, the traveling paths for the ACK become longer, causing more delay. For example, $D_{2}$ in Figure 1 should change its destination for the ACK from $D_{1}$ to the client in the Internet.

III Background

III-A Software Defined Networking (SDN)

SDN is the architecture that decouples the control and data planes in the network. Control logic is centralized in the so-called SDN controller. By Exploiting this architecture, applications running on the SDN controller operate the network through flow-based forwarding decisions rather than destination-based ones [18]. OpenFlow [19], or OpenFlow switch specification is the first standardized protocol in SDN and defines interfaces for the SDN controller to give commands to switches and to receive the network information from them. One of the most common behavior in this standard is the flow entry creation and matching process at SDN switches.

As depicted in Figure 2, the SDN controller gives flow-based forwarding rules through OFPT_FLOW_MOD message, including OFPFC_ADD command, matching field, and actions. Flow is identified by matching field represented as different rectangles in Figure 2. Matching field contains IP address, ethernet address, TCP port numbers and so on. The switch does the action specified by the SDN controller to the identified flow. For example, it can modify TCP/IP header and forward the corresponding flow to the designated interface(s).

III-B Replication Process

In order to provide the fault tolerance in the cluster file system, it stores the same data in multiple (i.e., 3) nodes. The cluster file system does this process in the application layer. Figure 3 shows the replication process in HDFS, which is used as a guiding example in this paper.

Client requests the Name Node to store a block. 2. 2.

The Name Node provides client with the data nodes to store the block. 3. 3.

Client asks if $D_{1}$ is ready to receive the block (repeated until $D_{3}$). 4. 4.

$D_{3}$ informs to $D_{2}$ that pipeline is ready (repeated until client). 5. 5.

Client divides the block into multiple HDFS packets and send one of them to $D_{1}$ (repeated until $D_{3}$). 6. 6.

$D_{3}$ informs to $D_{2}$ that it successfully received the HDFS packet (repeated until client).

5 and 6 are repeated until the block transfer is completed. Even though this process may not exactly same in the other cluster file systems, this process is similar as long as the other cluster file systems use sequential TCP connections for replication like GFS and Windows Azure Storage.

IV Design

IV-A Challenges

In order to solve the problems mentioned above, we extend TCP over SDNs, and the followings are the key issues in this paper.

• •

Transparent mirroring with the SDN standard: Unlike previous solutions, our scheme focuses on solving the real-world problem, so it should be feasible in off-the-shelf SDN equipment, supporting the current standard framework.

• •

Successful reception of transparently mirrored TCP segments: The mirrored ones are not easy for the next data node in the pipeline to accept, because the TCP header information such as source, destination, and sequence number is not correct.

• •

Prevention of duplicate transmission of the transparently mirrored TCP segments: The previous data node in the pipeline tries to send the data already mirrored to the next data node, because the pipeline structure is intact. However, such an action is unnecessary in our scheme.

• •

Retransmission of the lost TCP segments: The previous data node in the pipeline does not need to send the data to the next data node, however, if the next data node lose the mirrored TCP segments, the previous data node are required to retransmit the TCP segments like in the original pipeline structure.

Next, we discuss below how the SDN controller application can configure SDN switches to make and forward the transparently mirrored TCP segments towards data nodes.

IV-B Configuration for Mirroring at SDN Switches

Suppose the Name Node selects the data nodes $\mathbf{D}=\{D_{1},D_{2},\ldots,D_{k}\}$ for storing a client-requested data, where $k$ is the replication factor. When the Name Node lets the SDN controller application know the pipeline information (IP addresses and TCP port numbers) for $\mathbf{D}$, it should create flow entries in the switches $\mathbf{S}$ connecting $\mathbf{D}$.

IV-B1 Distributing the Mirrored TCP Segments

At each switch in $\mathbf{S}$, it creates a flow entry that matches packets from the client to $D_{1}$, and performs output action(s) [19] on the interface(s) to those data nodes below the given switch. In order to compute the distributing output interface(s), the routing application running on the SDN controller is consulted to obtain the interfaces $I_{c}$ and $I_{\mathbf{D}}$ towards the client and $\mathbf{D}$, respectively. Then, forwarding interfaces are $I_{\mathbf{D}}-I_{c}$. For instance, $s_{a}$ in Figure 1 computes $\{I_{D_{1}},I_{D_{2}}\}$ as the forwarding interfaces. Table I summarizes forwarding interfaces at each switch in Figure 1.

IV-B2 Modifying TCP/IP Header for the Transparent Mirroring

In addition to the output action, set-field actions [19] are configured in the ToR switches connecting mirroring data nodes $\mathbf{D}-\{D_{1}\}$ down the pipeline. For instance, if a switch needs to deliver the mirrored data to $D_{j}$, the set-field actions modify the IP addresses and the TCP port numbers of the client and $D_{1}$ in the source and the destination, respectively, to those of $D_{j-1}$ and $D_{j}$. Finally, one more set-field action is configured on the flow entry to set a flag in the reserved field of the TCP header for signaling the receiving TCP that the header has been changed and it is a mirrored copy.

For these configurations at SDN switches, the SDN controller application uses OFPT_FLOW_MOD message to carry the action-creating command OFPFC_ADD [19]. Figure 4 shows configuration for the transparent mirroring at SDN switches ($S_{a}$ and $S_{e}$) in Figure 1.

IV-C TCP Extentions for Mirrored Replication

The central feature our modified TCP (henceforth TCP “Mirrored Replication (MR)”) is that $D_{j}$ ($2\leq j\leq k$) directly receives a HDFS data block from the client, not from the previous data node $D_{j-1}$ in the pipeline. To preserve the traditional HDFS chain replication abstraction, however, the pipeline should still be created and maintained. Thus in TCP-MR, the connection from $D_{j}$ is still established with $D_{j-1}$ and the TCP ACKs from $D_{j}$ is sent to $D_{j-1}$ (not to the client), as in the traditional HDFS pipeline. For this reason, when $D_{j}$ receives a TCP segment from the client (as if from $D_{j-1}$), it has to perform two operations in the newly added states (MR_SND and MR_RCV) in Figure 5. First, it has to translate the sequence number and accept the payload in the received segment in the MR_RCV state. Second, it should simulate transferring it to $D_{j+1}$ down the pipeline in the MR_SND state, while not actually transmitting. Below, we discuss how these two operations are realized in TCP-MR.

IV-C1 Receiving with Sequence Number Translation

The sequence number spaces are independent between the TCP connections in the pipeline. Figure 6 shows the pipeline creation process [1] from the perspective of TCP (For $D_{3}$, similar procedure is repeated). At the last step of the pipeline completion, $D_{1}$ informs the client of it [1] (a in Figure 6), so that the client can start transmitting data (15 in Figure 6). But the client first acknowledges the notification-carrying TCP segment from $D_{1}$, which is mirrored to all $D_{j}$ ($2\leq j\leq k$) (b in Figure 6). Then they use the ACK to compute the sequence number compensation given as

[TABLE]

where $n_{1}$ is the sequence number in the mirrored ACK with the reserved flag set to 1, and $n_{j}$ is the current sequence number of the TCP channel from $D_{j-1}$. For instance, $\delta_{2}$ is -100 and $\delta_{3}$ is 300 in Figure 7. From this moment on, TCP-MR on $D_{j}$ enters into the MR_RCV state in Figure 5 and accepts the data segments from the client that has the reserved flag set to 1, which signifies that the TCP data segment is a mirrored copy. Meanwhile, for other segments with the reserved flag set, the flags (SYN, ACK, FIN, RST, CWR, ECE) and the ACK number information in the TCP header are ignored because they are the signaling traffic between the client and $D_{1}$. But for the TCP segments from $D_{j-1}$, for example the retransmissions, $D_{j}$ processes them normally. Figure 8 shows the flow chart for receiving process of $D_{j}$. Obviously, $D_{j}$ sends an ACK to $D_{j-1}$ as conventional TCP does except setting the reserved flag as 2. $D_{j-1}$ receiving the ACK with the reserved flag 2 enters into the MR_SND state in Figure 5.

IV-C2 Simulating Forwarding Down the Pipeline

In order to prevent $D_{j-1}$ ($2\leq j\leq k$) from duplicating the client’s transmission to $D_{j}$ and prepare necessary retransmission in the future, $D_{j-1}$ should slide the sending window, run the retransmission timer, and process the ACK from $D_{j}$, without actually transmitting data segments. We call this feature of TCP-MR the virtual transmission, and it is done for non-retransmitted data segments. If the retransmission timer expires, however, $D_{j-1}$ should actually fill the hole for $D_{j}$ because the client should not engage with $D_{j}$ in the chain replication semantics. Table II summarizes differences between TCP and TCP-MR from the perspective of $D_{j}$.

Also note that since the data segment comes directly from the client, $D_{j-1}$ may receive an ACK from $D_{j}$ even before its virtual transmission in Figure 9, if the following condition holds:

[TABLE]

[TABLE]

[TABLE]

Here, $T_{c,j}$ is the time it takes for a TCP segment to travel from the client to $D_{j}$, and $T_{p(j)}$ is the time for $D_{j}$ to transmit an ACK after receiving the segment. $T_{p(j-1)}$ is the time for $D_{j-1}$ to perform the virtual transmission after receiving a TCP segment from the client. Note that $T_{p(j-1)}>T_{p(j)}$ can happen because $T_{p(j-1)}$ includes the time to receive multiple TCP segments to build a HDFS packet whose default size is 64 KB. In the original Hadoop model, $D_{j-1}$ starts to transfer a HDFS packet to $D_{j}$ only after it completely receives it and notifies the Hadoop application so that it may start the transfer [1]. In contrast, $T_{p(j)}$ includes only the reception and ACK generation delays, which could be much smaller than $T_{p(j)}$. In case $D_{j-1}$ receives an ACK from $D_{j}$ before it starts the virtual transmission, it first stores the ACK number and processes it upon the virtual transmission, as if it received a normal ACK with the number.

V Implementation and Performance Evaluation

To prove the feasibility of the proposed concept and evaluate its performance, we implement it on a virtual machine platform using VMware Workstation. On a high-performance desktop with Intel i7-6700K CPU with 8 MB cache and 4.0 GHz clock, we create a virtual machine for each of the client, the data node, the SDN controller, and the Name Node. All are connected to a single SDN switch in a wheel-and-spoke topology. The SDN switch implements the OpenFlow switch in software as per OpenvSwitch 2.5.0 [20], and POX [21] serves as the SDN controller. As for HDFS configurations, the HDFS block size is set to 128 MB, and HDFS packet size to 64 KB. The file size to be stored is set to 128 MB. For each data node, the Linux kernel (Ubuntu 14.04) is augmented with TCP-MR. We use two metrics for evaluation, HDFS block transfer time and network link use, as we vary the replication factor from 2 to 5. For performance evaluation, we set the maximum kernel memory size for data reception to a sufficient value to prevent throughput drop from having the window size at data nodes reduced to zero. Specifically, we set writeMaxPackets to 20 HDFS packets of size 64 KB each, so net.core.rmem_max is set to 20$\times$64 KB = 1.3 MB.

V-A Block Transfer Time Reduction

Figure 10 shows the transfer completion times for chain and mirrored replications. ‘Data’ is the net data transfer time, and ‘total’ is the total time including the pipeline setup, etc. We observe that the implemented mirrored replication reduces the data transfer time by 25%, and the total time by 17%. Since the reduction applies to each HDFS data block, the ratio will be the same irrespective of the total file size. Although the absolute measured times themselves on our simple virtualized testbed may not be too relevant because on a real data center network they can further depend on the network capacity and link congestion levels, the reduction ratios are a meaningful indication of the expected improvement in the real data center environments.

V-B Traffic Saving

The parallel transfer by the SDN combined with the non-conventional TCP reception not only saves the time for data write but also the data traffic that crosses the network, which benefits other tasks that share the network resource. We define the total traffic load imposed on the data center network as the volume of the transferred data multiplied by the number of traversed links by it. Given the same data size for the two compared schemes, however, it suffices to count only the number of traversed links $L_{tot}$ for the comparison. In the traditional chain replication, it can be decomposed to

[TABLE]

If we let $c\equiv D_{0}$,

[TABLE]

Here, $L_{x,y}$ denotes the number of intra-datacenter links from $x$ to $y$, and $\{s_{i}\}_{i=1}^{k}$ are the (possibly overlapping) ordered list of switches from which the next descending starts towards the next data node in the pipeline. For example, in Figure 1, the list is $\{s_{1}=s_{c},s_{2}=s_{a},s_{3}=s_{c}\}$. Note that the first term in the summation is the number of ascending links going up in the hierarchy, whereas the second term is those descending from the switches to the data nodes. In Figure 1, for example, the former links are $\{5,7,8,9\}$ and the latter are $\{2,3,4,6,10,11,12\}$ (Link 1 is not in the data center). The idea of the mirrored replication is to eliminate the ascending links in the replication, i.e., the terms $L_{D_{j},s_{j+1}}\ (j\geq 1)$. Therefore, the traffic saving ratio in the proposed system is essentially the fraction of the ascending links in $L_{tot}$ and the traffic saving ratio is given as

[TABLE]

In the typical three-layer switching network that comprise edge (top-of-rack), aggregation, and core switches [22] as in Figure 1, we can consider two cases: the client is either outside or inside the data center network. In the former, $L_{c,s_{1}}=0$ (we count only the links in the data center network), and the data flow descends through three links. The latter case is further subdivided into four cases. First, if the client colocates with $D_{1}$ on the same server, $L_{D_{0},s_{1}}=L_{s_{1},D_{1}}=0$. Moreover, $L_{D_{1},s_{2}}$ cannot be eliminated since it should be the replication source. Second, if the client and $D_{1}$ are on the same rack but not on the same server, $L_{D_{0},s_{1}}=L_{s_{1},D_{1}}=1$. Third, if they are located in different racks, $L_{D_{0},s_{1}}=L_{s_{1},D_{1}}$ are either 2 or 3. Otherwise, the number of links can be anywhere between 1 and 3, for both ascending and descending. From $D_{4}$ and on, there is no constraint, so it is also anywhere between 1 and 3. Given these, Figure 11 shows that the average traffic reduction is substantial, ranging from 15 to 40% at the typical replication factor of 3, and likely more for larger replication factors.

VI Discussion

Our scheme, TCP-MR, is a novel approach in that not only it preserves the pipeline structure during the parallel transfer, as opposed to the previous solutions, in order to reduce data replication time and traffics in the network but also it does stipulate how the SDN switches should work in order to support TCP-MR in the current SDN standard [19]. Although it is known to be beneficial for data centers to adopt a SDN [23], its application usually are limited within the network resource management through multicast [16] [8], routing [15], switch selection [14], and so on. Meanwhile, in our scheme, SDN switches modify the TCP/IP header and forward the transparently mirrored TCP segments in order to support the TCP extension in a concrete and unprecedented way.

TCP-MR may be concerned with the absence of TCP flow control between the client and $D_{j}$ ($2\leq j\leq k$), however, this concern is trivial with the sufficient kernel memory for data reception at $D_{j}$. It prevents $D_{j}$ from dropping the successfully received out-of-order segments to provide the sufficient kernel memory for data reception with $D_{j}$. For instance, the mirrored segments from the client may sometimes get lost. Not surprisingly, $D_{j}$ tries to fill the hole from $D_{j-1}$ by sending the TCP ACK and getting the retransmitted segment. During this recovery process, the mirrored out-of-order segments from the client consumes the receive buffer at $D_{j}$ quickly and the receiver buffer becomes zero. However, the mirrored out-of-order segments keep coming because of the absence of TCP flow control between them. From this moment on, $D_{j}$ drops even the successfully received out-of-order segments due to no receive buffer and ask $D_{j-1}$ to retransmit them. With the sufficient receive buffer, however, $D_{j}$ does not discard any successfully received segments from the client. The sufficient kernel memory size for HDFS is writeMaxPackets$\times$HDFS packet size. writeMaxPackets is the maximum number of HDFS packets to send without the HDFS ACK in the application layer from all data nodes in the pipeline and it is 20 for default. HDFS packet is the unit by which HDFS in the application layer divides the data and its default size is 64 KB. Setting aside the kernel memory, which is set manually for performance evaluation, in TCP-MR is necessary for future work.

It is our future work to develop a congestion-aware routing application, tailored to TCP-MR in SDN to complement the absence of TCP congestion control between the client and $D_{j}$ ($2\leq j\leq k$). In the SDN architecture, network intelligence such as monitoring congested links and routing to avoid those links is easy to implement because the control and data planes are decoupled [23]. Still, TCP-MR has advantages over conventional TCP because paths (i.e., 10,11,12 in Figure 1) taken by TCP-MR is the subset of paths (i.e., 7,8,9,10,11,12 in Figure 1) taken by conventional TCP.

Some may argue that TCP-MR is only applicable to HDFS, however, it can be applied to any cluster file systems such as GFS and Windows Azure Storage as long as they exploit sequential TCP connections to replicate data. It may require some minor interfacing for adoption, however, there is no burden to application programmers for cluster file systems once it is adopted. As mentioned the above, we used HDFS as a guiding example.

TCP-MR is not comparable to the scheme establishing TCP subflows such as MPTCP because TCP-MR deals with one to many communication whereas MPTCP deals with one to one communication. TCP-MR could be augmented with MPTCP, however, it is beyond the scope of this paper.

VII Conclusion

This paper shows that through a TCP extension, the chain replication used in many cluster file systems can be performed in parallel among SDN-connected data nodes. The proposed concept preserves the chain replication semantics, which allows HDFS or Hadoop to work without modification. We show by using a prototype implementation that it improves the data transfer time by 25% for typical replication factors. Also, it saves 15 to 40% traffic for the typical replication factor of 3 and more for larger replication factors.