Online and Offline Greedy Algorithms for Routing with Switching Costs

Online and Offline Greedy Algorithms for Routing with Switching Costs

Roy Schwartz
Technion –- Israel Institute of Technology
schwartz@cs.technion.ac.il
   Mohit Singh
Georgia Institute of Technology
mohit.singh@isye.gatech.edu
   Sina Yazdanbod
Georgia Institute of Technology
syazdanbod@gatech.edu
Abstract

Motivated by the use of high speed circuit switches in large scale data centers, we consider the problem of circuit switch scheduling. In this problem we are given demands between pairs of servers and the goal is to schedule at every time step a matching between the servers while maximizing the total satisfied demand over time. The crux of this scheduling problem is that once one shifts from one matching to a different one a fixed delay is incurred during which no data can be transmitted.

For the offline version of the problem we present a approximation ratio (for any constant ). Since the natural linear programming relaxation for the problem has an unbounded integrality gap, we adopt a hybrid approach that combines the combinatorial greedy with randomized rounding of a different suitable linear program. For the online version of the problem we present a (bi-criteria) -competitive ratio (for any constant ) that exceeds time by an additive factor of . We note that no uni-criteria online algorithm is possible. Surprisingly, we obtain the result by reducing the online version to the offline one.

1 Introduction

In recent years the vast scaling up of data centers is fueled by applications such as cloud computing and large-scale data analytics. Such computational tasks, which are performed in a data center, are distributed in nature and are spread over thousands of servers. Thus, it is no surprise that designing better and efficient switching algorithms is a key ingredient in obtaining better use of networking resources. Recently, several works have focused on high speed optical circuit switches that have moving optical mirrors [6, 10, 27] or wireless circuits [13, 15, 28].

A common feature of many of these new switching models is that at any time the data can be transmitted on any matching between the senders and the receivers. However, once the switching algorithm decides to reconfigure from the current matching to a new different matching, due to physical limitations such as the time it takes to rotate mirrors, a fixed delay is incurred before data can be sent along the new reconfigured matching. This has led to significant study on obtaining good scheduling algorithms that take this delay into account [18, 21, 26]. The cost in switching between matchings makes the problem different when compared to the classical literature on scheduling in crossbar switching [5], which are usually based on Birkhoff von-Neumann decompositions. In this paper we focus on finding the schedule that sends as much data as possible in a fixed time window. We aim to design simple and efficient offline and online algorithms, with provable guarantees, for the scheduling problem that incorporates switching delays.

In the circuit switch scheduling problem, we are given a traffic demand matrix , where is the set of senders and is the set of receivers. denotes the amount of data that needs to be sent from sender to receiver . The ’s can also be seen as weights on the edges of a complete bipartite graph with vertex set . We are also given a time window and a switching time . At any time, the algorithm must pick a matching and duration for which the data is transmitted along the edges of the matching that still require data to be sent. When the algorithm changes to another matching for another duration , the algorithm must account for amount of time for switching between the two matchings. The total amount of time that data is sent along matchings as well as switching time between the matchings must total no more than . The objective is to maximize the total demand that is satisfied.

1.1 Our Results and Contributions

Our main contribution in this paper are simple and efficient algorithms for the offline and online variants of the circuit switch scheduling problem. The following theorem summarizes our result for the offline setting.

Theorem 1.

Given any constant , there is a polynomial time algorithm that returns a -approximation for the circuit switch scheduling problem.

We note that one can formulate two natural linear programming relaxation to the circuit switch scheduling problem. The first assigns a distribution over matchings for every time, whereas the second picks configurations with the additional knapsack constraint. Unfortunately, both have an unbounded integrality gap. Thus, a different approach must be used.

