Optimal Scheduling of Age-centric Caching: Tractability and Computation

03/21/2020 ∙ by Ghafour Ahani, et al. ∙ Uppsala universitet Agency for Science, Technology and Research 0

The notion of age of information (AoI) has become an important performance metric in network and control systems. Information freshness, represented by AoI, naturally arises in the context of caching. We address optimal scheduling of cache updates for a time-slotted system where the contents vary in size. There is limited capacity for the cache and for making content updates. Each content is associated with a utility function that is monotonically decreasing in the AoI. For this combinatorial optimization problem, we present the following contributions. First, we provide theoretical results settling the boundary of problem tractability. In particular, by a reformulation using network flows, we prove the boundary is essentially determined by whether or not the contents are of equal size. Second, we derive an integer linear formulation for the problem, of which the optimal solution can be obtained for small-scale scenarios. Next, via a mathematical reformulation, we derive a scalable optimization algorithm using repeated column generation. In addition, the algorithm computes a bound of global optimum, that can be used to assess the performance of any scheduling solution. Performance evaluation of large-scale scenarios demonstrates the strengths of the algorithm in comparison to a greedy schedule. Finally, we extend the applicability of our work to cyclic scheduling.



There are no comments yet.


This week in AI

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

1 Introduction

The research interest in age of information (AoI) has been rapidly growing in the recent years. The notion of AoI has been introduced for characterizing the freshness of information [1]. AoI is defined as the amount of time elapsed with respect to the time stamp of the information received in the most recent update. The AoI grows linearly between two successive updates. For a wide range of control and network systems, e.g., status monitoring via sensors, AoI has become an important performance metric.

The AoI aspect arises naturally in the context of caching for holding content items with dynamic updates [2]. Consider a local cache for which updates of content items take place via a network such as a backhaul link in wireless systems. Rather than obtaining content items via the backhaul network, users can download them from the cache if the content items of interest are in the cache, thus reducing network resource consumption. Due to limited backhaul network capacity, not all content items in the cache can be updated simultaneously. Hence, at a time point, the performance of caching depends on not only the content items currently in the cache, but also how old these items are; the latter can be characterized by AoI.

We address optimal scheduling of cache updates, where the utility of the cache is based on AoI. The system under consideration is time-slotted, with a given scheduling horizon. The content items are of different sizes. Updating the cache in a time slot is subject to a capacity limit, constraining which content items that can be downloaded in the same time slot. Moreover, the cache itself has a capacity. For each content item, there is a utility function that is monotonically decreasing in the AoI, and because the content items differ in popularity, the utility function is content-specific. If a content item is not in the cache, the utility value is zero. For every time slot, the optimization decision consists of the selection of the content items to be updated, subject to the network and cache capacity constraints. Thus the problem falls in the domain of combinatorial optimization. The objective is to find the schedule maximizing the total utility over the scheduling horizon.

Our work consists in the following contributions toward understanding and solving the outlined AoI-driven cache optimization problem (ACOP).

  • We provide theoretical results of problem tractability. Specifically, for the special case of uniform content size, the global optimum of ACOP admits polynomial-time tractability (even if the problem remains combinatorial optimization). We establish this result via mapping the problem to a graph, and proving that the optimal schedule is a minimum-cost flow in the graph. For non-uniform content size, the problem is NP-hard due to the knapsack structure, except for two contents. Thus our results settle the boundary of problem tractability.

  • We derive an integer linear programming (ILP) formulation for ACOP in its general form, enabling the use of off-the-shelf optimization solvers to approach the problem. This is particularly useful for examining the performance of sub-optimal solutions for small-scale scenarios, for which the global optimum is computed via ILP.

  • We derive a mathematical reformulation, by considering sequences representing the evolution of the AoI over time for each content item. The reformulation enables a scalable solution approach. Specifically, we present a column generation algorithm that addresses the linear programming (LP) version of the reformulation, by keeping only a small subset of possible sequences and augmenting the subset based on optimality condition. To obtain integrality, we present a rounding concept based on disjunctions rather than on fractional variables, such that column generation is repeated for improvement after rounding. Performance evaluation demonstrates the strengths of the repeated column generation algorithm in comparison to a greedy schedule. Moreover, as the algorithm provides an optimality bound in addition to a problem solution, it is possible to gauge performance even if the global optimum is out of reach. Using the bound, our results show the algorithm consistently yields near-to-optimal solutions for large-scale problem instances.

  • Finally, we discuss the extension of our results to cyclic scheduling, i.e., the schedule is repeated in a cyclic manner. In this case, the AoI values at the beginning of the schedule are determined by the caching updates made later in the schedule. We present adaptations, such that the tractability analysis, the ILP formulation, and the repeated column generation algorithm all remain applicable.

