RCD: Rapid Close to Deadline Scheduling for Datacenter Networks

07/13/2017 ∙ by Mohammad Noormohammadpour, et al. ∙ 0

Datacenter-based Cloud Computing services provide a flexible, scalable and yet economical infrastructure to host online services such as multimedia streaming, email and bulk storage. Many such services perform geo-replication to provide necessary quality of service and reliability to users resulting in frequent large inter- datacenter transfers. In order to meet tenant service level agreements (SLAs), these transfers have to be completed prior to a deadline. In addition, WAN resources are quite scarce and costly, meaning they should be fully utilized. Several recently proposed schemes, such as B4, TEMPUS, and SWAN have focused on improving the utilization of inter-datacenter transfers through centralized scheduling, however, they fail to provide a mechanism to guarantee that admitted requests meet their deadlines. Also, in a recent study, authors propose Amoeba, a system that allows tenants to define deadlines and guarantees that the specified deadlines are met, however, to admit new traffic, the proposed system has to modify the allocation of already admitted transfers. In this paper, we propose Rapid Close to Deadline Scheduling (RCD), a close to deadline traffic allocation technique that is fast and efficient. Through simulations, we show that RCD is up to 15 times faster than Amoeba, provides high link utilization along with deadline guarantees, and is able to make quick decisions on whether a new request can be fully satisfied before its deadline.



There are no comments yet.


page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

I Introduction

Cloud Computing [5] has changed the way IT services are provisioned, managed, and delivered to users. Companies do not have to over-provision costly hardware infrastructure and personnel to offer large scale services. Cloud Computing allows services to scale as needed and companies only pay for the amount of resources used. It can be considered as a pool of computing resources designed to provide “a computing function as a utility” [6]. In addition, through statistical multiplexing, public clouds, such as Amazon EC2 [7], are able to provide such flexible and scalable services at minimum costs.

Datacenters are the infrastructure upon which cloud computing services are provided. To improve service provisioning, such infrastructures are usually spanned over multiple physical sites (multiple datacenters) closer to customers [8]. This also allows for higher reliability by keeping extra copies of user data on different datacenters. For example, Google’s G-Scale network connects its 12 datacenters [1]. Also, Amazon EC2 platform runs on multiple datacenters located in different continents.

Many applications require traffic exchange between datacenters to synchronize data, access backup copies or perform geo-replication; examples of which include content delivery networks (CDNs), cloud storage and search and indexing services. Most of these transfers have to be completed prior to a deadline which is usually within the range of an hour to a couple of days and can also be as large as petabytes [2]. In addition, links that connect these datacenters are expensive to build and maintain. As a result, for any algorithm used to manage these resources, it is desired to have the following features:

Efficiency: We want to maximize the transfer goodput. This means maximizing both link utilization and number of successfully finished transfers.

Speed: For large scale applications that have millions of users, large number of transfers have to be processed and allocated. It is crucial that our algorithm is fast enough to allocate new requests in a short time.

In [9], authors propose Deadline-aware Datacenter TCP (D2TCP) which increases the number of transfers that complete prior to their assigned deadlines by adjusting the transmission rate of such transfers based on their deadlines. Also, multiple previous studies have focused on improving the efficiency and performance of inter-datacenter communications through proper scheduling of transfers. In [1, 3, 2], authors propose B4, TEMPUS and SWAN. B4 and SWAN focus on maximizing link utilization through centralized traffic engineering and application of software defined networking. TEMPUS improves fairness by maximizing the minimum portion of transfers delivered to destination before the transfer deadlines. None of these schemes guarantees that admitted transfers are completed prior to their deadlines.

In [4], authors propose Deadline-based Network Abstraction (DNA) which allows tenants to specify deadlines for transfers, and a system called Amoeba which guarantees that admitted transfers are completed prior to the specified deadlines. When a request is submitted, Amoeba performs admission control and decides whether the new request can be satisfied using available resources. If a transfer cannot be completed prior to its deadline, Amoeba tries to reschedule a subset of previously admitted requests to push traffic further away out of the new request’s window. The admission process is performed on a first-come-first-served (FCFS) basis and requests are not preempted. In addition, each request is initially scheduled to finish as soon as possible.