We adopt a hybrid approach that combines greedy and rounding of a special linear program to prove the above theorem. The former approach is employed when the switching delay is significantly smaller than the time window , while the latter approach is employed otherwise. It was already noted [26] that the offline variant of the circuit switch scheduling problem is a special case of maximizing a monotone submodular function given a knapsack constraint. Unfortunately, the above reduction requires a ground set of infinite size where each element in the ground set corresponds to a matching and a duration . We note that even if the durations are discretized we are still left with a ground set of exponential size that contains all matchings of the bipartite graph. Hence, the standard tight -approximation [23] for maximizing a monotone submodular function given a knapsack constraint cannot be applied. Our main technical ingredient is to show that despite the above difficulties, the hybrid approach we propose in the paper allows one to obtain the nearly optimal -approximation for the problem.

We also consider the online variant of the problem where the data matrix is not known in advance but is revealed over time. We consider a discrete time process where at each time step, we receive a new additional data matrix that needs to be transmitted. Moreover, we can choose a matching to transmit data at any time step with the constraint that whenever we change the matching from the previous step, no data is transmitted for steps. Our main contribution is a reduction from the online variant to the offline variant. To the best of our knowledge, such reductions with a minor loss in the guarantee are seldomly found. This results in a bi-criteria algorithm since the online algorithm is allowed a slightly larger time window than the optimum. We remark that such a bi-criteria approximation is necessary and we refer the reader to Appendix B for details. The following theorem summarizes the above.

Theorem 2.

Given a -approximation for the offline circuit switch scheduling problem and an integer , there exists an algorithm achieving a competitive ratio of for the online circuit switch scheduling problem which uses a time window of as compared to a time window of for the optimum.

Combining Theorem 1 and Theorem 2, we have the following corollary.

Corollary 2.1.

For any constant , there exists an algorithm achieving a competitive ratio of for the online circuit switch scheduling problem which uses a time window of as compared to a time window of for the optimum.

We note that the online algorithm in the above corollary runs in polynomial time. If one is not interested in the running time of the algorithm, but rather interested only in coping with an unknown future, then Theorem 2 gives an online algorithm whose competitive ratio is for any arbitrarily small constant (by assuming that the offline problem can be solved optimally, i.e., ).

1.2 Related Work

Venkatakrishnan et. al. [26] were the first to formally introduce the offline variant of the circuit switch scheduling problem. They focused on the special case that all entries of the data matrix are significantly small, and analyzed the greedy algorithm. Though it is known that the greedy algorithm does not provide any worst-case approximation guarantee for the general case of maximizing a monotone submodular function given a knapsack constraint, [26] proved that in the special case of small demand values they obtain an (almost) tight approximation guarantee. To the best of our knowledge, our algorithm gives the best provable bound for the offline variant of the circuit switch scheduling problem. A different related variant of the problem is when data does not have to reach its destination in one step, i.e., data can go through several different servers until it reaches its destination [18, 21, 26].

A dual approach is given by Liu et. al. [20], who aim to minimize the total needed time to transmit the entire demand matrix. Since our algorithm aims to maximize the transmitted data in a time window of , one can use our algorithm as a black box while optimizing over . It was proven in [19] that the problem of minimizing the time needed to send all of the data is NP-Complete. Hence, we can conclude that the circuit switch scheduling problem is also NP-Complete.

The problem of decomposing a demand matrix into matchings, i.e., the decomposition of a matrix into permutation matrices, was considered by [3, 8, 17, 22]. The special cases of zero delay [14] and infinite delay [24] have also been considered. Several related, but slightly different, settings include [7, 11, 25].

Regarding the theoretical problem of maximizing a monotone submodular function given a knapsack constraint, Sviridenko [23] (building upon the work of Khuller et. al. [16]) presented a tight -approximation algorithm. This tight algorithm enumerates over all subsets of elements of size at most three, and greedily extends each subset of size three, and returns the best solution found. Deviating from the above combinatorial approach of [16, 23], Badanidiyuru and Vondrák [2] and Ene and Nguyen [9] present algorithms that are based on an approach that extrapolates between continuous and discrete techniques. Unfortunately, as previously mentioned, none of the above algorithms can be directly applied to the circuit switch problem due to the size of the ground set.