2 Related Work

The notion of AoI was introduced in [1]. Generalizations to multiple information sources have been studied in [3]. The aspect of queue management has been introduced in [4, 5, 6]. Early application scenarios of AoI include channel information [7] and energy harvesting [8]. In [9], the authors address optimal update policy for AoI, and provide conditions under which the so called zero-wait policy is optimal. In [10], the authors have considered AoI under a pull model, where information freshness is relevant (only) when the use interest arises. For transmission scheduling with AoI minimization, [11]

considers a system model with error probability of transmission, and

[12] proposes algorithms for multiple link scheduling with presence of interference. We refer to [13] for a comprehensive survey of research on AoI. Below we outline very recent developments that demonstrate a rapidly growing interest in the topic.

One line of research has consisted in sampling, scheduling and updating policies for various system models that have queuing components and AoI as the performance objective. In [14], the scenario has multiple source-destination pairs with a common queue, along with a scheduler. In [15]

, the authors have investigated optimal sampling strategies addressing AoI as well as error in estimating the state of a Markov source. The system model in

[16] combines stochastic status updates and unreliable links; the authors make an approximation of the Whittle index and derive a solution algorithm thereby. The study in [17] considers an energy-constrained server that is able to harvest energy when no packet from the source requires service. The notion of preemption has been addressed in [18, 19] for a single flow in a multi-hop network with preemptive intermediate nodes, and multiple flows such that different flows preempt each other, respectively. The authors of [20] have proposed the use of dynamic pricing to provide AoI-dependent incentives to sampling and transmission. For network control systems (NCPs), [21] has addressed sampling and scheduling, relating estimation error to AoI, and [22] has focused on approximately optimal scheduling strategy for multi-loop NCPs, where the centralized scheduler takes a decision based on observed AoI.

Another line of research arises from the introduction of AoI to various applications and networking context. By including energy constraints, [23] extends [12] for optimal link activation for AoI minimization in wireless networks with interference. The study in [24] is similar to [12] and [23] in terms of the scheduling aspect and the presence of interference, however the system model considers AoI for all node pairs of the network, and the emphasis is on performance bounds. The work in [25] considers a two-way data exchanging system, where the AoI is constrained by the uplink transmission capability and the downlink energy transfer capability. Application of the AoI concept in camera networks where information from multiple cameras are correlated has been presented in [26]. For remote sensor scenarios, [27] has studied AoI-optimal trajectory planning for unmanned aerial vehicles (UAVs). For distributed content storage, AoI has been applied to address the trade-off between delay and data staleness [28]. In [29], the authors have studied AoI with respect to orthogonal multiple access (OMA) and non-orthogonal multiple access (NOMA), and revealed that NOMA, even though allowing for better spectral efficiency, is not always better than OMA in terms of average AoI.

AoI has also appeared as the performance metric in using machine learning as a tool in communication systems. In

[30], online adaptive learning has been used for addressing error probability in the context of AoI minimization. In [31], learning is used for optimal data sampling to minimize AoI.

For AoI-aware caching, research results are available in [2, 32]. The general problem setup, i.e., what to optimize and when to update with an objective function defined by AoI, reminds the system model we consider. However, our work has significant differences to [2] and [32]. First, it is (implicitly) assumed in [2] and [32] that the items are of uniform size. We do not have this restriction and hence in our problem, which items can be updated at a time are determined by the sizes as well as the capacity limits. Second, the works in [2] and [32] derive updating policy with respect to expected AoI, whereas our problem falls into the domain of combinatorial optimization and we use methods thereof to solve the problem. Moreover, the problems in [2, 32] are approached by either assuming given inter-update intervals of each item or the total number of updates of each item. In our work, these entities remain optimization variables throughout the optimization process.

3 Preliminaries

3.1 System Model

Consider a cache of capacity . The content items for caching form a set . Item is of size . Time is slotted, and the time horizon consists of a set of time slots . In each time slot, the cache can be updated via a backhaul communication link whose capacity is denoted by .