In this paper, we propose RCD: a simple and fast traffic scheduler that minimizes the time required to perform the admission process. RCD does not have to move already admitted requests to decide whether a new request can be admitted. Also, it achieves high utilization by effectively using resources.

In the following sections, we first explain the problem of scheduling, present the rules based on which RCD operates, and compare RCD with Amoeba through simulations.

Ii The Scheduling Problem

As mentioned in several previous studies [3, 2], inter-datacenter traffic can be categorized into three different classes:

Highpri: This type of traffic is mainly initiated by users interacting with a website or online service. It is latency-sensitive as it directly affects user experience and has to be satisfied as soon as possible.

Background: Like previous traffic type, this one doesn’t have a deadline either. It consists of throughput-oriented large transfers that are not critical, and have the least priority.

Elastic: Traffic requests of this type have to be fully satisfied before their deadline. Deadlines can be either hard or soft. Finishing an elastic request with a hard deadline after its deadline is pointless while in a soft deadline case, value of the transfer drops based off a value function depending on how late the transfer is finished.

Now imagine we have two datacenters and connected using one single link. New traffic requests of types mentioned above are generated in datacenter destined for datacenter . Since highpri traffic is highly sensitive, it has to be sent on the link as soon as it is generated. The remaining bandwidth is first given to elastic requests and then background requests. The scheduling algorithm should decide how much bandwidth is given to each request at every time instance.

It is possible to estimate the volume of highpri traffic (it is usually between 5-15% of the link capacity)

[4]. As a result, we can set aside a percentage of the bandwidth on the link for this traffic and solve the scheduling problem for elastic and background traffic considering only the left over capacity. Elastic traffic is always allocated first as it has a higher priority. Background traffic goes through when there is no more elastic traffic to send. Throughout this paper, we focus on Elastic traffic and ways of allocating it.

Let us assume capacity is what is left after reserving the required bandwidth for highpri traffic. As in [4]

, our aim here is to maximize the number of elastic transfers that finish before their deadlines as well as link utilization. In this paper, we will use linear programming to implement traffic scheduling.

In the following sections, we propose our method and compare its time complexity with the method proposed in [4]. Finally, we discuss how the ideas presented next can be further developed and applied to a network case where in addition to volume and deadline, each request is identified with a source and destination node.

Iii Rapid Close to Deadline Scheduling

In order to flexibly allocate traffic with varying rates over time, we break the timeline into small timeslots. We do not assume an exact length for these timeslots as there are trade-offs involved. Having smaller timeslots can lead to large linear programs (LPs) which are time-consuming and inefficient to solve while having larger timeslots results in a less flexible allocation because the transmission rate is considered constant over a timeslot. In implementation of the previous study [4], a length of 3 to 5 minutes is used.

We schedule traffic for future timeslots because focusing only on current timeslot provides poor performance as we cannot provide long term promises and cannot guarantee that important transfers finish before their deadlines [2]. Assume we are allocating traffic for a timeline starting at representing current time and ending at which corresponds to the latest deadline for all submitted requests. New requests may be submitted to the scheduler at any time. Each request is identified with three parameters, and is shown as in which is the transfer volume, is the first deadline where value of the transfer starts to drop if finished after this time, and is the deadline after which finishing the transfer is pointless. For a request with a hard deadline , we have .

In order to schedule traffic, we can create and solve a linear program (LP) involving all of submitted requests with demand and capacity constraints populated based off link capacities and request volumes. This LP has to be solved every time a new request is submitted and can result in changing the allocation of already scheduled requests. The problem with this approach is its high complexity (solving such a large LP over and over is computationally inefficient) as the frequency of arrivals increases.

In this section we discuss our proposal for bandwidth allocation. The useful property of elastic traffic is that it does not matter how soon or late we finish the transfer as long as we finish it before its deadline. We use this characteristic to further improve the allocation process based on the following rules:

Rule 1: Similar to previous schemes [4], RCD does not support preemption. Preempting a request that is partly transmitted is wasteful. Also, it may result in thrashing if requests are consecutively preempted in favor of future requests.

