Managing Multiple Mobile Resources
Bj\"orn Feldkord, Till Knollmann, Manuel Malatyali, Friedhelm, Meyer auf der Heide

TL;DR
This paper extends the Mobile Server Problem to multiple servers in Euclidean space, showing inherent online algorithm limitations and proposing a competitive algorithm under locality and augmentation assumptions.
Contribution
It introduces a new model with multiple mobile servers, analyzes the limitations of online algorithms, and presents a competitive algorithm under specific constraints.
Findings
No online algorithm can have a constant competitive ratio without restrictions.
Locality of requests enables the design of a bounded competitive online algorithm.
The proposed algorithm simulates classical k-Page Migration algorithms with additional greedy moves.
Abstract
We extend the Mobile Server Problem, introduced in SPAA'17, to a model where k identical mobile resources, here named servers, answer requests appearing at points in the Euclidean space. In order to reduce communication costs, the positions of the servers can be adapted by a limited distance m_s per round for each server. The costs are measured similar to the classical Page Migration Problem, i.e., answering a request induces costs proportional to the distance to the nearest server, and moving a server induces costs proportional to the distance multiplied with a weight D. We show that, in our model, no online algorithm can have a constant competitive ratio, i.e., one which is independent of the input length n, even if an augmented moving distance of (1+\delta)m_s is allowed for the online algorithm. Therefore we investigate a restriction of the power of the adversary dictating the…
| Lower bound | Unweighted Problem () | Weighted Problem () | |
|---|---|---|---|
Peer Reviews
No public reviews on file for this paper yet. If you reviewed it on a platform where reviews are public (OpenReview, ICLR, NeurIPS, ICML), you can paste yours below so the community can read it here.
Videos
No videos yet. Explain this paper in a talk, walkthrough, or lecture? Add one.
Managing Multiple Mobile Resources (Full Version)
††thanks: This work was partially supported by the German Research Foundation (DFG) within the Collaborative Research Centre ”On-The-Fly Computing” under the project number 160364472 — SFB 901/3.
Björn Feldkord
Till Knollmann
Manuel Malatyali
Friedhelm Meyer auf der Heide
Abstract
We extend the Mobile Server Problem introduced in [8] to a model where identical mobile resources, here named servers, answer requests appearing at points in the Euclidean space. In order to reduce communication costs, the positions of the servers can be adapted by a limited distance per round for each server. The costs are measured similar to the classical Page Migration Problem, i.e., answering a request induces costs proportional to the distance to the nearest server, and moving a server induces costs proportional to the distance multiplied with a weight .
We show that, in our model, no online algorithm can have a constant competitive ratio, i.e., one which is independent of the input length , even if an augmented moving distance of is allowed for the online algorithm. Therefore we investigate a restriction of the power of the adversary dictating the sequence of requests: We demand locality of requests, i.e., that consecutive requests come from points in the Euclidean space with distance bounded by some constant . We show constant lower bounds on the competitiveness in this setting (independent of , but dependent on , and ).
On the positive side, we present a deterministic online algorithm with bounded competitiveness when augmented moving distance and locality of requests is assumed. Our algorithm simulates any given algorithm for the classical -Page Migration problem as guidance for its servers and extends it by a greedy move of one server in every round. The resulting competitive ratio is polynomial in the number of servers , the ratio between and , the inverse of the augmentation factor and the competitive ratio of the simulated -Page Migration algorithm.
1 Introduction
We consider a scenario where several devices continuously access a common set of identical resources. The devices pose requests for a resource which must be answered by communicating with the resources, incurring cost for communication. The placement of resources is managed by an algorithm whose goal it is to reduce the costs for communication and for moving the resources as much as possible. Typically requests do not concern the complete resource (which may be rather large) and it is cheaper to answer a request for a resource by communicating with the resource instead of moving it. We assume requests appear in an online fashion, i.e., it is unknown to the algorithm where the next requests will arrive while newly arriving requests must be answered instantly to provide latency guarantees.
The scenario described above can be modeled based on the classical Page Migration problem [5]: A single resource can be moved between two points and for costs , where is the distance between and and is a constant. In every round a request appears at some point , and if the current position of the resource is , it is served for costs . This problem was extended to the Mobile Server Problem [8], which puts a limit on how much the resource (called server) can move in each time step and therefore introduces the idea that the positions of resources can not be arbitrarily changed in each time step.
In our work, we extend this idea to multiple resources: We consider identical servers located in the Euclidean space (of arbitrary dimension). Each of them may move a distance of at most per time step. In each time step, a request appears which has to be served by one of the servers by the end of the time step. The cost function is the same as in the Page Migration Problem.
1.1 Related Work
Besides being a direct extension of the Mobile Server Problem [8], our work builds on and is related to results surrounding the -Server and Page Migration problems. These problems have been examined in many variants and especially for the -Server Problem there are many algorithms for special metrics. In this overview we only focus on most relevant results for our problem, which are mostly algorithms with an (asymptotically) optimal competitive ratio.
In the classical -Server Problem as introduced by Manasse et al. [13], identical servers are located in a metric space and requests are answered by moving at least one of the servers to the point of the request. The associated costs are equal to the total distance moved. Manasse et al. showed that no online algorithm could be better than -competitive on every metric with at least points. They stated as the -Server Conjecture that there is a -competitive online algorithm for every metric space. Further, the conjecture is shown to hold for and where is the number of points in the metric space.
Since its introduction, many algorithms have been designed for special cases of the problem. Most notable is the Double-Coverage Algorithm [7], which is -competitive on trees. For general metrics, the best known result is the Work-Function Algorithm, which is shown to be -competitive [11]. Although this algorithm seems generally inefficient in case of runtime and memory, there have been studies showing that an efficient implementation of this algorithm is indeed possible [14, 15]. It was also shown that the algorithm has an optimal competitive ratio of on line and star metrics, as well as metrics with points [3].
The study of randomized online algorithms was initiated by Fiat et al. [10] who gave a -competitive algorithm for the complete graph. It is speculated that this factor can be obtained for all metrics, however the question is still open. For general metrics, the first algorithm with polylogarithmic competitive ratio was an -competitive algorithm by Bansal et al. [1]. This was recently improved by Bubeck et al. [6] who gave an -competitive algorithm for HSTs which can be turned into an -competitive one for general metrics by a dynamic embedding of general metrics into HSTs [12].
Regarding the Page Migration Problem [5] (also known as File Migration Problem), most results focus on online algorithms which handle only a single page. Contrary to the -Server Problem, the design of such algorithms is not trivial for the Page Migration Problem. To the best of our knowledge, the current best results are a -competitive deterministic algorithm by Bienkowski et al. [4] and a collection of randomized algorithms with competitive ratio of at most 3 by Jeffery Westbrook [16]. The most relevant results for our problem are two constructions by Bartal et al. [2] who give both a deterministic and a randomized algorithm which transform a given algorithm for the -Server problem into a deterministic / randomized algorithm for the -Page Migration Problem. If the given -Server algorithm is -competitive, the deterministic algorithm is -competitive, the randomized algorithm is -competitive. Conversely, we use the resulting algorithms as a black box in our constructions.
1.2 Our Results & Outline of the Paper
In [8] it was already shown that no online algorithm for our problem can be competitive even on the real line and with just server. As a consequence, we employ the following methods to derive reasonable results for the problem: On the one hand we restrict the adversary to the case with locality of requests, i.e., we introduce a parameter by which we can define families of instances classified by the maximum distance between two consecutive requests. On the other hand we apply resource augmentation as in [8], i.e., we allow the online algorithm to use a maximum movement distance of . We show that, for , both methods are needed to yield competitive bounds independent of the length of the instance. For , it was shown in [9] that a locality of requests can improve the competitiveness, but is not necessary to achieve a constant upper bound.
The parameters and have a crucial impact on the resulting competitiveness and thus separate simple from hard instances. We are able to show that these parameters seem to naturally describe the problem, since we can prove a lower bound of . For fast moving resources (), our algorithm has an almost optimal competitive ratio when given an optimal -Page Migration algorithm. For the case of slow moving resources (), we can achieve bounds independent of the length of the input stream. In detail, we obtain a bound of , where is the competitiveness of a given -Page Migration algorithm. For the case , which we call the unweighted problem, the -Page Migration algorithm can be replaced by a -Server algorithm. Note that the parameter in Table 1 is indirectly given as the relative difference between and . If , then in the first row we have . Alternatively, if , this case still yields an almost optimal upper bound up to a factor of .
The paper is structured as follows: A formal definition of our model can be found in Section 2. All relevant lower bounds are established in Section 3. In terms of upper bounds, we first give an algorithm for the unweighted problem in Section 4. The analysis for instances with consists of a simple potential function argument found in Section 4.1. The analysis of the other case is much more challenging and is conducted in Section 4.2. The weighted case () is discussed in Section 5. While the basic approach stays the same, we need to modify the movement of the online algorithm due to the higher movement costs. We show how the algorithm can be adapted and present the resulting competitive ratio following a similar structure as in the unweighted case.
2 Model & Notation
In this section we formally describe the model and some common notation used throughout the paper.
Time is considered discrete and divided into time steps . An input to the -Mobile Server Problem is given by a sequence of requests where each occurs in time step and is represented by a point in the Euclidean space of arbitrary dimension. We are given servers controlled by our online algorithm. At each point in time, one server occupies exactly one point in the Euclidean space. We denote by the position of server at end of time step , and by the Euclidean distance between two points and . For the distance between two servers and in the same time step , we also use the notation . We may also leave out the time entirely if it is clear from the context.
In each time step , the current request is revealed to the online algorithm. The algorithm may then move each server, such that for all servers . The movement incurs cost of for a constant . The request is then served by the closest server , which incurs cost of . Note that the variables indexed with the time represent the configuration at the end of the time step .
In our model, we consider the locality of requests dictated by a parameter limiting the distance between consecutive requests, i.e., . We also consider a resource augmentation setting, where the maximum distance an online algorithm may move is in fact for some . The cost of our online algorithm is denoted by . We compare the costs of an online algorithm to an offline optimum, whose servers are denoted by and whose cost is .
3 Lower Bounds
In this section, we will prove lower bounds for the competitive ratio of our problem. They show the importance both of the resource augmentation and the locality of requests introduced above. All our lower bounds already hold on the line (and therefore in arbitrary dimensions, too). Since our model is an extension of the -Page Migration Problem, is a lower bound for deterministic algorithms inherited from that problem (which itself inherits the bound from the -Server Problem, see [2, 13]). Even when is restricted, the lower bound instance can simply be scaled down such that the distance limits are not relevant for the instance.
We start by discussing the model without any restriction on the distance between the requests in two consecutive time steps, i.e., the parameter is unbounded. We also consider the case, that there is no resource augmentation, i.e., the maximum movement distance of the online algorithm and of the offline solution are the same. The following lower bound, originally formulated for , carries over from [8]:
Theorem 1**.**
Every randomized online algorithm for the Mobile Server Problem (with ) has a competitive ratio of against an oblivious adversary, where is the length of the input sequence.
For more than one server, we obtain an additional bound which can not be resolved with the help of resource augmentation. The proofs of the following theorems can be found in Appendix A.
Theorem 2**.**
For , every randomized online algorithm for the -Mobile Server Problem has a competitive ratio of at least , where is the length of the input sequence.
Since we often consider input sequences for problems such as ours to be potentially infinite, we deem competitive ratios dependent on the input length undesirable. Hence, as a consequence of the bounds shown so far, we apply two modifications to our model which help us to achieve a competitive ratio independent of the length of the input sequence. We use the concept of resource augmentation just as in [8] to allow the online algorithm to utilize a maximum movement distance of for some as opposed to the distance used by the optimal offline solution. This measure alone does not address the bound from Theorem 2 (the ratio shrinks, but still depends on ). Hence, we introduce the locality of requests, i.e., restrict the distance between two consecutive requests to a maximum distance of . Note, that only restricting the distance between consecutive requests does also not remove the dependence on , as was shown in [9]. The following theorem can be obtained in a similar way as Theorem 2:
Theorem 3**.**
For , every randomized online algorithm for the -Mobile Server Problem, where the distance between consecutive requests is bounded by , has a competitive ratio of at least .
4 An Algorithm for the Unweighted Problem
In this section we consider the unweighted problem (). Our algorithm does the following: We mainly follow around a simulated -Server algorithm, but always move the closest server greedily towards the request.
We use the following notation in this section: Denote by the servers of the online algorithm, the servers of the simulated -server algorithm and the servers of the optimal solution. For an offline server , we denote by the closest server of the online algorithm to (this might be the same server for multiple offline servers). Furthermore, we denote by , and the closest server to the request of the algorithm, the -server algorithm, and the optimal solution respectively. For a fixed time step , we add a to any variable to denote the state at the end of the current time step, e.g., is the position of the server at the beginning of the time step and is the position at the end of the current step.
Our algorithm Unweighted-Mobile Servers (UMS) works as follows:
Take any -Server algorithm with bounded competitiveness in the Euclidean space. Upon receiving the next request , simulate the next step of . Calculate a minimum weight matching (with the distances as weights) between the servers of the online algorithm and the servers of . There must be a server for which . If the server matched to can reach in this turn, move all servers towards their counterparts in the matching with the maximum possible speed of . Otherwise, select the server which is closest to and move it to with speed at most . All other servers move towards their counterparts in the matching with speed .
We briefly want to discuss the fact that both steps of our algorithm are necessary for a bounded competitiveness. For the classical -Server Problem, a simple greedy algorithm, which always moves the closest server onto the request has an unbounded competitive ratio. We can show, that a simple algorithm which just tries to imitate any -Server algorithm as best as possible is also not successful. Intuitively, the simulated algorithm can move many servers towards the request within one time step and serve the following sequence with them, while the online algorithm needs multiple time steps to get the corresponding servers in position due to the speed limitation.
Simple algorithm: Let be any given -Server algorithm. The -Mobile Server algorithm does the following: Simulate . Compute a minimum weight matching (with the distances as weights) between the own servers and the servers of . Move every server towards the matched server at maximum speed.
Theorem 4**.**
For , there are competitive -Server algorithms such that the simple algorithm for the -Mobile Server Problem does not achieve a competitive ratio independent of .
The remainder of this section is devoted to the analysis of the competitive ratio of the UMS algorithm. In Section 4.1, we first consider the case that the distance between consecutive requests is smaller than the movement speed of the algorithm’s servers. This case is easier than the case of slower servers since we can always guarantee that the online algorithm has one server on the position of the request. In the other case (), described in Section 4.2, we need to extend our analysis to incorporate situations in which our online algorithm has no server near the request although the optimal offline solution might have such a server. Details left out due to space constraints can be found in Appendix B.
4.1 Fast Resource Movement
We first deal with the case that for some . We show that we can achieve a result independent of the input length, even without resource augmentation. At the end of this section, we briefly discuss how to extend the result to incorporate resource augmentation, i.e., if the online algorithm has a maximum movement distance of , we handle all cases with .
Theorem 5**.**
If for some , the algorithm UMS is -competitive, where is the competitive ratio of the simulated -server algorithm .
Proof.
We assume the servers adapt their ordering according to the minimum matching in each time step. Based on the matching, we define the potential . Note that the algorithm reaches the point of in each time step, and hence only pays for the movement of its servers, i.e., . We assume, that is on the request after the current time step, i.e., .
First, consider the case that can reach in this time step. Since each server moves directly towards their counterpart in the matching, we have
\begin{array}[]{rcl}\Delta\psi&=&\frac{2}{\varepsilon}\cdot\sum_{i=1}^{k}d(a_{i}^{\prime},c_{i}^{\prime})-\frac{2}{\varepsilon}\cdot\sum_{i=1}^{k}d(a_{i},c_{i})\\ &\leq&\frac{2}{\varepsilon}\cdot\sum_{i=1}^{k}d(c_{i},c_{i}^{\prime})-\frac{2}{\varepsilon}\cdot\sum_{i=1}^{k}d(a_{i},a_{i}^{\prime})\\ &=&\frac{2}{\varepsilon}\cdot C_{\mathcal{K}}-\frac{2}{\varepsilon}\cdot C_{Alg}.\end{array}
Now assume that cannot reach in this time step. The server moves at full speed and hence . Now, let be the server which is at range at most to and does the greedy move possibly away from onto . It holds . In total, we get
\begin{array}[]{rcl}\Delta\psi&\leq&\frac{2}{\varepsilon}(\sum_{i=1}^{k}d(a_{i}^{\prime},c_{i}^{\prime})-\sum_{i=1}^{k}d(a_{i},c_{i}^{\prime}))+\frac{2}{\varepsilon}\sum_{i=1}^{k}d(c_{i},c_{i}^{\prime})\\ &\leq&\frac{2}{\varepsilon}(d(a_{1}^{\prime},c_{1}^{\prime})-d(a_{1},c_{1}^{\prime})+d(a_{2}^{\prime},c_{2}^{\prime})-d(a_{2},c_{2}^{\prime}))-\frac{2}{\varepsilon}\sum_{i=3}^{k}d(a_{i},a_{i}^{\prime})+\frac{2}{\varepsilon}\sum_{i=1}^{k}d(c_{i},c_{i}^{\prime})\\ &\leq&-2m_{s}-\frac{2}{\varepsilon}\sum_{i=3}^{k}d(a_{i},a_{i}^{\prime})+\frac{2}{\varepsilon}\cdot C_{\mathcal{K}}\\ &\leq&-\sum_{i=1}^{k}d(a_{i},a_{i}^{\prime})+\frac{2}{\varepsilon}\cdot C_{\mathcal{K}}.\end{array}
∎
We can extend this bound to the resource augmentation scenario, where the online algorithm may move the servers a maximum distance of . When relaxing the condition appropriately to , we get the following result:
Corollary 6**.**
If for some , the algorithm UMS is -competitive, where is the competitive ratio of the simulated -server algorithm .
The proof works the same as above by replacing occurrences of by and changing the potential to .
At first glance, the result seems to become weaker with increasing if stays the same. The reason is that by fixing the relative difference between and actually decreases, i.e., relatively speaking, gets closer to . It can be seen that if instead we fix the value of and increase , the value of increases by the same amount and hence the competitive ratio tends towards .
4.2 Slow Resource Movement
This section considers the case and is structured as follows: To support our potential argument, we first introduce a transformation of the simulated -Server algorithm which ensures that the simulated servers are always located near the request. We then introduce an abstraction of the offline solution, reducing it to the positioning of a single server which acts as a reference point for a new potential function. The server approximates the optimal positioning of the servers while at the same time obeys certain movement restrictions necessary in our analysis. Finally, we complete the analysis by combining the new derived potential function with the methods from the previous section.
The k-Server Projection
Our goal is to transform a -Server algorithm into a -Server algorithm which serves the requests of a -Mobile Server instance such that all servers keep relatively close to the current request . For the case , we want our algorithm to use this projection as a simulated algorithm as opposed to a regular -Server algorithm, hence we must ensure that this projection is computable online with the information available to our online algorithm. The servers of are denoted as and the servers of as .
We define two circles around : The inner circle has a radius of and the outer circle has a radius of . We will maintain for the entirety of the execution. The time is divided into phases, where the phase starting at time with the request at point ends on the smallest such that . During a phase the simulated servers move to preserve the following: If , then . At the end of the phase, in addition to the previous condition, it should hold: If , then is on the boundary of such that is minimized. It is obvious that the definition of the algorithm guarantees for all at each point in time.
Proposition 7**.**
For the servers of it holds during the whole execution. The costs of are at most times the costs of .
The Offline Helper
We define a new offline server , which approximates the optimal position while managing the role change of in a smooth manner. By , we denote the server of the online algorithm with minimal distance to For a formal description of the behavior, we need the following definitions:
- •
The inner circle contains all points with .
- •
The outer circle contains all points with .
Abusing notation, we also refer to and as distances equal to the radius defined above. This section is devoted to proving the following:
Proposition 8**.**
There exists a virtual server which moves at a speed of at most per time step, for which at all times, and for which the following conditions hold as long as :
If at the end of the current time step, moves at a maximum speed of , i.e., . 2. 2.
If at the end of the current time step, then at the end of the current time step, i.e., .
In the following, we show that it is possible to define a movement pattern for in a way, such that invariants 1 and 2 of Proposition 8 hold as long as . Otherwise, will simply follow and restore the properties once . In order to describe the movement in detail, we introduce the concept of transitions.
In the input sequence and a given optimal solution, we define a transition between two steps , if there are such that and at time step and and at time step . In between these two time steps, . For such a transition, we define the transition time as . If , we call this a long transition. Otherwise, we call it a short transition. We say that passes the request after and receives the request in . The concept is illustrated in Figure 4.2.
The behavior of can be computed as follows:
During a long transition between time steps and , move with speed towards whenever . In the last two steps and , move such that at time and do not move in at all. Informally, moves one step ahead of such that after the transition, as soon as . 2. 2.
For a sequence of short transitions starting with in , determine which of the following events terminating the current sequence occurs first:
- (a)
A long transition from a server to between time and occurs. In this case, simply moves towards in each step with speed at most until . 2. (b)
A short transition from a server to between time and occurs, where at one point prior in the sequence . If can move straight towards the final position of in with speed without ever leaving , then do that. Otherwise move towards a point with . Among those candidates, minimizes . When this point is reached, keep the invariant whenever the final position of is not within around . The position of on the circle around should be the one closest to ’s final position. When is inside the circle, the position of should be equal to . 3. 3.
If , treat the time until as a long transition between and , i.e., move towards with speed and skip one step ahead of during the last 2 time steps. (Steps 1 and 2 are not executed during this time.)
Note that the server is a purely analytical tool and hence the behavior as described above does not have to be computable online.
Our goal is to show that all invariants described in Proposition 8 hold inductively over all transitions. We divide the entire timeline into sequences, where each sequence starts with both and being in . A sequence ends when one of the events stated in step 2 of the algorithm completes. The following lemma states that the initial condition is restored after every long transition.
Lemma 9**.**
If at the beginning of a long transition between and , then at the end of the transition.
Our next goal is to analyze a sequence of short transitions. During these transitions, moves faster than and hence the distance of to increases due to the role change after a transition. The next lemma establishes an upper bound on that increase. Since we use the lemma in another context as well, the formulation is slightly more general.
Lemma 10**.**
Every short transition between in step and in step can increase the distance of some server , which moves at speed at most , to by at most .
Likewise, decreases its distance to by at most .
We want to show, that holds after a sequence of short transitions is terminated by one of the conditions described in step 2 of the algorithm. During the sequence, we must also show that . The main idea for the following lemma is that never leaves per definition and hence following it keeps inside .
Lemma 11**.**
Consider a sequence of short transitions which is terminated by a long transition. If at the beginning of the sequence, then after the long transition. During the sequence of short transitions, .
We show with the help of Lemma 10 that during the sequence of transitions, does not loose too much distance to , while , since at one point , takes enough time to get into position for a short transition such that can reach the final position of in time.
Lemma 12**.**
Consider a sequence of short transitions which is terminated by a short transition from to , where at one point prior in the sequence . If at the beginning of the sequence and at all times, then after the transition to . During the sequence, .
Our analysis of the movement pattern of leads directly to the following lemma, in which we mostly need to argue that either or .
Lemma 13**.**
During the execution of the algorithm, as long as the algorithm is in step 1 or 2.
So far we have shown that all claims of Proposition 8 hold as long as the algorithm is not in step 3. It remains to analyze step 3 of the algorithm, using similar arguments as for analyzing the long transitions earlier.
Lemma 14**.**
After the execution of step 3 it holds . Furthermore, during step 3 of the algorithm.
Algorithm Analysis
We now turn our attention back to the analysis of the UMS algorithm. In the following, we assume to be a -Server algorithm obtained from Proposition 7. We use a potential composed of two major parts which balance the main ideas of our algorithm against each other: will measure the costs of the greedy strategy, while will cover the matching to the simulated -Server algorithm.
Let be an offline server which fulfills the invariants stated in Proposition 8. Recall that denotes the currently closest server of the online algorithm to . The first part of the potential is then defined as
[TABLE]
with .
For the second part, we set
[TABLE]
where the online servers are always sorted such that they represent a minimum weight matching to the simulated servers . We choose to be sufficiently large.
If we understand as a function in , then we can rewrite it as . Hence, when estimating the potential difference , we can upper bound it by replacing the term with the case identical to . This mostly reduces estimating to bounding the difference .
For some of our estimations we use a slightly altered result from [8].
Lemma 15**.**
Let be some server with and moves towards a distance of , then .
We start the analysis by bounding the second potential difference . The bounds can be obtained by similar arguments as in the proof of Theorem 5.
Lemma 16**.**
.
Lemma 17**.**
If , then
Now consider the case that . We have . The movement cost are canceled by as in Lemma 16. It only remains to bound the possible increase of . We use .
: . 2. 2.
: .
In all of the above, the competitive ratio is bounded by .
Finally, we consider the case . Whenever , we use Lemma 15 to obtain the following:
Lemma 18**.**
If and , then .
With this lemma, can be used to cancel the costs of the algorithm in case of a high distance to .
Lemma 19**.**
If , then .
The resulting competitive ratio of is less than the bound from the former set of cases. Accounting for the loss due to the transformation of the simulated -Server algorithm, we obtain the following result:
Theorem 20**.**
If , the algorithm UMS is -competitive, where is the competitive ratio of the simulated -server algorithm .
5 Extension to the Weighted Problem
In this section we consider our general model in which the movement costs are weighted with a factor . We assume throughout the section that for convenience in the analysis. In case , we may just apply the algorithm from the previous section, whose costs increase by at most a factor of as a result.
The main difference to the unweighted case is that our algorithm uses a -Page Migration algorithm as guidance, whose best competitive ratio in the deterministic case so far is a factor worse than that of a -Server algorithm for general metrics. The analysis is slightly more involved since unlike in the -Server Problem, a -Page Migration algorithm does not always have to have one page at the point of the request. In case of small distances to , the movement costs have to be balanced against the serving costs by scaling down the movement distance by a factor of . Throughout this section, we use the same notation as for the unweighted version.
Our algorithm Weighted-Mobile Servers (WMS) works as follows:
Take any -Page Migration algorithm . Upon receiving the next request , simulate the next step of . Calculate a minimum weight matching (with the distances as weights) between the servers of the online algorithm and the pages of . Select the closest server to and move it to at most a distance in case and at most in case . All other servers move towards their counterparts in the matching with speed . If another server than is closer to after movement, then move all servers towards their counterpart in the matching with speed instead.
The remainder of this section is devoted to the analysis of the WMS algorithm and is structured similar to Section 4. Due to space constraints, we can only give a brief overview and refer for the details to Appendix C.
We start by analyzing the case that for some . For , our algorithm simply assumes . It can be easily verified, that this does not hinder the analysis.
Theorem 21**.**
If for some , the algorithm WMS is -competitive, where is the competitive ratio of the simulated -Page Migration algorithm .
We can extend this bound to the resource augmentation scenario, where the online algorithm may move the servers a maximum distance of . When relaxing the condition appropriately to , then we get the following result:
Corollary 22**.**
If for some , the algorithm WMS is -competitive, where is the competitive ratio of the simulated -Page Migration algorithm .
Similar to the -Server Projection discussed in Section 4.2, we obtain the following result which gives us a new -Page Migration algorithm needed for the case .
Proposition 23**.**
Let be an online algorithm for the -Page Migration Problem. There exists an online algorithm for the -Page Migration Problem with pages such that it holds during the whole execution. The costs of are at most times the costs of .
From here on we assume to be a -Page Migration algorithm obtained from the transformation in Proposition 23. The offline helper and its invariants as stated in Proposition 8 do not depend on the simulated algorithm and therefore all insights gained from the corresponding section are still valid. We use a potential composed of two major parts just as for the unweighted case.
Let be an offline server which fulfills the invariants stated in Proposition 8. The first part of the potential is then defined as
[TABLE]
with .
For the second part, we set
[TABLE]
where the online servers are always sorted such that they represent a minimum weight matching to the simulated servers . We choose to be sufficiently large.
We begin by analyzing , reusing ideas from the proof of Theorem 21.
Lemma 24**.**
.
Lemma 25**.**
If , then .
Now consider the case that . We have . The movement costs are canceled by as in Lemma 24. It only remains to bound the possible increase of . We use .
: . 2. 2.
: .
In all of the above, the competitive ratio is bounded by .
Finally, we consider the case . As in the previous Section, whenever , we make use of Lemma 15 to obtain the following result, which then helps us bound :
Lemma 26**.**
If and , then .
Lemma 27**.**
If , then .
The resulting competitive ratio is less than the bound from the former set of cases. Accounting for the loss due to the transformation of the simulated -Page Migration algorithm, we obtain the following upper bound:
Theorem 28**.**
If , the algorithm WMS is -competitive, where is the competitive ratio of the simulated -Page Migration algorithm .
6 Open Problems
The gap between the upper and lower bound is closely related to the question of the deterministic upper bound for -Page Migration: Not only would an -competitive algorithm for -Page Migration directly improve the bound for , it could also give an idea how to improve the analysis of the greedy step in our algorithm, such that the costly transformation of the simulated algorithm would no longer be needed. This would potentially reduce the upper bound by another factor of . On the other hand, if is a lower bound for -Page Migration, this carries over to our model as well. We believe that the main algorithmic idea is suitable to reach an asymptotically optimal competitive ratio, but it remains an open problem to derive a proof of that. The high constants in our proofs are partially due to allowing easier argumentation in certain segments of the proof. There is however also great potential in reducing constants by trying to extend the potential analysis to operate in longer phases instead of doing a step-by-step analysis.
If we allow randomization, we can get an -competitive -Page Migration algorithm from [2]. As discussed in the related work section, the question of the best possible competitive ratio of randomized algorithms for the -Server problem is still open, however we know that a result polylogarithmic in can be achieved [12]. As our construction is entirely deterministic, apart from potentially the simulated algorithm, it would be interesting whether randomization can be used to significantly improve the competitive ratio. The desired result would be an algorithm with a competitive ratio polylogarithmic in . More generally, the problem of finding a randomized algorithm with competitiveness is still open for the classical -Page Migration problem.
Appendix A Details of Section 3
A.1 Proof of Theorem 2
Theorem 2.
For , every randomized online algorithm for the -Mobile Server Problem has a competitive ratio of at least , where is the length of the input sequence.
Proof.
We first explain the proof for in detail and then describe how to extend it to servers. All servers start on the same position on the real line which we identify with 0. The input proceeds in two phases. In the first phase, there are requests on point 0. At the start of the second phase, choose one of the following points uniformly at random: . We refer to this point as . In the second phase, issue requests on .
The optimal solution moves one server to during the first phase and has costs of at most . Since the online algorithm only has two servers, both of its servers have a distance of at least to with probability at least : Divide the line into four segments of size . The online algorithm can at most occupy two of theses segments (cf. Figure 1). As a consequence, the expected costs for the online algorithm in the second phase are at least . The cost ratio is then .
For servers, divide the line to the right of the starting point into segments of size each. The segments are divided into groups of 4. Each group has two inner and two outer segments, where the outer segments neighbor segments of other groups. The adversary now chooses in each group one of the two inner segments uniformly at random. We refer to the middle point in each of the chosen segments as . During the first phase, requests appear at the starting point, and the adversary moves one server to each, the last server remains at the starting point. The moving costs for the adversary are .
In the second phase, on each point , requests appear in order of distance to the starting point. As before, if at the first time when a request appears on and the online algorithm does not have one server in the corresponding segment, then the costs for serving requests for the online algorithm are at least . Now we iterate over the groups of segments: Consider the group which contains . At the time of the first request on the online algorithm either covers both, one or no inner segment of that group. In case of only one covered segment, lies in the other inner segment with probability . Consider a server in one of the inner segments: This server can not move into a neighboring group within time steps. Hence we can regard the servers which cover inner segments as ”used up” for the following groups and hence we may apply the arguments inductively. Let , and the number of groups where the online algorithm covers both, one and no inner segment of that group respectively. We have , and the expected number of segments for which the online algorithm incurs costs of are at least . It is easy to see that the number of these segments are in .
For the ratio we compare the costs and get . ∎
A.2 Proof of Theorem 3
Theorem 3.
For , every randomized online algorithm for the -Mobile Server Problem, where the distance between consecutive requests is bounded by , has a competitive ratio of at least .
Proof.
The proof follows the structure of the proof of Theorem 2. We first describe the bound for and then extend it to servers. All servers start on the same position denoted by [math] on the real line. The input is given in three phases. In the first phase, requests are issued consecutively on point [math]. At the beginning of the second phase, choose uniformly at random one of the points . Let the chosen point be . Now, move the request by towards in each time step until is reached. In the third phase, issue requests consecutively at .
Observe that the request needs at most time steps to get to . The optimal solution moves one of its servers in the first phase to and has a movement cost of at most . Since the distance between the request and an optimal server in each step in the second phase is at most , the costs of the optimal solution in this phase are bounded by . The optimal solution does not incur cost in the third phase.
Since the point is unknown to the online algorithm, with a probability of at least , both servers of the online algorithm have a distance of at least to after the first phase. From here on, we assume that this is this the case. After the second phase the distance of an online server to the request is at least . The costs for serving requests in the third phase is minimized for the online algorithm, if it moves with speed towards in each time step. The induced costs are at least if is sufficiently large.
In total, the competitive ratio is for sufficiently large .
Now consider the case of servers. We use a similar construction as in the proof of Theorem 2, but now divide the line to the right of the starting point into segments of size each. The segments are divided into groups of 5. Each group has three inner and two outer segments, where the outer segments neighbor segments of other groups. The adversary now chooses in each group one of the two inner segments, which neighbor an outer segment uniformly at random. We refer to the middle point in each of the chosen segments as . During the first phase, requests appear at the starting point, and the adversary moves one server to each, the last server remains at the starting point. The moving costs for the adversary are .
In the second phase, on each point , requests appear in order of distance to the starting point, with requests in between when the it moves over the line. The latter type of requests induce costs for the adversary of if is sufficiently large (same argument as above). The costs of the online algorithm can be bounded as in the previous theorem, with the additional argument that while the request moves past the first potential choice for a , any server covering this segment does not get to the second potential candidate in time. With this, the costs for the online algorithm are still .
For the ratio we compare the costs and get for sufficiently large . ∎
Appendix B Details of Section 4
B.1 Proof of Theorem 4
Theorem 4.
For , there are competitive -Server algorithms such that the simple algorithm for the -Mobile Server Problem does not achieve a competitive ratio independent of .
Proof.
Consider the following instance: All servers and the request start at the same point on the real line. The requests moves times to the right by a distance of each. It then moves steps to the left again and remains at that point for the remaining time steps.
An optimal solution may be to just follow the request around with a single server which induces cost . Assume the -Server algorithm does the following: As long as the request moves to the right, it gets served by a single server, the requests after that are served by a second server (this -server algorithm would be at most 2-competitive in this instance). As a result, the online algorithm will move one server to the rightmost point in the sequence and then begin to move a second server towards the request. When the request has reached its final position, the second server of the online algorithm has moved a distance of to the right and hence it takes more time steps for it come closer than a distance of to the request. The server of the online algorithm who followed the request initially to the rightmost point has now a distance of to the request. It follows that the costs of the online algorithm are at least . By setting , the competitive ratio becomes as large as . ∎
B.2 Proof of Proposition 7
Proposition 7.
For the servers of it holds during the whole execution. The costs of are at most times the costs of .
Proof.
We define the following potential: . During a phase, the potential decreases every time moves to by the same amount moves. Each time moves, increases by at most the amount that moves.
We show that during each phase, moves its servers by a total distance of at least . Consider the movement of the request from its starting point to the final point . We know that . Imagine drawing a straight line between and and separating it into segments of length by hyperplanes orthogonal to the line. There are now at least such segments. Since the maximum movement distance of is , there is at least one request per segment.
We consider the configuration of at the beginning of the phase. Every server of has two segments adjacent to its own. Denote the segments which do not contain a server of and are not adjacent to a segment containing such a server unoccupied segments. Since there are segments in total and servers of , there are at least unoccupied segments. For any unoccupied segment it holds that a server of has to move at least to answer a request in the segment since it needs to cross the entire neighboring segment. Thus, for at least segments, the servers of incur costs of at least , implying a total movement cost of at least .
We can now bound the costs at the end of a phase: The argument when is the same as before. Otherwise, increases by at most . This yields .
∎
B.3 Proof of Lemma 9
Lemma 9.
If at the beginning of a long transition between and , then at the end of the transition.
Proof.
During the transition time , moves a distance of at most . At the beginning, and , hence . During the first time steps, can catch up to a distance of and therefore reaches (the speed of is an additional higher which accounts for the movement of ). Since , there are at least 2 time steps remaining where can move ahead to the final position of . ∎
B.4 Proof of Lemma 10
Lemma 10.
Every short transition between in step and in step can increase the distance of some server , which moves at speed at most , to by at most .
Likewise, decreases its distance to by at most .
Proof.
We consider a short transition from offline server to in between time steps and . By definition, .
We show that since and must be relatively close together, their distance to the closest server of the online algorithm must be similar. We first upper bound the distance between and in step : The request travels a distance of at most between the two. During this time, could have moved a distance of at most , and the inner radius could have changed by at most . Since after the time steps enters the inner circle of , we can use the above information to trace the distance between the two servers and the inner circle’s radius of back to time step (see Figure 4.2).
With this knowledge, we get
\begin{array}[]{rrcl}&d_{t_{1}}(o_{j},o_{j}^{a})&\geq&d_{t_{1}}(o_{i},o_{i}^{a})-d_{t_{1}}(o_{i},o_{j})\\ &&\geq&d_{t_{1}}(o_{i},o_{i}^{a})-t^{*}\cdot(m_{c}+m_{s}+\frac{\delta}{16}m_{s})-inner_{t_{1}}(o_{i})-inner_{t_{1}}(o_{j})\\ &&\geq&d_{t_{1}}(o_{i},o_{i}^{a})-3\cdot inner_{t_{1}}(o_{i})-inner_{t_{1}}(o_{j})-4m_{c}\\ &&\geq&(1-3\cdot\frac{\delta^{2}}{48960k})\cdot d_{t_{1}}(o_{i},o_{i}^{a})-\frac{\delta^{2}}{48960k}\cdot d_{t_{1}}(o_{j},o_{j}^{a})-4m_{c}\\ \Leftrightarrow&d_{t_{1}}(o_{j},o_{j}^{a})&\geq&\frac{1-3\cdot\frac{\delta^{2}}{48960k}}{1+\frac{\delta^{2}}{48960k}}\cdot d_{t_{1}}(o_{i},o_{i}^{a})-\frac{4}{1+\frac{\delta^{2}}{48960k}}\cdot m_{c}\\ \Rightarrow&d_{t_{1}}(o_{j},o_{j}^{a})&\geq&(1-\frac{4}{48960k+1})\cdot d_{t_{1}}(o_{i},o_{i}^{a})-4m_{c}.\end{array}
In reverse, we can bound
\begin{array}[]{rrcl}&d_{t_{1}}(o_{i},o_{i}^{a})&\geq&d_{t_{1}}(o_{j},o_{j}^{a})-d_{t_{1}}(o_{i},o_{j})\\ &&\geq&d_{t_{1}}(o_{i},o_{i}^{a})-3\cdot inner_{t_{1}}(o_{i})-inner_{t_{1}}(o_{j})-4m_{c}\\ &&\geq&(1-\frac{\delta^{2}}{48960k})\cdot d_{t_{1}}(o_{j},o_{j}^{a})-\frac{3\delta^{2}}{48960k}\cdot d_{t_{1}}(o_{i},o_{i}^{a})-4m_{c}\\ \Leftrightarrow&d_{t_{1}}(o_{i},o_{i}^{a})&\geq&\frac{1-\frac{\delta^{2}}{48960k}}{1+\frac{3\delta^{2}}{48960k}}\cdot d_{t_{1}}(o_{j},o_{j}^{a})-\frac{4}{1+\frac{3\delta^{2}}{48960k}}\cdot m_{c}\\ \Rightarrow&d_{t_{1}}(o_{i},o_{i}^{a})&\geq&(1-\frac{4}{48960k})\cdot d_{t_{1}}(o_{j},o_{j}^{a})-4m_{c}.\end{array}
Since can move away from during the transition and itself moves at speed at most , we get
\begin{array}[]{rcl}d_{t_{2}}(s,o_{j})&\leq&d_{t_{1}}(s,o_{j})+t^{*}\cdot(2+\delta)m_{s}\\ &\leq&d_{t_{1}}(s,o_{i})+d_{t_{1}}(o_{i},o_{j})+t^{*}\cdot(2+\delta)m_{s}\\ &\leq&d_{t_{1}}(s,o_{i})+t^{*}\cdot(m_{c}+m_{s}+\frac{\delta}{16}m_{s})+inner_{t_{1}}(o_{i})+inner_{t_{1}}(o_{j})+t^{*}\cdot(2+\delta)m_{s}\\ &\leq&d_{t_{1}}(s,o_{i})+5\cdot inner_{t_{1}}(o_{i})+inner_{t_{1}}(o_{j})+8m_{c}\\ &\leq&d_{t_{1}}(s,o_{i})+5\cdot\frac{\delta^{2}}{48960k}\cdot d_{t_{1}}(o_{i},o_{i}^{a})+\frac{\delta^{2}}{48960k}\cdot d_{t_{1}}(o_{j},o_{j}^{a})+8m_{c}.\end{array}
To derive the first bound, we get
\begin{array}[]{rcl}d_{t_{2}}(s,o_{j})&\leq&d_{t_{1}}(s,o_{i})+5\cdot\frac{\delta^{2}}{48960k}\cdot d_{t_{1}}(o_{i},o_{i}^{a})+\frac{\delta^{2}}{48960k}\cdot\frac{1}{1-\frac{4}{48960k}}\cdot d_{t_{1}}(o_{i},o_{i}^{a})\\ &&+(8+\frac{\delta^{2}}{48960k}\cdot\frac{4}{1-\frac{4}{48960k}})\cdot m_{c}\\ &\leq&d_{t_{1}}(s,o_{i})+6.001\frac{\delta^{2}}{48960k}\cdot d_{t_{1}}(o_{i},o_{i}^{a})+8.001m_{c}.\end{array}
For the second bound, we continue with
\begin{array}[]{rcl}d_{t_{2}}(s,o_{j})&\leq&d_{t_{1}}(s,o_{i})+5\cdot\frac{\delta^{2}}{48960k}\cdot d_{t_{1}}(o_{i},o_{i}^{a})+\frac{\delta^{2}}{48960k}\cdot d_{t_{1}}(o_{j},o_{j}^{a})+8m_{c}\\ &\leq&d_{t_{1}}(s,o_{i})+(1+\frac{5}{1-\frac{4}{48960k+1}})\cdot\frac{\delta^{2}}{48960k}\cdot d_{t_{1}}(o_{j},o_{j}^{a})+(8+5\cdot\frac{\delta^{2}}{48960k}\cdot\frac{4}{1-\frac{4}{48960k+1}})m_{c}\\ &\leq&d_{t_{1}}(s,o_{i})+6.001\cdot\frac{\delta^{2}}{48960k}\cdot d_{t_{1}}(o_{j},o_{j}^{a})+8.001\cdot m_{c}.\end{array}
Next we bound the change in during the transition:
\begin{array}[]{rrcl}&d_{t_{1}}(o_{j},o_{j}^{a})&\leq&d_{t_{2}}(o_{j},o_{j}^{a})+t^{*}\cdot(2+\delta)m_{s}\\ &&\leq&d_{t_{2}}(o_{j},o_{j}^{a})+2\cdot inner_{t_{1}}(o_{i})+4m_{c}\\ &&\leq&d_{t_{2}}(o_{j},o_{j}^{a})+2\cdot\frac{\delta^{2}}{48960k}\cdot d_{t_{1}}(o_{i},o_{i}^{a})+4m_{c}\\ &&\leq&d_{t_{2}}(o_{j},o_{j}^{a})+2.001\cdot\frac{\delta^{2}}{48960k}\cdot d_{t_{1}}(o_{j},o_{j}^{a})+4.001m_{c}\\ \Leftrightarrow&d_{t_{1}}(o_{j},o_{j}^{a})&\leq&\frac{1}{1-2.001\cdot\frac{\delta^{2}}{48960k}}\cdot d_{t_{2}}(o_{j},o_{j}^{a})+4.002m_{c}.\end{array}
This gives us
\begin{array}[]{rcl}d_{t_{2}}(s,o_{j})&\leq&d_{t_{1}}(s,o_{i})+\frac{1}{1-2.001\cdot\frac{\delta^{2}}{48960k}}\cdot 6.001\cdot\frac{\delta^{2}}{48960k}\cdot d_{t_{2}}(o_{j},o_{j}^{a})\\ &&+(8.001+6.001\cdot\frac{\delta^{2}}{48960k}\cdot 4.002)\cdot m_{c}\\ &\leq&d_{t_{1}}(s,o_{i})+6.002\cdot\frac{\delta^{2}}{48960k}\cdot d_{t_{2}}(o_{j},o_{j}^{a})+8.002m_{c}.\end{array}
For the bound of decreasing the distance, the same proof can be applied: Start with and use the same estimations as before from there. ∎
B.5 Proof of Lemma 11
Lemma 11.
Consider a sequence of short transitions which is terminated by a long transition. If at the beginning of the sequence, then after the long transition. During the sequence of short transitions, .
Proof.
As in step 2 of the algorithm, we assume the sequence starts at time with , and terminates with a long transition from to between time steps and . selects the server which passes on to over the long transition and follows it. Since for the duration of the sequence, we have at the beginning of the sequence and therefore holds for the entire duration. At the beginning, with
[TABLE]
we get . Furthermore, since at least holds its relative distance to , during any step during the sequence,
[TABLE]
and therefore during the whole sequence. By Lemma 9, we have after the long transition. ∎
B.6 Proof of Lemma 12
Lemma 12.
Consider a sequence of short transitions which is terminated by a short transition from to , where at one point prior in the sequence . If at the beginning of the sequence and at all times, then after the transition to . During the sequence, .
Proof.
We assume the sequence starts at time with , and terminates with a short transition from to between time steps and .
We first consider the case that would run outside if it moved directly to its target point. First, we need to show that is reached before this happens. In the beginning, it holds : . With
[TABLE]
we get .
Now assume . Then
[TABLE]
meaning for the duration of the sequence. Taking the negation of that statement it also follows that is reached before .
Note that can maintain the point at the fixed distance to which is closest to the final position of : Imagine the radius stays fixed and only moves by at most . Then the point at the fixed radius closest to only changes by at most . Afterwards the radius changes by at most and hence the movement speed of is sufficient.
We now need to determine that at the final time step , . Apply Lemma 10 by setting and we can bound .
Now assume it holds true that can move straight towards the final position of with speed without ever leaving . In this case, we compute a path which constitutes an upper bound on the distance has to traverse, using the following definition:
Definition 1** (Transition Path).**
Assume at time step and at some later time step . Consider the path constructed as follows. Start at the position of in time step . Let be the last time step before in which and . The first part of the path goes from ’s position at time step to ’s position in time step . Afterwards, a short transition from to some other server between time step and occurs, in which case our path goes from in to in . Continue the procedure recursively until in time step is reached. We call the constructed path a -transition path. See Figure 2 for an illustration of one of the recursion steps.
Now consider the -transition path. The distance traveled by is bounded by the distance of to at time plus the length of the transition path. The former has a length of .
To upper bound the length of the - transition path, we divide it into two types of edges (excluding the first edge): The first type is between the same offline server in different time steps. If the total time is , the maximum distance induced is .
The second type of edges are between different offline servers and represent a short transition. By construction, there are at most such edges. With the help of Lemma 10 we may upper bound the length of an edge by , where is the time the transition begins (in the lemma, set to a static server at the position of the server who passes the request at time ).
The distance can change in two ways over time: It changes due to the movement of the servers or due to a role change of , where it suffices to consider only those short transitions included in our constructed path. Let be the points in time where the short transitions inducing the second type edges begin. We can upper bound their total length as . Assuming the highest possible distance for each of the , we get for the first transition the total distance of the movement during the sequence added to the original length, which is . The transitions after that build inductively on the resulting lengths. Define . The first edge length is upper bounded by , the resulting value for is . In general, and . We can bound the total increase by
[TABLE]
The total path length may hence bounded by .
For comparison, we lower bound the time it takes to move into position such that a short transition can occur. Take a time step where . We may assume that , otherwise the travel time for simply increases. For a short transition between time steps and to to occur, we need , and . We have (see Figure 4.2 and the proof of Lemma 10).
With we get
[TABLE]
Comparing the distances at and , we conclude that .
In order to lower bound the number of time steps needed for bridging that distance, we first examine the change in . Recall that in and in . We can represent the movement of with the -transition path. The distance can change in two ways over time: It changes due to the movement of the servers or due to a role change of , where it suffices to consider only those short transitions included in our constructed path. If we set the beginnings of the short transitions at time steps , we get the upper bound similar to before:
[TABLE]
Continuing from above, we have
[TABLE]
Now we consider the ways in which shrinks: The first is the movement of and , reducing the distance by at most per time step, i.e., if the entire sequence lasts steps, the maximum reduction is . The other way is by the role change of . Note that above, we just accounted for the change of the distance due to the role change, and not for the change of . Lemma 10 gives us that the distance of to any server decreases by at most . This decrease is maximized the same as above, i.e., .
We can now lower bound the number of time steps it takes to complete the sequence: It is bounded by the minimum time , such that
\begin{array}[]{ccl}&&\hat{t}\cdot 2m_{s}+0.0002\delta^{2}\cdot(d_{t_{1}}(o^{*},o^{*a})+\hat{t}\cdot 2m_{s})+8.002km_{c}\\ &\geq&\frac{\delta}{144}\cdot d_{t_{1}}(o^{*},o^{*a})-\frac{4.001\delta^{2}}{48960k}\cdot(d_{t_{1}}(o^{*},o^{*a})+\hat{t}\cdot(2+\delta)m_{s}\\ &&+1.0002\cdot(d_{t_{1}}(o^{*},o^{*a})+\hat{t}\cdot(2+\delta)m_{s})+8.002km_{c})-4.001m_{c}\\ \Leftrightarrow&&\hat{t}\cdot 2.0004m_{s}+\frac{4.001\delta^{2}}{48960k}\cdot 2.0002\cdot\hat{t}\cdot(2+\delta)m_{s}\\ &\geq&\frac{\delta}{144}\cdot d_{t_{1}}(o^{*},o^{*a})-\frac{4.001\delta^{2}}{48960k}\cdot 2.0002\cdot d_{t_{1}}(o^{*},o^{*a})-0.0002\delta^{2}\cdot d_{t_{1}}(o^{*},o^{*a})\\ &&-8.002km_{c}-\frac{4.001\delta^{2}}{48960k}\cdot 8.002km_{c}-4.001m_{c}\\ \Rightarrow&&2.0009\cdot\hat{t}\cdot m_{s}\geq 0.0065\delta\cdot d_{t_{1}}(o^{*},o^{*a})-12.0047km_{c}.\end{array}
To finish the proof, we show that has enough time to reach its destination by comparing the lower bound of the time takes to move into position to the upper bound of the travel path of :
[TABLE]
∎
B.7 Proof of Lemma 13
Lemma 13.
During the execution of the algorithm, as long as the algorithm is in step 1 or 2.
Proof.
We argue that or . We have demonstrated, that during a sequence of short transitions, never leaves . It remains to show that the statement holds during a long transition. We observe during the transition time . Before the first step, and . We have already shown that for , catches up to within the time in the proof of Lemma 9. Expressed in distance, catches up to when is a distance of outside the inner circle of . We show that at this time, is still in : Let . We have
\begin{array}[]{rcl}d_{t_{1}+\hat{t}}(r,o^{*})&\leq&d_{t_{1}}(r,o{*})+\hat{t}\cdot 2m_{c}\\ &\leq&\frac{\delta^{2}}{48960k}\cdot d_{t_{1}}(o^{*},o^{*a})+2\cdot inner_{t_{1}}(o^{*})+2m_{c}\\ &\leq&3\cdot\frac{\delta^{2}}{48960k}\cdot d_{t_{1}}(o^{*},o^{*a})+2m_{c}.\end{array}
With
\begin{array}[]{rrcl}&d_{t_{1}+\hat{t}}(o^{*},o^{*a})&\geq&d_{t_{1}}(o^{*},o^{*a})-\hat{t}\cdot(2+\delta)m_{s}\\ &&\geq&d_{t_{1}}(o^{*},o^{*a})-2\cdot inner_{t_{1}}(o^{*})-2m_{c}\\ \Leftrightarrow&d_{t_{1}+\hat{t}}(o^{*},o^{*a})+2m_{c}&\geq&(1-\frac{2\delta^{2}}{48960k})\cdot d_{t_{1}}(o^{*},o^{*a})\\ \Rightarrow&2\cdot d_{t_{1}+\hat{t}}(o^{*},o^{*a})+4m_{c}&\geq&d_{t_{1}}(o^{*},o^{*a})\end{array}
we get as long as . This implies that at all times, either or .
We now turn to the claim of the lemma. If , then . If , then and therefore . ∎
B.8 Proof of Lemma 14
Lemma 14.
After the execution of step 3 it holds . Furthermore, during step 3 of the algorithm.
Proof.
We define time steps and such that they encompass step 3 of the algorithm, i.e., and are chosen minimal such that and . Since changes by at most in each time step, .
If at time , the procedure is in a long transition, the algorithm already follows and can continue as usual (the result for the long transition holds independently of ). Otherwise, we have . Hence . The server catches up to a distance of at least per time step. Clearly, and therefore at time .
The second claim, can be shown the same way as in the previous lemma, where it is clear that is reached before falls below . ∎
B.9 Proof of Lemma 16
Lemma 16.
.
Proof.
Assume that . Every other server moves towards its counterpart , hence
\begin{array}[]{rcl}\Delta\psi&\leq&Y\cdot\frac{m_{c}}{\delta m_{s}}\sum\limits_{i=1}^{k}(d(a_{i}^{\prime},c_{i}^{\prime})-d(a_{i},c_{i}))\\ &\leq&Y\cdot\frac{m_{c}}{\delta m_{s}}\left(d(a_{1}^{\prime},c_{1}^{\prime})-d(a_{1},c_{1})+\sum\limits_{i=2}^{k}(d(c_{i},c_{i}^{\prime})-d(a_{i},a_{i}^{\prime}))\right).\\ \end{array}
Now, if serves the request with , i.e., , then
[TABLE]
Otherwise, serves the request with another server (assume ). Since was not chosen as , it moves the full distance of and hence
\begin{array}[]{rcl}\Delta\psi&\leq&Y\cdot\frac{m_{c}}{\delta m_{s}}\left(d(a_{1},a_{1}^{\prime})+d(c_{1},c_{1}^{\prime})+d(c_{2},c_{2}^{\prime})-d(a_{2},a_{2}^{\prime})+\sum\limits_{i=3}^{k}(d(c_{i},c_{i}^{\prime})-d(a_{i},a_{i}^{\prime}))\right)\\ &\leq&Y\cdot\frac{m_{c}}{\delta m_{s}}\left(\sum\limits_{i=1}^{k}d(c_{i},c_{i}^{\prime})-\frac{\delta}{2}m_{s}-\sum\limits_{i=3}^{k}d(a_{i},a_{i}^{\prime})\right).\end{array}
The lemma follows by setting , as . ∎
B.10 Proof of Lemma 17
Lemma 17.
If , then
Proof.
We assume . Since , we have . If is served by , then
[TABLE]
If is served by a different server of (assume ), then
[TABLE]
This term is larger then the former one for sufficiently large . ∎
B.11 Proof of Lemma 18
Lemma 18.
If and , then .
Proof.
By our construction of the simulated -Server algorithm, we have . Furthermore,
[TABLE]
Hence
[TABLE]
and with Lemma 15, we get .
In order to bound the movement of , we need to show that . We use
\begin{array}[]{rrcl}&d(a^{*},r^{\prime})&\leq&m_{c}+d(a^{*^{\prime}},r^{\prime})\\ &&\leq&m_{c}+d(o^{*a^{\prime}},r^{\prime})\\ &&\leq&m_{c}+(1+\frac{\delta^{2}}{48960k})\cdot d(o^{*^{\prime}},o^{*a^{\prime}})\\ \Leftrightarrow&\frac{1}{1+\frac{\delta^{2}}{48960k}}(d(a^{*},r^{\prime})-m_{c})&\leq&d(o^{*^{\prime}},o^{*a^{\prime}})\end{array}
The bound follows from .
From Proposition 8 we get and therefore .
∎
B.12 Proof of Lemma 19
Lemma 19.
If , then .
Proof.
: We use
[TABLE]
to get . Furthermore, due to Lemma 17. In total, with . 2. 2.
: We show that the condition of Lemma 18 applies:
[TABLE]
Hence the lemma gives us
[TABLE]
Furthermore, we have
[TABLE]
and due to Lemma 16. In total, we get .
∎
Appendix C Details of Section 5
C.1 Proof of Theorem 21
Theorem 21.
If for some , the algorithm WMS is -competitive, where is the competitive ratio of the simulated -Page Migration algorithm .
Proof.
We assume the servers adapt their ordering according to the minimum matching in each time step. Based on the matching, we define the following potential: . We observe, that in all time steps it holds . We fix a time step and assume .
First examine the case that moves towards its matching partner instead of . Then and . Consider the server which is matched to : Either it reaches or it moves a distance of . In the first case which gives a competitive ratio of immediately. In the latter case, there is a server such that and hence which implies a competitive ratio of at most as well.
Now assume moves towards and hence . We have . In all of the following cases, we make use of
[TABLE]
We distinguish the following cases with respect to the positioning of the pages of :
:
Since we assume , we have
\begin{array}[]{rrcl}&D\cdot d(a_{1},a_{1}^{\prime})&\leq&d(a_{1},r^{\prime})\\ &&\leq&d(a_{1},a_{1}^{\prime})+d(a_{1}^{\prime},r^{\prime})\\ \Rightarrow&\frac{D}{2}\cdot d(a_{1},a_{1}^{\prime})&\leq&d(c^{*^{\prime}},r^{\prime}).\end{array}
It follows and . 2. 2.
and :
We know that and hence . If then , otherwise . 3. 3.
and :
We assume . It must hold and hence . In the case , . This gives us . With the bound follows.
In case , . Similar as before, and .
∎
C.2 Proof of Proposition 23
Proposition 23.
Let be an online algorithm for the -Page Migration Problem. There exists an online algorithm for the -Page Migration Problem with pages such that it holds during the whole execution. The costs of are at most times the costs of .
Proof.
The servers of are denoted as and the servers of as .
We define two circles around : The inner circle has a radius of and the outer circle has a radius of . We will maintain for the entirety of the execution. The time is divided into phases, where each phase ends when there is a distance of between the current position and the position at the beginning of the phase of . During a phase the simulated servers move to preserve the following:
- •
If , then .
At the end of the phase the servers move such that the following holds:
- •
If , then .
- •
If , then is on the boundary of such that is minimized.
We define the following potential: . During a phase, the potential decreases every time moves to by times the amount moves. Each time moves, increases by at most times the amount that moves. In case for the closest server of to , which is , to hold , then and hence the serving costs of the algorithms are the same. Otherwise, , and hence the serving costs differ at most by a factor of 3.
We show that during each phase, has costs of at least . Consider the movement of the request from its starting point to the final point . We know that . Imagine drawing a straight line between and and separating it into segments of length by hyperplanes orthogonal to the line. There are now at least such segments. Every server of has two segments adjacent to its own. Denote the segments which do not contain a server of and are not adjacent to a segment containing such a server unoccupied segments. Since there are segments in total and servers of , there are at least unoccupied segments at the beginning of a phase. Since the maximum movement distance of is , there is at least one request per segment.
The servers of divide the unoccupied segments into at most many groups of segments right next to each other. We now analyze the cost of a group of size . We only consider one half of the group and argue that the other half has at least the same cost. Requests in the given segments can be served the following way: An adjacent server moves into the first segments and then serves the remaining segments over the distance. The costs incurred are at least . This term is minimized by setting which implies cost of at least . No matter how the unoccupied segments are divided into groups, this gives a total cost of at least .
We can now bound the costs at the end of phase: The argument when is the same as before. Otherwise, increases by at most . This yields . ∎
C.3 Proof of Lemma 24
Lemma 24.
.
Proof.
Assume that . Every other server moves towards its counterpart , hence
\begin{array}[]{rcl}\Delta\psi&\leq&Y\cdot D\frac{m_{c}}{\delta m_{s}}\sum\limits_{i=1}^{k}(d(a_{i}^{\prime},c_{i}^{\prime})-d(a_{i},c_{i}))\\ &\leq&Y\cdot D\frac{m_{c}}{\delta m_{s}}\left(d(a_{1}^{\prime},c_{1}^{\prime})-d(a_{1},c_{1})+\sum\limits_{i=2}^{k}(d(c_{i},c_{i}^{\prime})-d(a_{i},a_{i}^{\prime}))\right).\\ \end{array}
First examine the case that moves towards its matching partner instead of . Then .
Now assume moves towards . We have . We distinguish the following cases with respect to the positioning of the pages of :
:
Since we assume , we have
\begin{array}[]{rrcl}&D\cdot d(a_{1},a_{1}^{\prime})&\leq&d(a_{1},r^{\prime})\\ &&\leq&d(a_{1},a_{1}^{\prime})+d(a_{1}^{\prime},r^{\prime})\\ \Rightarrow&\frac{D}{2}\cdot d(a_{1},a_{1}^{\prime})&\leq&d(c^{*^{\prime}},r^{\prime}).\end{array}
It follows . 2. 2.
and :
We know that and hence . 3. 3.
and :
We assume . It must hold and hence . This gives us . It follows .
∎
C.4 Proof of Lemma 25
Lemma 25.
If , then .
Proof.
Assume that . Every other server moves towards its counterpart , hence
\begin{array}[]{rcl}\Delta\psi&\leq&Y\cdot D\frac{m_{c}}{\delta m_{s}}\sum\limits_{i=1}^{k}(d(a_{i}^{\prime},c_{i}^{\prime})-d(a_{i},c_{i}))\\ &\leq&Y\cdot D\frac{m_{c}}{\delta m_{s}}\left(d(a_{1}^{\prime},c_{1}^{\prime})-d(a_{1},c_{1})+\sum\limits_{i=2}^{k}(d(c_{i},c_{i}^{\prime})-d(a_{i},a_{i}^{\prime}))\right).\\ \end{array}
First examine the case that moves towards its matching partner instead of . Then since the server matched to moves the full distance.
Now assume moves towards . If , we know that and hence with .
Otherwise, we assume . It must hold and hence . This gives us . It follows . ∎
C.5 Proof of Lemma 26
Lemma 26.
If and , then .
Proof.
By our construction of the simulated -Server algorithm, we have . Furthermore,
[TABLE]
Hence
[TABLE]
and with Lemma 15, follows.
In order to bound the movement of , we need to show that . We use
\begin{array}[]{rrcl}&d(a^{*},r^{\prime})&\leq&m_{c}+d(a^{*^{\prime}},r^{\prime})\\ &&\leq&m_{c}+d(o^{*a^{\prime}},r^{\prime})\\ &&\leq&m_{c}+(1+\frac{\delta^{2}}{48960k})\cdot d(o^{*^{\prime}},o^{*a^{\prime}})\\ \Leftrightarrow&\frac{1}{1+\frac{\delta^{2}}{48960k}}(d(a^{*},r^{\prime})-m_{c})&\leq&d(o^{*^{\prime}},o^{*a^{\prime}})\end{array}
The bound follows from .
From Theorem 8 we get and therefore . ∎
C.6 Proof of Lemma 27
Lemma 27.
If , then .
Proof.
: First consider the case . With Lemma 24 we can bound the movement costs of the algorithm. Furthermore, we use
[TABLE]
to get
[TABLE]
Hence . In total, with .
Otherwise, Lemma 25 applies which gives us . We may either use or
[TABLE]
gives us . In any case, with . 2. 2.
: We show that the condition of Lemma 26 applies:
[TABLE]
Hence the lemma gives us
[TABLE]
Furthermore, we have
[TABLE]
and due to Lemma 25. In total, we get .
∎
The reference list from the paper itself. Each links out to its DOI / PubMed record.
- 1[1] Nikhil Bansal, Niv Buchbinder, Aleksander Madry, and Joseph Naor. A polylogarithmic-competitive algorithm for the k -server problem. J. ACM , 62(5):40:1–40:49, 2015.
- 2[2] Yair Bartal, Moses Charikar, and Piotr Indyk. On page migration and other relaxed task systems. Theor. Comput. Sci. , 268(1):43–66, 2001.
- 3[3] Yair Bartal and Elias Koutsoupias. On the competitive ratio of the work function algorithm for the k-server problem. Theor. Comput. Sci. , 324(2-3):337–345, 2004.
- 4[4] Marcin Bienkowski, Jaroslaw Byrka, and Marcin Mucha. Dynamic beats fixed: On phase-based algorithms for file migration. In Proceedings of the 44th International Colloquium on Automata, Languages, and Programming (ICALP) , pages 13:1–13:14, 2017.
- 5[5] David L. Black and Daniel D. Sleator. Competitive algorithms for replication and migration problems. Technical Report CMU-CS-89-201, Department of Computer Science, Carnegie-Mellon University, 1989.
- 6[6] Sébastien Bubeck, Michael B. Cohen, Yin Tat Lee, James R. Lee, and Aleksander Madry. k-server via multiscale entropic regularization. In Proceedings of the 50th Annual ACM SIGACT Symposium on Theory of Computing (STOC) , pages 3–16, 2018.
- 7[7] Marek Chrobak, Howard J. Karloff, T. H. Payne, and Sundar Vishwanathan. New results on server problems. SIAM J. Discrete Math. , 4(2):172–181, 1991.
- 8[8] Björn Feldkord and Friedhelm Meyer auf der Heide. The mobile server problem. In Proceedings of the 29th ACM Symposium on Parallelism in Algorithms and Architectures (SPAA) , pages 313–319, 2017.