The AoI of an item in the cache is the time difference between the current slot and the time slot in which the item was most recently updated. Each time the item is updated, the AoI is zero, i.e., maximum information freshness. The AoI then increases by one for each time slot, until the item gets updated again. The value of having item cached is characterized by a utility function that is monotonically decreasing in its AoI. If the item is not in the cache, its utility is zero. The utility function is item-specific to reflect, for example, the difference in the popularity of the content items.

The AoI-driven cache optimization problem, or ACOP in short, is to determine which content items to store and update in each time slot, such that the total utility of the cache over the time horizon is maximized, subject to the capacity limits of the cache and the backhaul. Later in Section 8, we will consider the case of optimizing a cyclic schedule of cache updates.

Notation: In addition to regular mathematical style of entities, we adopt the following notation style in the paper. Sets are denoted using calligraphic style. Moreover, boldface is used to denote the vector form of the entity in question.

Remark 1.

Our system model is not necessarily restricted to caching scenarios. For example, consider a system monitoring a number of remote sites, for which the information generated differ in size. The amount of information that can be sent to the monitoring center is constrained by the network bandwidth, and the task is optimal scheduling of updates to maximize utility as a function of AoI. This setup corresponds to ACOP with redundant cache capacity.

3.2 Greedy Solution

For a combinatorial problem, a simple and greedy strategy typically serves as a reference solution. For ACOP, a greedy solution is to maximize the total utility of each time slot by simply considering the utilities of the individual items if they are added to the cache or become updated in the cache. This solution for a generic time slot is given in Algorithm 1.

Input: , , current cache , current AoI

Algorithm 1 Greedy solution for a generic time slot
1:  ; ; ;
2:  while  and  do
5:     if  then
6:        Update cache item
8:     else
9:        if  and  then
10:           while  do

In the algorithm, is the candidate set of items for caching, is the residual cache capacity, and is used to keep track of those items that are currently in the cache and selected for update. The item maximizing the utility, if added or updated, is considered and then removed from . If is in the cache, it gets updated and recorded in . Otherwise, if the remaining downloading capacity admits and there will be sufficient residual capacity by removing cached items except those in , the algorithm removes items in ascending order of their utility values with respect to the current AoI, followed by adding item . The process ends when the candidate set becomes empty.

4 Problem Complexity Analysis

ACOP apparently is in the domain of combinatorial optimization. Thus it is important to gain understanding of problem complexity, as many combinatorial problems are NP-hard (e.g., the traveling salesman problem) whereas others are tractable in terms of computing global optimum in polynomial time (e.g., matching in graphs). In this section, we present proofs to establish the boundary of tractability for ACOP. Namely, for uniform item size, ACOP is tractable, otherwise it is NP-hard except for the very special case of two content items. We denote ACOP with uniform item size by ACOP.

As the capacity limits of the cache and the backhaul link imply constraints of knapsack type, it is not surprising that ACOP is NP-hard in general, with a proof based on the binary knapsack problem. This result is formalized below.

Theorem 1.

ACOP is NP-hard.


Consider a knapsack problem with items and knapsack capacity . Denote the value and weight of item by and , respectively. We construct an ACOP instance by setting (i.e., single time slot), , , and . The utility function is defined such that . Downloading a content item to the cache amounts to selecting the corresponding item in the knapsack problem. Obviously, the optimal solution maximizing the total utility of the cache leads to the optimum of the knapsack problem, and the result follows. ∎

Consider ACOP where all items are of the same size. In this case, both cache and backhaul capacities can be expressed in the number of items. Even though the problem is still combinatorial along the time dimension, we prove it is tractable, i.e., the global optimum can be computed in polynomial time. The key is to transform the problem into a minimum-cost flow problem  [33] in a specifically constructed graph. In the following, we assume that the backhaul capacity is non-redundant, i.e., .

In optimization, a network flow problem is defined in a (directed) graph; each arc has a linear cost in the arc flow that is also subject to an upper bound and a lower bound. The latter is often zero. There are one or more source nodes and sink nodes, each generating and receiving a specified amount of flow, respectively. The total amount of flow generated at the source nodes equals that to be received by the sink nodes. The optimization task is to determine how flows go from the source nodes to the sink nodes, such that the total flow cost is minimum, subject to flow balance at the nodes as well as the upper and lower bounds of the arcs.

Figure 1: An illustration of the network flow problem corresponding to ACOP.