Rule 2: To be fast, RCD does not change the allocation of already allocated traffic unless there is leftover bandwidth in current timeslot (). In which case it fetches traffic from the earliest timeslot that is not empty and sends it. This is done until either we fully utilize the current timeslot or there is no more elastic traffic to send.

In addition, we make the following simplifying assumptions. Study of the algorithm without these assumptions is left for future work.

  • Requests are instantly allocated upon arrival. They are allocated over timeslots for which . If a request cannot be allocated upon arrival, it is rejected.

  • All requests have a hard deadline.

  • Bandwidth used by highpri traffic is constant and can be estimated with high accuracy.

Figure 1: Elastic traffic and different allocations

Now let’s discuss an example considering our allocation rules. Fig. 1 shows three traffic allocation approaches and their behavior when a new traffic request is submitted:

Allocation 1: Tries to finish everything as soon as possible and does not change anything that is already allocated. This is the least complex approach; however, it fails to accommodate the new elastic request.

Allocation 2: Tries to finish everything as soon as possible but upon arrival of the new request, moves part of the already allocated request ahead to allocate the new request. Depending on how many already allocated requests are moved to accommodate the new request, this method has a variable chance of success. If it reallocates a large number of requests then it can get very slow as the frequency of arrivals increases. Conversely, it can have a small chance of success if only a few requests are reallocated.

Allocation 3: Based on our three rules, plans on finishing everything as late as possible, however, by sending traffic from future timeslots on , it results in everything finished as soon as possible. Does not move allocated requests, only sends parts of already allocated requests to utilize the available capacity. Every time a new request is submitted, a small linear program involving only the new request is solved.

When a new elastic request is submitted, RCD creates a small LP to schedule it. The size of this LP is . Assume the amount of bandwidth allocated for which at time is , the total demand is , and the deadline is . In addition, let’s assume is the residual capacity on the link at timeslot . We use the LP of equation 2 with the objective function of equation 1 to do the allocation. If following LP does not yield a feasible solution, we reject the request.

Now assume elastic requests are submitted to the scheduler in order. We want to show that upon arrival of , our allocation for previously admitted requests is in a way that we cannot increase the admission chance of by rearranging the allocation of already allocated requests. Let’s show the deadline of as and at any time , show the latest deadline of all admitted requests as .


Theorem 1: If we draw a vertical line at time in our traffic allocation, it is not possible to increase the free space before the line by moving traffic from left side of the line () to the right side ().

Figure 2: A general allocation used in theorem 1

Proof: Let’s assume we have the allocation shown in Fig. 2. To schedule all requests, we used the cost function of equation 1 which assigns a smaller cost to future timeslots. Assume we can move some traffic volume from left side to the right side. If so, this volume belongs to at least one of the admitted requests and that means we are able to decrease the allocation cost for that request even further. This is not possible because the LP in equation 2 gives the minimum cost solution. Therefore, we cannot move traffic from left side of the line to the right side. Doing so will either result in violation of link capacity or violation of a deadline.

Now let’s assume a new elastic traffic arrives. If it can be allocated on the residual link capacity then we can accept it. If not, based on theorem 1, there is no way we can shift already allocated traffic so that we can accommodate the new elastic traffic. Therefore, we simply reject the request.

There may be cases when we want to reserve some bandwidth for an important traffic request while we don’t have the traffic content yet. For example, at we find out an important traffic will arrive at and has to be fully transferred before midnight. We allocate such traffic the same as other elastic requests. This way we can be sure that when the traffic arrives, we have enough room to send it. If that important traffic is still not available by the time we finish sending all traffic requests that are allocated before it, we simply fetch traffic from the next closest request ahead of that transfer and if possible, push the important transfer to the next timeslot(s). Fig. 3 is an example of this case.

Figure 3: Reserving bandwidth for a future request

If the reserved traffic is still not available when we are too close to its deadline that we cannot finish it anymore, we free the reserved bandwidth in favor of future elastic requests.

Iv Simulation Results