The online version of the circuit switch scheduling problem has been considered from a queuing theory prospective, with delays [4] and without delays [12]. In these works, guarantees are proven under the assumption that the incoming traffic is from a known distribution or i.i.d. random variables. To the best of our knowledge, the online version has not been studied from a theoretical perspective.

2 Preliminaries

First, let us start with a formal description of the problem. We are given a complete bipartite graph where and are the sets of sending and receiving servers, a constant and a time window . We are also given the traffic demand matrix of the graph, , where denotes the amount of data that needs to be sent from sender to receiver . The ’s can be seen as weights on the edges of the complete bipartite graph. To simplify the notation, for an edge we abbreviate to . Let be the collection of all matchings in .

Definition 1.

The pair is called a configuration if and .

The term scheduling a configuration means sending data via the matching for a duration of time that equals . For simplicity of presentation, we also interpret a matching as a matrix where if and only if the entry of edge in equals . Note that for any edge the total data sent through would be and the total amount of data sent by the configuration would be (note that the minimum is taken element-wise). For simplicity of presentation we may use and interchangeably.

Switching from a configuration to another incurs a given constant delay , during which no transmission can be made. Let denote the collection of all possible configurations.

Definition 2.

A schedule of size is a subset such that . We say that requires a total time of to be scheduled.

The total time of the schedule includes both the time for sending data with each configuration and the delay in switching between them. This brings us to the definition of a feasible schedule.

Definition 3.

A schedule is feasible if .

In the offline setting, the goal is to find a feasible schedule that maximizes the data sent over the given time window of length . This problem can be formulated as follows:

(1)

We note that might be of infinite size. However, we use standard discretization techniques to limit the set of possible values of in our algorithms. We will discuss this with more detail in the later relevant sections. For now, assume is finite. To facilitate the notation and the analysis of our problem, we turn to a well-known class of functions called submodular functions.

Definition 4.

Given a ground set , a set function is a submodular function if for every : .

For our problem, define as:

Moreover, we denote by the marginal gain of the schedule if the configuration was added to it. It has been shown that is submodular (refer to Theorem in [26]). For the sake of completeness, we state the theorem. Note that is monotone if for every : .

Theorem 3 (Theorem 1 in [26]).

The function is a monotone submodular function.

For the online version of the problem, we use a discrete time model. Unlike the offline version, in the online setting we do not know the entire traffic matrix of the graph in the beginning. We start with as the demand matrix already present in the initial graph. At time an additional traffic matrix is revealed to the algorithm that includes new demands for data that need to be transmitted. In the online version of the problem sending configuration means that for the next time steps our algorithm is busy sending the matching . Switching a configuration to a different one incurs an additional delay of steps, during which no data can be sent. The incoming traffic matrices, at every step starting with the sending of and ending with the switching cost (a total of time steps), will accumulate and be added to the remaining traffic matrix of the graph.

3 Offline Circuit Switch Scheduling Problem

In this section, we prove Theorem 1 by giving an approximation algorithm for the circuit switch scheduling problem. Our algorithm is a combination of the greedy algorithm as well as a linear programming based approach. We first show that the greedy algorithm gives close to a -approximation if , the switching time, is much smaller than the time window. This is done in Section 3.1. In Section 3.2, we give a randomized rounding algorithm for a linear programming relaxation that gives a -approximation but runs in time exponential in number of matchings used in the optimal solution. While the natural linear program for the problem has unbounded gap, we show how to bypass this when the schedule has a constant number of matchings.

3.1 Greedy Algorithm

The greedy algorithm is as follows: at each step choose the configuration that maximizes the amount of data it sends per unit of time it uses. Formally, if is the remaining data demand in the graph after configurations were already chosen, the greedy algorithm will choose the following configuration to be used next:

(2)

The greedy algorithm continues to pick configurations until the first time the time constraint is violated or met. Algorithm 1 demonstrates this process. Let denote this number of steps and the schedule created after steps of this algorithm. The last chosen configuration may violate the time window budget and a natural strategy is to reduce its duration to the time window as is done in Step (11)-(12) of the algorithm. Indeed [26] analyzes this algorithm and shows that it performs well if each entry in data matrix is small. They also show that the above optimization problem can be solved using the maximum weight matching problem. We give a different analysis of the algorithm and show that it gives us a -approximation if .