The graph we construct for proving the tractability of ACOP is illustrated in Fig. 1. For clarity, we illustrate the construction for two items and the first two time slots. The construction of the remaining time slots follows the same pattern. There is one source node, , and one sink node . The source node generates flow units to be sent to the sink through the network.

The underlying rationale is as follows. There are three types of nodes. First, for each item and time slot , node represents that item is in the cache in slot with age . Second, nodes act as the collection points for all items except those to be kept in the cache in time slot . Third, nodes , are collection points for items to be added or updated in the cache.

Each arc of the graph is associated with tuple , where is the cost per flow unit, and and are the lower and upper bounds of the arc flow, respectively. These values are shown in the figure, however not for the arcs entering the nodes due to lack of space. For these arcs, the tuple is . Moreover, we do not show explicitly the tuples for some arcs of time slot two for the sake of clarify; the tuple values of any such arc are the same as for the corresponding arc in the previous time slot.

Let us consider the first time slot with any integer flow solution. The flow units leaving source have to either enter or . Note the maximum number of units entering has upper bound , allowing at most items to be added or updated. Node has an arc of capacity one to node of item , . Having a flow of one unit on the arc corresponds to putting item in the cache, generating utility that is equivalent to an amount of in cost minimization. There will be such items111For ACOP, the downloading capacity is always fully used, because adding or updating items always leads to better utility (or more negative cost for the minimum-cost flow problem).. The flow units from to correspond to the items not cached in time slot one. Note the flow lower bound of arc is , meaning that at least flow units must enter node , i.e., at least items are outside the cache.

For a generic time slot and item , if one unit of flow enters node , then the flow has two choices by graph construction. Either it goes to node , representing that item remains in the cache, with AoI for the next time slot and the corresponding utility, or it has to be sent to the collection node . The latter case represents that the item is removed from the cache, and, from , the item either enters via node (i.e., item is downloaded again to the cache with AoI zero), or stays outside the cache by entering collection node .

Remark 2.

In Fig. 1, some of the nodes (and hence also their adjacent arcs) are redundant. For example, no flow will enter nodes and , because the AoI will never attain two or three in time slot two. These nodes are however kept in the figure to better reflect the general structure of graph construction.

Lemma 2.

The optimal solution to ACOP corresponds to an integer flow solution for the constructed graph with equivalent objective function value.


Consider an optimal solution to ACOP. For time slot one, items are downloaded, and the flow on arc is set to , whereas units of flow are put on . For each downloaded item , we set the flow on to be exactly one unit, generating the (negative) cost of .

Consider a generic time slot . For the next time slot , denote the number of deleted items by , and the numbers of items updated and added by and , respectively. Denote by the number of items not in the cache in the ACOP solution for time slot . Thus there are flow units on arc . If a cached item in the ACOP solution is kept in the cache in , we set one flow unit on the arc representing this state. That is, if the AoI of is , we set one flow unit on arc , generating a (negative) cost of . For any item that is either to be deleted or updated for , we set one flow unit on arc . Thus there are flow units in total arriving via these arcs, and the total amount of incoming flow to equals .

We set flow units on arc . Next, observe that , because at optimum the backhaul capacity is always fully utilized. From , for any item that is either updated or added to the cache in , we set one unit flow on arc , giving the (negative) cost of . By flow balance, the amount of outgoing flow on arc equals , and we need to prove is between the flow bounds and . If the cache is full, then clearly , and the conclusion follows. Suppose the cache is not full (this occurs at the first few time slots if downloading capacity is much smaller than cache capacity ), such that the spare capacity can hold items. In this case, at optimum, if , then each deleted item will be replaced by an added item, as otherwise it is optimal not to delete. Let . We have . Moreover, as items are cached, the number of items outside the cache . Thus = . Note that , thus . That follows simply from that .

In addition to the above, it is straightforward to see that the flow construction satisfies the flow balance at nodes representing the items’ possible AoI values, and adheres to the bounds of their adjacent arcs. At the last stage, for all cached items in slot , we set one unit of flow from the node representing the AoI to . These flow units, together with those on arc that represent the number of items outside the cache, arrive the destination node with a total flow of . Hence the lemma. ∎

Lemma 3.

The optimal integer flow solution in the constructed graph corresponds to a solution of ACOP with equivalent objective function value.