We compare the performance and speed of RCD with Amoeba [4]. Other schemes, such as [3, 2], are deadline-agnostic and have an effective link utilization of less than [4]. Amoeba, on the other hand, only accepts requests when it can guarantee that the deadline can be fully met.

Simulation Setup: As mentioned earlier, we assume highpri traffic takes a fixed amount of bandwidth and allocate the leftover among elastic requests. Simulation is performed for 576 timeslots each lasting 5 minutes which is equal to 2 days. We performed the simulations three times and calculated the average.

Metrics: Percentage of failed elastic requests, average link utilization, and average allocation time are the three metrics measured and presented.


We generate elastic requests based off a Poisson distribution of rate

. The difference between the arrival time of requests and their deadlines follows an exponential distribution with an average of

timeslots. In addition, the demand of each request also follows an exponential distribution with an average of (a maximum of unit of traffic can be sent in each timeslot on the link).

Figure 4: Comparing Amoeba and RCD

Fig. 4 shows the aforementioned simulation metrics for both Amoeba and RCD. As can be seen, both algorithms result in similar failure rate and utilization. However, RCD achieves the same performance metrics with much less complexity: it is up to times faster than Amoeba. Also, the complexity of RCD grows very slowly as the frequency of arrivals increases: up to times while arrivals increase by a factor of .

With regards to the trend for time complexity as shown in Fig. 4, when the request arrival rate is small, most of the capacity is left unused. Therefore, Amoeba does not have to move already allocated requests to push in a new one. As the arrival rate increases, we see a higher utilization. Starting the arrival rate of , utilization gets close to and we can see a huge jump in the time complexity of Amoeba (by a factor of ). That is because Amoeba has to move around multiple already allocated requests to push in the new request.

For an arrival rate of requests per timeslot, we see that both algorithms drop almost half of the requests. This can happen as a result of a failure in the network. For example, when a datacenter is connected using only two links and one of them fails for a few timeslots. While Amoeba can get really slow, RCD is able to handle such situations almost as fast as when there is low link utilization.

Up until now, the focus was only on one link. The network case will be discussed in the next section.

V RCD in Network

For a single link, it was demonstrated how RCD allows for independent allocation of newly arriving requests: one only needs to know the residual link capacity to allocate a new request, and can be sure that there will be no performance degradation. For a network case however, it is not as simple. In this section we discuss one possible way of extending RCD for application in a network connecting multiple datacenters. Providing a detailed solution is beyond the scope of this paper and is identified as future work.

For a network case, each request is added a source and destination parameter and is shown as . We use the same rules as mentioned in section three. However, we have to augment the linear program in equation 2 to account for multiple paths and different capacity constraints of network links. Assume represents the set of network links and is the residual capacity of link at time . We want to allocate an elastic request with a source datacenter and a destination datacenter . For a node in the network, refers to set of links going out of and refers to set of links going into . We create the LP demonstrated in equation 4, which corresponds to a flow network, with the objective function in equation 3 to allocate bandwidth upon arrival of a new request.

This LP has a size of variables. For a network such as Google’s G-Scale network [1] with 19 links, assuming 5-minute timeslots and a deadline of 24 hours, this LP will have 5500 variables. Using a laptop with Intel Core-i5 2.5GHz CPU, such an LP can be solved in less than a second. We can further optimize this LP using the k-shortest paths method: only links on those paths will be considered in routing.

Based on the objective function in equation 3, similar to single link case, the resulting allocation will favor later timeslots. However, this time traffic is initially scheduled as late as possible on whole paths (not each single link). It is straight-forward to show that theorem 1 still holds: assuming no preemption, if a new request arrives it is not possible to move any previously allocated traffic further into the future to open up space before new request’s deadline.

Figure 5: Example of RCD allocation for network

Fig. 5 shows an example of network case allocation. As can be seen, resources are not allocated as late as possible for , however, the overall allocation cannot be pushed further into the future.

Utilizing unused resources in current timeslot by sending traffic from future timeslots is not as straight-forward anymore. A central network scheduler will have to decide how to do that. The idea is to look at the first traffic scheduled on timeline for all links, and if for some of the links, there is some unused bandwidth in current timeslot, pull some traffic from future timeslots and send it.