Theorem 4.

Let denote the schedule as returned by the greedy algorithm and denote the optimal schedule. Then

1:Input:
2:Output:
3:. , .
4:while  do
5:     .
6:     .
7:     .
8:     .
9:end while
10:.
11:if   then
12:     
13:     if   then
14:         
15:     else
16:         
17:     end if
18:end if
19:return
Algorithm 1 Greedy Algorithm
Proof.

To analyze the algorithm, we first show that the objective of the optimal schedule of a slightly smaller time window is not much smaller than the optimum value of the optimum schedule for time window in Lemma 1. Indeed, the lemma states that given any schedule for time window , for example the optimal schedule, there exists a schedule with time window of a comparable objective.

Lemma 1.

For any schedule for a time window of , there is a schedule on a window of time such that .

Proof.

Let be the total time spent sending data and be the total time spent switching between configurations. Thus, . We prove that we can remove time from some configuration or we can remove an entire configuration from while reducing the objective by no more than fraction of the objective. Consider the two following cases for the given . If , we have . Thus there exists a configuration that we can deduct time from and at most lose . If . This means the number of configurations is at least . Each configuration on average sends data. Therefore, there is a configuration we can completely remove from our schedule such that total amount of lost data is at most . In both cases we can reduce the time taken by the schedule by at least and have a new schedule such that . ∎

Let denote the optimal solution with time window . From Lemma 1, we have . In the following lemma, we show that the output of the greedy algorithm is at least a -approximation of . The proof of the lemma follows standard analysis for greedy algorithms for coverage functions, or more generally submodular functions, except for the being careful at the last step. The proof appears in Appendix A. The proof of Theorem 4 now follows immediately.

Lemma 2.

If is the optimum schedule on time window , then

3.2 Linear Programming Approach for Constant Number of Configurations

In this section, we assume that we want to schedule at most a given constant number of configurations and prove the following theorem.

Theorem 5.

There exists a randomized polynomial time algorithm that given an integer and an instance of the circuit switch scheduling problem returns a feasible schedule whose objective, in expectation, is at least of the optimum solution that uses at most matchings. Moreover the running time of the algorithm is polynomial in .

Let us denote optimum schedule by . Note that, without the loss of generality, we can assume that we know what the ’s are. This can be done by a standard discretization of the possible values. Since, the number of configurations is constant this enumeration will be polynomial in to an accuracy of . The total data sent by a schedule is . However, in this section, it is more beneficial to consider the total data as the sum of total data sent over each edge. We model the total data by , where is the amount of data that was sent through edge in our graph. In the case of the optimum, and . We can formulate the following integer program for this problem.

(3)
(4)
(5)
(6)

Constraints (4) is to ensure that only one matching is considered in every time interval. Constraint (5) and (6) are to model the total data sent. We can relax this integer program to an LP by changing the to . The following lemma states that the relaxed linear program is a relaxation of our problem for the constant number of configurations.

Lemma 3.

Let be the value of an optimum solution to the LP, then

Proof.

If is our optimum answer, based on we will create a feasible answer to the LP. For every , we set . Clearly, the constraint 4 is satisfied since we picked exactly one matching for every interval. The constraints 5 and 6 is by definition satisfied since and the constraints are modeling this minimum. This argument shows that the optimum answer is feasible in the LP and since the LP is a maximization problem we can conclude that . ∎

The LP contains an exponential number of variables, since the number of matchings in the complete graph is exponential in the size of the graph. To be able to solve this program we need to introduce a separation oracle for the dual of this LP. The following program is the dual of our LP.

(7)
(8)
(9)

The Lemma 4 states the existence of a separation oracle.

Lemma 4.

The dual program admits a polynomial time separation oracle.

Proof.