For any integer flow solution, all arcs adjacent to nodes , have either zero or one unit of flow. Moreover, obviously an optimal flow will have flow units on arcs .

Consider the flows on the outgoing arcs of node . Exactly arcs have one unit of flow, and the other arcs have zero flow. For any arc with one flow unit, the corresponding solution of ACOP downloads and caches item for time slot one. Doing so for all time slots gives the ACOP solution in terms of the items that are added to or updated in the cache over time. Moreover, any arc with a flow unit means to keep the item in the cache from to . Thus the flow solution leads to a caching solution for ACOP. Note that the solution is feasible with respect to cache capacity. This is because there are at least flow units on arc , and by flow balance, for any time slot , there are at most flow units in total on the incoming arcs of . Finally, the constructed solution clearly gives an objective function value that equals the negation of the optimal flow cost, and the lemma follows. ∎

Theorem 4.

ACOP is tractable with polynomial-time complexity.


The maximum possible age of any item in the cache is bounded by the number of time slots . Hence the size of the constructed graph is polynomial in and . Moreover, the graph is clearly acyclic. For minimum-cost flow problems with integer input, there is an optimal solution in which the arc flows are integers, and there are (strong) polynomial algorithm for the problem including that with negative costs in an acyclic graph[33]. These facts, together with Lemmas 2-3, establish the theorem. ∎

Consider now ACOP with two content items. For this special case, it is trivial to see if the cache can hold one or both items. Moreover, without loss of generality, one can assume that the backhaul capacity allows for updating one item. As a result, ACOP with two content items falls in the domain of ACOP, giving the corollary below.

Corollary 5.

ACOP with two items is tractable with polynomial-time complexity.

The above observation does not generalize to three or more items, because then the capacity can no longer be interpreted in the number of items. Instead, the items’ individual sizes must be explicitly accounted for.

Remark 3.

For combinatorial optimization problems, tractable problem sub-classes are often identified by proving that a greedy solution leads to optimum. For ACOP, however, the greedy solution in Section 3.1 remains sub-optimal. This is due to item-specific utility function and backhaul capacity. Consider a simple example of two items. Both are of size one. The capacity values are and . For item one, the utility function (with ) and for . For item two, for , and for . The greedy solution would cache and update item one in all time slots. Thus for , the total utility is . The optimal solution is to cache item two in time slot one. Then, item one is added and kept updated in the next time slots. This gives a total utility of . As a result, the greedy solution becomes highly sub-optimal for large . Thus the notion of network flows is necessary for arriving at the conclusion of the tractability of ACOP.

5 Integer Linear Programming Formulation

We derive an integer linear programming (ILP) formulation for ACOP. This leads to a solution approach of using an off-the-shelf optimization solver (e.g.,[34]). Even though the approach does not scale, it can be used to obtain optimum problem instances of small size, for the purpose of performance evaluation of other algorithms.

We use binary variable

that equals one if the age of item in time slot is , otherwise the variable equals zero. Note that index is up to , because the AoI in slot can never exceed . Also, means item is added to the cache or updated for time slot . Binary variable is used to indicate if item is in the cache in time slot or not. The ILP formulation is given below.


The objective function (1a) is to maximize the overall utility. By (1b), if item is cached in a time slot , i.e., , then exactly one of the binary variables representing the possible AoI values is one, otherwise these binary variables have to be zeros. Inequality (1) states that if item is cached with AoI in a time slot, then for the next time slot, either the AoI becomes (represented by ), or it gets updated (represented by ), or the item is no longer in the cache (represented by ). The cache and backhaul capacity limits are formulated in (1d) and (1e), respectively.

6 Repeated Column Generation Algorithm

For efficient solution of ACOP, we propose an algorithm based on repeated column generation. Column generation is an efficient method for solving large-scale linear programs with the following two structural properties [35]. First, there are exponentially many columns (i.e., variables), hence including all is not practically feasible and the method deals with only a small subset of them. Second, identifying new columns that improve the objective function value can be performed by solving an auxiliary problem, named the subproblem. This enables successive addition of new and promising columns until optimality is reached.

6.1 Problem Reformulation

Applying column generation to ACOP is based on a reformulation. In the reformulation, a column of any item is a vector representing the caching and updating decisions of the item over all time slots. We denote by the index set of all possible such vectors for item . For each column , there is a tuple for every time slot . Both elements are binary. Specifically, a column is represented by in which and are one if and only if the item is cached and updated, respectively, in time slot . Note that there are exactly three possible outcomes of the tuple values: , , and . As a result, the cardinality of set is bounded by .