Figure 6: Multiple solutions while pulling traffic

In this case, since there are multiple links and paths, it may not be possible to propose an optimal solution. In a single link case, all requests will have to use the same resource: bandwidth of one link. In a network case, however, requests may use resources from different links. In addition, we may not be able to pull the first scheduled request on all links and send them in current timeslot. That’s because a request that is scheduled closest to current time on one link, may not be the closest to current time on next or previous link of the path.

Fig. 6 is an example of such cases. Assume and are two possible requests that may be submitted in , however, we don’t know which one it will be. At the beginning of , we can either choose to go with solution 1 or 2. We prefer the first solution if comes in, because the second solution will reject the request. For the same reason, we prefer the second solution if gets submitted. Our lack of knowledge prohibits us from making a definite optimal decision. We plan on studying this subject further in our future studies.

Vi Conclusions and Future Work

In this paper, we proposed RCD, a technique that makes fast scheduling of bandwidth resources possible for large transfers with specific deadlines, provides deadline guarantees, and allows for maximum bandwidth utilization. Our simulations demonstrate that for high arrival rates, RCD is up to 15 times faster than Amoeba, a system with similar objectives. RCD makes it possible to decide on request admission knowing only the residual bandwidth. We also proposed a method to reserve bandwidth for important requests with deadlines whose content is not available for delivery at current time. Finally, we proposed an idea on how RCD can be further extended and applied to a network connecting multiple datacenters. Further study of RCD considering soft deadlines, variable highpri traffic rate, application and simulation of RCD for a network case, and comparison of RCD for a network case with other schemes are identified as future work.


  • [1] S. Jain, A. Kumar, S. Mandal, J. Ong, L. Poutievski, A. Singh, S. Venkata, J. Wanderer, J. Zhou, M. Zhu, and J. Zolla, B4: Experience with a globally-deployed software defined WAN. In ACM SIGCOMM Computer Communication Review (Vol. 43, No. 4, pp. 3-14), ACM, 2013.
  • [2] S. Kandula, I. Menache, R. Schwartz, and S.R. Babbula, Calendaring for wide area networks. In Proceedings of the 2014 ACM conference on SIGCOMM (Vol. 44, No. 4, pp. 515-526), ACM, 2014.
  • [3] C.Y. Hong, S. Kandula, R. Mahajan, M. Zhang, V. Gill, M. Nanduri, and R. Wattenhofer, Achieving high utilization with software-driven WAN. In ACM SIGCOMM Computer Communication Review (Vol. 43, No. 4, pp. 15-26), ACM, 2013.
  • [4] H. Zhang, K. Chen, W. Bai, D. Han, C. Tian, H. Wang, H. Guan, and M. Zhang, Guaranteeing deadlines for inter-datacenter transfers. In Proceedings of the Tenth European Conference on Computer Systems (No. 20), ACM, 2015.
  • [5] M. Armbrust, A. Fox, R. Griffith, A.D. Joseph, R. Katz, A. Konwinski, G. Lee, D. Patterson, A. Rabkin, I. Stoica, and M. Zaharia, A view of cloud computing. Communications of the ACM (Vol. 53, No. 4, pp. 50-58), ACM, 2010.
  • [6] D. Kliazovich, P. Bouvry, and S.U. Khan, GreenCloud: a packet-level simulator of energy-aware cloud computing data centers. The Journal of Supercomputing (Vol. 62, No. 3, pp. 1263-1283), Springer, 2012.
  • [7] Elastic Compute Cloud (EC2) Cloud Server & Hosting - AWS.
  • [8] Y. Chen, S. Jain, V.K. Adhikari, Z.L. Zhang, and K. Xu, A first look at inter-data center traffic characteristics via yahoo! datasets. In Proceedings of IEEE INFOCOM (pp. 1620-1628). IEEE, 2011.
  • [9] B. Vamanan, J. Hasan, and T. N. Vijaykumar, Deadline-aware Datacenter TCP (D2TCP). ACM SIGCOMM Computer Communication Review (Vol. 42, No .4, pp. 115-126), ACM, 2012.