Given a solution we are required to determine whether it is feasible and if not provide a constraint that is violated. We can easily determine whether all constraints of type (9) are satisfied, and if not provide one that is violated, by a simple enumeration over all edges . The same can be done for constraints of type (8) by enumerating over and for each compute a maximum weight matching in equipped with as edge weights and check whether the maximum weight matching has value at most . If the maximum weight matching exceeds the target value return the constraint that corresponds to and the maximum weight matching. ∎

Solving the linear program will provide us with a fractional solution . For any we have . This constraint of the LP creates a distribution over the matchings in time interval . We create a solution to the program from the fractional solution by a randomized rounding technique. We pick for the time interval with probability . Note that with probability no matching will be chosen for this time interval. A formal description of this rounding method is provided in Algorithm 2. Let denote the indicator random variable if matching is selected for the slot. Moreover, let denote the random variable that edge is present in the matching chosen in the slot. We have for each and and . Moreover, let denote the random variable that denotes the data sent along edge . Then we have . Observe that the random variables are independent.

1:Input:
2:Output:
3:for  do
4:     choose to be a random matching w.p. for the interval
5:end for
6:return
Algorithm 2 Randomized Rounding

The following Lemma 5 is implicit in Theorem 4 of Andelman and Mansour [1].

Lemma 5.

Let be independent Bernoulli random variables and let for some non-negative reals . Then

Applying the above lemma for each and random variables , we obtain that

Now summing over all edges, Theorem 5 follows. We are now ready to conclude our discussion of the offline variant of the circuit switch scheduling problem and prove Theorem 1.

Proof of Theorem 1.

Given , if then Theorem 4 gives us a -approximation. Otherwise, implying that at most configurations can be scheduled. In this case, Theorem 5 will give a -approximation. ∎

4 Online Circuit Switch Scheduling Problem

In this section, we prove Theorem 2. Recall that in the online setting, we consider a discrete time model111We could also consider a continuous time model where data matrices can arrive at any time and the algorithm can choose a matching at any time instant with a switching time when no data is sent. Our results apply to this model as well. The discrete model makes the presentation of the results easier. where an additional traffic matrix is revealed at every time . At every time step , a new set of traffic demands arrives and adds to the remaining traffic that has not been sent so far. We assume that the data matrix arriving at each step is integral and thus can be modeled as a multigraph. We denote the incoming traffic matrices as multigraphs (instead of ’s to simplify and familiarize the notation) and thus union of any two such graphs is defined by adding the number of copies of edges in the two constituents. Before proving the general theorem, we first consider the case when there is no delay while switching matchings, i.e., . Observe that in this case, the offline problem can be solved exactly and we show a -competitive algorithm for the online problem. The general reduction builds on this simple case along with the offline algorithm.

4.1 Without Configuration Delay

Observe that an online algorithm, in this case, will pick a set of matchings , instead of a schedule, that covers the maximum number of edges. At each step , the algorithm picks the maximum matching from the graph formed by the new edges that arrive, , and the remaining edges in the graph from previous steps which we denote by . The algorithm is formally given in Algorithm 3. Here denotes the set of all matchings on the complete bipartite graph with parts and . The objective of Algorithm 3 is , where denotes the number of edges in the matching . We denote the optimum solution by , We have the Theorem 6 for our approximation guarantee.

1:Input: Bipartite multigraphs on on where is disclosed at beginning of step .
2:Output:
3:, .
4:for  do
5:     .
6:     .
7:     , , .
8:end for
9:return
Algorithm 3 Online Greedy Algorithm without Delay
Theorem 6.

Algorithm 3 is -competitive for the online circuit switch scheduling problem without delays.

Proof.

Let denote the incoming edges for the first steps. We call this the input sequence for the first steps. We use induction on to prove the theorem. Specifically, we prove that for any input sequence of edges for steps, , we have

For , we know that the maximum matching has the biggest size of any matching in the graph. So, we have and thus the base case holds.

By the induction hypothesis, we have that for any input sequence of steps, we have where and are the output of the algorithm and the optimal solution, respectively.