Because a column fully specifies the caching and updating solution, the associated AoI values over time are known for any given column. Hence, the total utility value of column for item , denoted by , can be computed.

The problem reformulation uses a binary variable for each item and column . This variable is one if column is selected for item , and zero otherwise. The reformulation is given below.


In (2), (2b) states that exactly one column (i.e., caching and updating solution) has to be selected for every item. The next two constraints formulate the cache and backhaul capacity, respectively. Note that both (2) and (1) are valid optimization formulations of ACOP. However they differ in structure.

6.2 Column Generation

The structure of (2) can be exploited by using column generation. To this end, we consider the linear programming counterpart of (2), where (2e) is replaced by the relaxation . Moreover, for each item , a small subset is used and successively augmented to approach optimality. Initially, can be as small as a singleton, containing only the column representing not caching the item at all. One iteration of column generation solves the following LP.


At the optimum of (3), denote by , , and the corresponding optimal dual variable values of (3b), (3c) and (3d), respectively. For any item , the LP reduced cost of column equals . We are interested in knowing if there exists any column with a positive reduced cost (among those in for item ). If so, adding the column to (3) shall improve the objective function value. This can be accomplished by finding the column of maximum reduced cost for each item. Clearly, the resulting optimization task decomposes by item.

Recall that any column is characterized by a vector of tuples of binary values . Finding the column of maximum reduced cost amounts to setting binary values of the tuples, such that the corresponding reduced cost is maximized. These values represent the update and caching decisions of one item, and hence we can use the variable definitions in Section 5. The subproblem for a generic item is formulated below.


There are clear similarities between (4) and (1), as both concern optimizing caching and updating decisions. However, they differ in several significant aspects. First, (4) deals with a single item. Second, the cache and backhaul capacities are not present in (4) because these are addressed in (2). Finally, the objective function (4a) contains the dual variables as the purpose is to maximize the reduced cost. Note that dual variable is a constant for item and hence it is not explicitly included in (4a).

Figure 2: The graph for which finding the shortest path gives the optimum of (4).

Subproblem (4) is an integer linear problem. What is less obvious is that it can be transformed into a shortest path problem that is polynomial-time solvable. This is illustrated in Fig. 2, which is a modified single-item version of the network in Fig. 1. Moreover, the dual variables appear as part of the arc costs in Fig. 2.

Theorem 6.

The shortest path from node to gives the optimal solution of (4).


By construction and the proof of Lemma 3, a flow solution corresponds to a caching solution of the item in question. Since the graph is acyclic, a flow solution is a single path. Moreover, it is easy to verify that the total path cost equals (4a) of the corresponding caching solution, and the result follows. ∎

Remark 4.

Suppose a partial decision is taken such that an item shall not be cached at a slot. This amounts to simply deleting all the arcs entering the nodes representing the age values for that slot. Similarly, the partial decision of caching the item in a slot corresponds to deleting the arc representing the opposite. To account for a partial decision of updating the item in a slot , we find first the shortest path problem from the source to node , and then include arc and find the shortest path from to the destination node. In conclusion, solving the subproblem can easily accommodate partial decisions. This observation is useful for attaining an integer solution (Section 6.3).

Input: , , , , ,

Algorithm 2 Column generation
1:  Initialize
2:  Stop False
3:  while Stop = False do
4:     Solve (3) to obtain optimum and dual optimum
5:     Stop True
6:     for  do
7:        Solve (4)
8:        if  then
9:           Stop False
10:           Add the column corresponding to to

Column generation for ACOP is summarized in Algorithm 2. Applying Algorithm 2, the optimal objective function value is the LP optimum of (2) and is therefore an upper bound (UBD) of the global optimum of ACOP. This UBD is very useful to gauge performance of any suboptimal solution, because the deviation from the global optimum is bounded by that to the UBD.

6.3 Attaining Solution Integrality

The solution by Algorithm 2 may be fractional. A naive rounding algorithm would pick some fractional -variable of some item and round it either up to one or down to zero, depending on the value. This way of rounding is rather aggressive, however, because the caching and updating decisions over all time slots become fixed, and there would be no opportunity to make any further decision for item .

We consider performing rounding more gracefully. The idea is to make a rounding decision for one item and one time slot at a time. Given the optimum LP solution via column generation, we define (cf. variables used in formulation (1) in Section 5) and . These entities can be interpreted as the likelihood of caching and updating item in time slot , respectively. Note that for item , there may be multiple (and factional) -variables contributing to the values of and . The following theorem states that, to attain an integer solution for (3), it is sufficient that and , , become integer.

Theorem 7.

is integer if and only if and are integer.


The necessity is obvious by the definition of and . For sufficiency, assume and are integer. Suppose is fractional, and assume more specifically . By (3b), there must exist at least another -variable for item that has fractional value. Let denote the column index set of the fractional -variables of item . Because there are no identical columns in , there must exist some time slot , for which can be partitioned into two sets, and , such that and , and none of the two sets is empty. Thus , contradicting that is integer. The same argument applies to , and the theorem follows. ∎

By the above result, rounding can be performed on and , instead of . This amounts to considering disjunctions, i.e., a partition of the -variables into two subsets rather than considering a single -variable (cf. the proof of Theorem 7), and assembles the use of disjunctions in branch-and-bound in solving integer programs [36]. Hence we use the term disjunction-based rounding (DR) to refer to to the rounding concept.

After performing DR, column generation is applied again. This is because additional columns may be needed to reach the LP optimum given the constraint imposed by rounding. For example, setting means to exclude columns and since the current is a small subset of , some new column with may improve the objective function. This yields the repeated column generation algorithm, or RCGA in short.

Note that, after a DR operation, both (3) and the subproblem of column generation have to comply with the rounding decision. Namely, if by DR, then are removed from (3), and arcs representing caching the item in slot time in the subproblem graph are deleted. If , then are removed from (3), and the subproblem for item becomes two (smaller) shortest path problems, then the arc representing not being in the cache is deleted. Similar updates apply for DR on . Thus the subproblem remains polynomial-time solvable.

The details of DR is presented in Algorithm 3. In the algorithm, symbol  is used to indicate assignment of value. Symbol  is used to indicate that an assigned value of an optimization variable is kept fixed after the assignment. Lines - calculate and . For item and time slot , Line makes the decisions of fixing and , if , and Line  discards the columns that do not comply to the decisions. Line performs the opposite decision of fixing and , if , and the non-complying columns are discarded (Line ). Lines 7-10 calculate the remaining spare backhaul and cache capacities, denoted by and , respectively.

Lines 11 and 12 compute the number of fractional elements of and , denoted by and , respectively. If both and equal to zero, the current solution is integer by Theorem 7. Otherwise, one DR is applied for if (Lines 14-26). If is integer but , DR is applied to a fractional element of (Lines 28-42).

More specifically, Lines 14-15 find the fractional element of being closest to zero, and the corresponding item and time slot. These entities are denoted by , , and , respectively. The corresponding entities in examining the fractional element of that is closest to one (Lines 16-17) are denoted by , , and , respectively. If , DR fixes to be zero in Line 19. Furthermore, the non-complying columns are discarded from in Line 20. If , the algorithm checks whether or not there is enough remaining backhaul capacity to download item . If the answer is positive, is fixed to be one in SP by Line 22, and the non-complying columns are deleted from by Line 23. If the remaining capacity does not permit to download , is fixed to be zero by Line 25 and the non-complying columns will be discarded from by Line 26. DR based on is similar to that for , and the details are presented in Lines 28-42.

As the next step, the algorithm updates the remaining spare backhaul and cache capacity limits (Lines 44-47). Thereafter, the algorithm examines if any content item has a larger size than what can be admitted by the capacity limit in any time slot. For any such item and time slot, the corresponding variable is fixed to zero, and the non-complying columns are discarded (Lines 48-55). Finally, to ensure feasibility, an auxiliary column is added for each item (Lines 56-57). If the item is cached or updated in a time slot by the decisions made by DR thus far, the corresponding parameter is set to one. The rest of elements of the column are zeros.

1:  Compute , where
2:  Compute , where
3:   and in SP if ,
4:   in RMP if ,
5:   and in SP if ,
6:   in RMP if ,
13:  if  then
18:     if  then
19:          in SP
20:          if ,
21:     else if  then
22:          in SP
23:          if ,
24:     else
25:          in SP
26:          if ,
27:  else if  then
28:      in SP if ,
29:      in RMP if ,
34:     if