Now, consider any input sequence . Recall, is the residual graph formed after first step of the algorithm, i.e. . At the next step, the algorithm will find the maximum matching in as its edge set. We build a new sequence of inputs and apply induction to it.

Let . Consider the optimum solution on this new input sequence. Let be the matchings that our algorithm picks given this new input sequence and the optimum matchings. Using the induction hypothesis we can write

First note that for . This is true since and are the maximum matchings of the same graph as can be seen inductively. We now show the following lemma that relates the optimum solution of the new instance to the original instance.

Lemma 6.

Proof.

The matchings is a feasible output for the optimum solution on the sequence. Therefore, we have as required. ∎

Using the induction hypothesis and the lemma we can write

Adding the inequality to both sides, we obtain

and the induction step follows.∎

4.2 With Configuration Delay

In this section, we assume switching between the configurations causes a delay of steps during which no data is sent. We also assume that we have access to a -approximation for the offline version of the problem. Note that we view the offline algorithm as a black-box. More formally, we assume we have an algorithm of the form Algorithm 4. To reiterate, is the given complete bipartite graph, is the traffic demand matrix, is the switching delay and is the size of the time window. Recall, that sending the configuration means that for the next steps we will only send data using matching .

1:Input:
2:Output:
Algorithm 4 Offline Algorithm for Circuit Switch Scheduling

Given a constant , the first step of the algorithm is to wait steps for data to accumulate and then run the offline algorithm on the accumulated data for time window . Let be the output of the offline algorithm. We run this schedule from time to . Meanwhile, we collect the incoming data matrices in these times. Figure 1 shows one step of the algorithm. At the next step, we consider the total remaining data that includes data that has not been scheduled so far from previous schedule(s) and newly arrived data in previous steps. We then run the offline algorithm on this data matrix to obtain a schedule for the next steps. More generally, we continue this process for every block of time steps. Algorithm 5 is the formal description of the algorithm. Note that this description is written as an enumeration over blocks of size . Recall that denotes the amount of data sent by any schedule .

1:Input: and data matrices on where revealed at beginning of step . Let .
2:Output:.
3:, .
4:for   do
5:     .
6:     .
7:     , .
8:end for
9:return
Algorithm 5 Online Greedy with Delay
Proof of Theorem 2.

We use a coefficient and optimize in the end. We prove the theorem by induction on the number of the blocks, i.e., and will follow along the lines of proof of Theorem 6. As we did in the proof of Theorem 6, we consider the incoming traffic as sequences. But in this case we define a sequence , where is the input of block . For , let the optimum schedule be and the algorithm’s schedule be . Figure 1 shows this setting.

Figure 1: Basis of the induction. The crossed out block is the waiting period of our algorithm

Using Lemma 1, there exists a schedule with the property that . Since is the output of our offline algorithm we can write and the basis of the induction is proven.

For , again let be the optimum schedule and be the output of our algorithm where each is the schedule on th block. Let be the optimum schedule for the first block and our algorithm’s schedule on that block. Refer to Figure 2 for an illustration of this setting.

Figure 2: Step of the induction.

Consider the new input sequence . Let the optimum schedule on the new input sequence be and the algorithm’s schedule be . From the induction hypothesis, we have

Note that for and thus

As in the proof of Lemma 6, a candidate schedule for the new instance is to consider and ignore the data sent by the algorithm in the schedule if it appears in any of the optimal matchings. Thus we obtain that

For based on our basis argument we can find such that . To sum up, we have the two following inequalities:

and

Rewriting the first inequality, we have

Adding the times the second inequality

Optimizing the we get and thus proving the theorem.

References

  • Andelman and Mansour [2004] Andelman, N. and Mansour, Y. (2004). Auctions with budget constraints. In Scandinavian Workshop on Algorithm Theory, pages 26–38.
  • Badanidiyuru and Vondrák [2014] Badanidiyuru, A. and Vondrák, J. (2014). Fast algorithms for maximizing submodular functions. In Proceedings of the twenty-fifth annual ACM-SIAM symposium on Discrete algorithms, pages 1497–1514.
  • Barman [2015] Barman, S. (2015). Approximating nash equilibria and dense bipartite subgraphs via an approximate version of caratheodory’s theorem. In Proceedings of the Forty-seventh Annual ACM Symposium on Theory of Computing, STOC ’15, pages 361–369.
  • Celik et al. [2016] Celik, G., Borst, S. C., Whiting, P. A., and Modiano, E. (2016). Dynamic scheduling with reconfiguration delays. Queueing Systems, 83(1-2):87–129.
  • Chang et al. [1999] Chang, C.-S., Chen, W.-J., and Huang, H.-Y. (1999). On service guarantees for input-buffered crossbar switches: a capacity decomposition approach by birkhoff and von neumann. In 1999 Seventh International Workshop on Quality of Service (IWQoS’99), pages 79–86.
  • Chen et al. [2014] Chen, K., Singla, A., Singh, A., Ramachandran, K., Xu, L., Zhang, Y., Wen, X., and Chen, Y. (2014). Osa: An optical switching architecture for data center networks with unprecedented flexibility. IEEE/ACM Transactions on Networking, 22(2):498–511.
  • Dasylva and Srikant [1999] Dasylva, A. and Srikant, R. (1999). Optimal wdm schedules for optical star networks. IEEE/ACM Transactions on Networking, 7(3):446–456.
  • Dufossé et al. [2018] Dufossé, F., Kaya, K., Panagiotas, I., and Uçar, B. (2018). Further notes on birkhoff–von neumann decomposition of doubly stochastic matrices. Linear Algebra and its Applications, 554:68 – 78.
  • Ene and Nguyen [2017] Ene, A. and Nguyen, H. L. (2017). A nearly-linear time algorithm for submodular maximization with a knapsack constraint. CoRR, abs/1709.09767.
  • Farrington et al. [2010] Farrington, N., Porter, G., Radhakrishnan, S., Bazzaz, H. H., Subramanya, V., Fainman, Y., Papen, G., and Vahdat, A. (2010). Helios: a hybrid electrical/optical switch architecture for modular data centers. ACM SIGCOMM Computer Communication Review, 40(4):339–350.
  • Fu et al. [2013] Fu, S., Wu, B., Jiang, X., Pattavina, A., Zhang, L., and Xu, S. (2013). Cost and delay tradeoff in three-stage switch architecture for data center networks. In 2013 IEEE 14th International Conference on High Performance Switching and Routing (HPSR), pages 56–61.
  • Georgiadis et al. [2006] Georgiadis, L., Neely, M. J., Tassiulas, L., et al. (2006). Resource allocation and cross-layer control in wireless networks. Foundations and Trends® in Networking, 1(1):1–144.
  • Hamedazimi et al. [2014] Hamedazimi, N., Qazi, Z., Gupta, H., Sekar, V., Das, S. R., Longtin, J. P., Shah, H., and Tanwer, A. (2014). Firefly: A reconfigurable wireless data center fabric using free-space optics. In ACM SIGCOMM Computer Communication Review, volume 44, pages 319–330.
  • Inukai [1979] Inukai, T. (1979). An efficient ss/tdma time slot assignment algorithm. IEEE Transactions on Communications, 27(10):1449–1455.
  • kandula et al. [2009] kandula, s., Padhye, J., and bahl, v. (2009). Flyways to decongest data center networks. Proc. of Hot Nets.
  • Khuller et al. [1999] Khuller, S., Moss, A., and Naor, J. S. (1999). The budgeted maximum coverage problem. Information processing letters, 70(1):39–45.
  • Kulkarni et al. [2017] Kulkarni, J., Lee, E., and Singh, M. (2017). Minimum birkhoff-von neumann decomposition. In International Conference on Integer Programming and Combinatorial Optimization, pages 343–354.
  • Li et al. [2017] Li, C., Mukerjee, M. K., Andersen, D. G., Seshan, S., Kaminsky, M., Porter, G., and Snoeren, A. C. (2017). Using indirect routing to recover from network traffic scheduling estimation error. In Proceedings of the Symposium on Architectures for Networking and Communications Systems, ANCS ’17, pages 13–24.
  • Li and Hamdi [2003] Li, X. and Hamdi, M. (2003). On scheduling optical packet switches with reconfiguration delay. IEEE Journal on Selected Areas in Communications, 21(7):1156–1164.
  • Liu et al. [2015] Liu, H., Mukerjee, M. K., Li, C., Feltman, N., Papen, G., Savage, S., Seshan, S., Voelker, G. M., Andersen, D. G., Kaminsky, M., et al. (2015). Scheduling techniques for hybrid circuit/packet networks. In Proceedings of the 11th ACM Conference on Emerging Networking Experiments and Technologies, page 41.
  • Liu et al. [2017] Liu, L., Gong, L., Yang, S., Xu, J., and Fortnow, L. (2017). Better algorithms for hybrid circuit and packet switching in data centers. arXiv preprint arXiv:1712.06634.
  • Mirrokni et al. [2017] Mirrokni, V., Leme, R. P., Vladu, A., and wai Wong, S. C. (2017). Tight bounds for approximate Carathéodory and beyond. In Proceedings of the 34th International Conference on Machine Learning, volume 70, pages 2440–2448.
  • Sviridenko [2004] Sviridenko, M. (2004). A note on maximizing a submodular set function subject to a knapsack constraint. Operations Research Letters, 32(1):41–43.
  • Towles and Dally [2003] Towles, B. and Dally, W. J. (2003). Guaranteed scheduling for switches with configuration overhead. IEEE/ACM Transactions on Networking, 11(5):835–847.
  • Vargaftik et al. [2016] Vargaftik, S., Barabash, K., Ben-Itzhak, Y., Biran, O., Keslassy, I., Lorenz, D., and Orda, A. (2016). Composite-path switching. In Proceedings of the 12th International on Conference on emerging Networking Experiments and Technologies, pages 329–343.
  • Venkatakrishnan et al. [2018] Venkatakrishnan, S. B., Alizadeh, M., and Viswanath, P. (2018). Costly circuits, submodular schedules and approximate carathéodory theorems. Queueing Systems, pages 1–37.
  • Wang et al. [2010] Wang, G., Andersen, D. G., Kaminsky, M., Papagiannaki, K., Ng, T., Kozuch, M., and Ryan, M. (2010). c-through: Part-time optics in data centers. In ACM SIGCOMM Computer Communication Review, volume 40, pages 327–338.
  • Zhou et al. [2012] Zhou, X., Zhang, Z., Zhu, Y., Li, Y., Kumar, S., Vahdat, A., Zhao, B. Y., and Zheng, H. (2012). Mirror mirror on the ceiling: Flexible wireless links for data centers. ACM SIGCOMM Computer Communication Review, 42(4):443–454.

Appendix A Missing Proofs

We recall Lemma 2.

Lemma.

If is the optimum schedule on time window , then

Proof.

Let be the set of configurations picked by the greedy algorithm before the update steps (11)-(12) in which is reduced to to obtain schedule . Note that could be negative, however, for now assume . For ease of notation we also define for each . Thus . We also let to be the scheduled formed by picking the first configurations in . We now show the following claim.

Claim 1.

For any configuration picked by the greedy algorithm in schedule at any , we have

Proof.

First let us concentrate on the case when . Then . Note that since is a matching that maximizes , for any other and any we can write

or equivalently, for each and configuration , we have

(10)

For any , consider the following

(11)

The last inequality comes from the submodularity of the function. Summing Inequality (10) over all configurations in and using that the has a time window , we obtain that

Combining the above inequality with Inequality (11), we obtain

(12)

Thus if , the claim follows since we have . When , first observe that since the data sent along a single matching is a concave function of the time it is used in a configuration, we have that

This completes the proof of the claim. ∎

First note we can write the following equality:

We will now derive the approximation factor. We have that

This will result in the following inequality.

Continuing for the remaining steps we will have:

Now using , we can write:

Since ,

Thus concluding the theorem for