Concurrent Distributed Serving with Mobile Servers

Abdolhamid Ghodselahi; Fabian Kuhn; Volker Turau

arXiv:1902.07354·cs.DC·October 16, 2023

Concurrent Distributed Serving with Mobile Servers

Abdolhamid Ghodselahi, Fabian Kuhn, Volker Turau

PDF

TL;DR

This paper presents a distributed protocol for mobile server resource allocation in large-scale networks, achieving near-optimal efficiency and scalability through innovative algorithms and analysis on hierarchical tree topologies.

Contribution

It introduces the GNN protocol for distributed server location and request handling, with proven competitiveness and optimality on hierarchical well-separated trees.

Findings

01

GNN is starvation-free and handles asynchronous requests effectively.

02

On HSTs, GNN achieves an expected O(log n) competitive ratio.

03

A lower bound of Ω(max{k, log n / log log n}) on the competitive ratio is established.

Abstract

This paper introduces a new resource allocation problem in distributed computing called distributed serving with mobile servers (DSMS). In DSMS, there are $k$ identical mobile servers residing at the processors of a network. At arbitrary points of time, any subset of processors can invoke one or more requests. To serve a request, one of the servers must move to the processor that invoked the request. Resource allocation is performed in a distributed manner since only the processor that invoked the request initially knows about it. All processors cooperate by passing messages to achieve correct resource allocation. They do this with the goal to minimize the communication cost. Routing servers in large-scale distributed systems requires a scalable location service. We introduce the distributed protocol GNN that solves the DSMS problem on overlay trees. We prove that GNN is…

Tables1

Table 1. Table 1 : The essential notations used throughout the paper.

Notation

Definition

Page

n

k

ℛ

r_{i} = (v_{i}, t_{i})

π_{Alg}^{z}

r_{0}^{z} = (v^{z}, 0)

s^{z}

ℛ_{Alg}^{z}

π_{Alg}^{z} ​ (i)

ℓ_{Alg} ​ (μ)

c_{Alg} ​ (r_{i}, r_{j})

C_{Alg} ​ (π_{Alg}^{z})

C_{Alg}

d_{G} ​ (u, v)

H

μ ​ (v)

B

r_{𝑠𝑟𝑐} ​ (μ)

r_{𝑑𝑒𝑠} ​ (μ)

e ​ (μ)

μ ​ (e)

T

ℱ_{Alg}

F_{Alg}^{z}

L_{Alg} ​ (F)

w_{G} ​ (e = (r_{i}, r_{j}))

W_{G} ​ (F)

ℛ_{D}

F ​ (T^{'})

ℱ_{Grd}

(μ, μ^{'})

ℱ_{m ​ d ​ f}

E^{o ​ l ​ d}

E^{n ​ e ​ w}

E^{p ​ o ​ t}

E^{p ​ o ​ t} ​ (e)

E^{o ​ l ​ d} ​ (e)

Φ ​ (F)

ℱ_{\min}

M^{↑} ​ (T^{'})

M^{↓} ​ (T^{'})

δ ​ (T^{'})

number of pints/nodes/processors

number of servers

input requests

request

r_{i}

that is invoked by node

v_{i}

at time

t_{i}

z

-th schedule as one of the

k

resulted schedules by Alg

dummy request

z

as the tail of

π_{Alg}^{z}

z

-th server that serves all requests in

π_{Alg}^{z}

request set of

π_{Alg}^{z}

index of the request scheduled at the

i

-th position of

π_{Alg}^{z}

latency of message

μ

in an execution of Alg

cost incurred by Alg for scheduling

r_{j}

as the successor of

r_{i}

total cost incurred by Alg for scheduling requests in

z

-th schedule

total cost incurred by Alg

weight of the shortest path between

u

and

v

on the input graph

G

directed version of

T

that is changing during a Gnn execution

find-predecessor message sent by

v

complete graph on requests in

ℛ

corresponding request with message

μ

predecessor request of

r_{𝑠𝑟𝑐} ​ (μ)

edge constructed by message

μ

message that constructs the edge

e

input HST

resulted forest by Alg; also, set of edges of the forest

z

-th TSP path of

ℱ_{Alg}

; also, set of edges of the

z

-th TSP path

total cost of

F

such that

F \subseteq ℱ_{Alg}

weight of the shortest path between

v_{i}

and

v_{j}

on the input graph

G

total weight of

F

w.r.t. measurements on the input graph

G

set of

k

dummy requests;

ℛ_{D} \subseteq ℛ

subgraph of

F

induced by the requests contained in

F

and

T^{'}

locality-based forest

gap

resulted forest by the transformation of

ℱ_{Gnn}

set of edges removed throughout the transformation of

ℱ_{Gnn}

set of edges added throughout the transformation of

ℱ_{Gnn}

{e \in ℱ_{Gnn} : (μ ​ (e), μ ​ (e^{'})) ​ is a gap for some ​ e^{'} \in E^{o ​ l ​ d}}

subset of

E^{p ​ o ​ t}

filtered out by

e \in E^{o ​ l ​ d}

subset of

E^{o ​ l ​ d}

filtered out by

e \in E^{p ​ o ​ t}

potential of

F

minimum weight

ℛ_{D}

-respecting spanning

k

-forest of

B

set of messages that leave

T^{'}

set of messages that enter

T^{'}

diameter of

T^{'}

1
1
2.2
2.2
2.2
2.2
2.2
2.3
2.3
2.3
2.3
1
2
2.4
3.1
3.1
4
3
3
4
4
4
4
4
4
4
5
4
4
4
4.1
4.1
6
6
6
4.1
4.1
4.1
5.1
5.3.1
5.3.1
5.3.1

Equations80

C_{\textsc A l g} (π_{\textsc A l g}^{z}) := i = 1 \sum ∣ R_{\textsc A l g}^{z} ∣ - 1 c_{\textsc A l g} (r_{π_{\textsc A l g}^{z} (i - 1)}, r_{π_{\textsc A l g}^{z} (i)}) .

C_{\textsc A l g} (π_{\textsc A l g}^{z}) := i = 1 \sum ∣ R_{\textsc A l g}^{z} ∣ - 1 c_{\textsc A l g} (r_{π_{\textsc A l g}^{z} (i - 1)}, r_{π_{\textsc A l g}^{z} (i)}) .

C_{\textsc A l g} := z = 1 \sum k C_{\textsc A l g} (π_{\textsc A l g}^{z}) .

C_{\textsc A l g} := z = 1 \sum k C_{\textsc A l g} (π_{\textsc A l g}^{z}) .

c_{\textsc A l g} (r, r^{'}) = ℓ_{\textsc A l g} (μ^{'}) .

c_{\textsc A l g} (r, r^{'}) = ℓ_{\textsc A l g} (μ^{'}) .

L_{\textsc{Alg}}(F):=\sum_{e\in F}\ell_{\textsc{Alg}}\big{(}\mu(e)\big{)}.

L_{\textsc{Alg}}(F):=\sum_{e\in F}\ell_{\textsc{Alg}}\big{(}\mu(e)\big{)}.

W_{G} (F) := e \in F \sum w_{G} (e) .

W_{G} (F) := e \in F \sum w_{G} (e) .

\ell_{\textsc{Gnn}}\big{(}\mu(e)\big{)}\leq w_{T}(e)

\ell_{\textsc{Gnn}}\big{(}\mu(e)\big{)}\leq w_{T}(e)

E^{pot}:=\left\{e\in\mathcal{F}_{\textsc{Gnn}}:\big{(}\mu(e),\mu(e^{\prime})\big{)}\ \text{is a gap for some}\ e^{\prime}\in E^{old}\right\}.

E^{pot}:=\left\{e\in\mathcal{F}_{\textsc{Gnn}}:\big{(}\mu(e),\mu(e^{\prime})\big{)}\ \text{is a gap for some}\ e^{\prime}\in E^{old}\right\}.

w_{T} (e_{i}^{o l d}) \leq w_{T} (e_{i}^{n e w}) + Φ (E^{p o t} ∖ {e_{1}^{p o t}, \dots, e_{i - 1}^{p o t}}) - Φ (E^{p o t} ∖ {e_{1}^{p o t}, \dots, e_{i}^{p o t}})

w_{T} (e_{i}^{o l d}) \leq w_{T} (e_{i}^{n e w}) + Φ (E^{p o t} ∖ {e_{1}^{p o t}, \dots, e_{i - 1}^{p o t}}) - Φ (E^{p o t} ∖ {e_{1}^{p o t}, \dots, e_{i}^{p o t}})

Φ (E^{p o t} ∖ {e_{1}^{p o t}, \dots, e_{i - 1}^{p o t}}) - Φ (E^{p o t} ∖ {e_{1}^{p o t}, \dots, e_{i}^{p o t}}) = w_{T} (e_{i}^{p o t}) - ℓ_{\textsc G nn} (e_{i}^{p o t}) .

Φ (E^{p o t} ∖ {e_{1}^{p o t}, \dots, e_{i - 1}^{p o t}}) - Φ (E^{p o t} ∖ {e_{1}^{p o t}, \dots, e_{i}^{p o t}}) = w_{T} (e_{i}^{p o t}) - ℓ_{\textsc G nn} (e_{i}^{p o t}) .

W_{T} (E^{o l d}) \leq W_{T} (E^{n e w}) + Φ (E^{p o t}) .

W_{T} (E^{o l d}) \leq W_{T} (E^{n e w}) + Φ (E^{p o t}) .

C_{\textsc A l g} (π_{\textsc A l g}^{z}) = L_{\textsc A l g} (F_{\textsc A l g}^{z}) .

C_{\textsc A l g} (π_{\textsc A l g}^{z}) = L_{\textsc A l g} (F_{\textsc A l g}^{z}) .

C_{\textsc A l g} = L_{\textsc A l g} (F_{\textsc A l g}) := z = 1 \sum k L_{\textsc A l g} (F_{\textsc A l g}^{z}) .

C_{\textsc A l g} = L_{\textsc A l g} (F_{\textsc A l g}) := z = 1 \sum k L_{\textsc A l g} (F_{\textsc A l g}^{z}) .

C_{\textsc O pt} \geq W_{G} (F_{\textsc O pt}) .

C_{\textsc O pt} \geq W_{G} (F_{\textsc O pt}) .

W_{G} (F_{\textsc O pt}) \geq W_{G} (F_{m i n}) .

W_{G} (F_{\textsc O pt}) \geq W_{G} (F_{m i n}) .

W_{T} (F_{m i n}) = W_{T} (F_{\textsc G r d}) .

W_{T} (F_{m i n}) = W_{T} (F_{\textsc G r d}) .

C_{\textsc A l g} = L_{\textsc A l g} (F_{\textsc A l g}) \leq W_{T} (F_{\textsc G r d}) .

C_{\textsc A l g} = L_{\textsc A l g} (F_{\textsc A l g}) \leq W_{T} (F_{\textsc G r d}) .

C_{\textsc O pt} \geq W_{T} (F_{\textsc O pt}) \geq W_{T} (F_{\textsc G r d}) .

C_{\textsc O pt} \geq W_{T} (F_{\textsc O pt}) \geq W_{T} (F_{\textsc G r d}) .

t_{1}^{↑} (T^{'}) < t_{1}^{↓} (T^{'}) \leq t_{2}^{↑} (T^{'}) < t_{2}^{↓} (T^{'}) \leq t_{3}^{↑} (T^{'}) < \dots .

t_{1}^{↑} (T^{'}) < t_{1}^{↓} (T^{'}) \leq t_{2}^{↑} (T^{'}) < t_{2}^{↓} (T^{'}) \leq t_{3}^{↑} (T^{'}) < \dots .

t_{1}^{↑} (T^{'}) < t_{1}^{↓} (T^{'}) \leq t_{2}^{↑} (T^{'}) .

t_{1}^{↑} (T^{'}) < t_{1}^{↓} (T^{'}) \leq t_{2}^{↑} (T^{'}) .

t_{1}^{↑} (T^{'}) < t_{1}^{↓} (T^{'}) \leq t_{2}^{↑} (T^{'}) < \dots \leq t_{j - 1}^{↑} (T^{'}) < t_{j - 1}^{↓} (T^{'}) \leq t_{j}^{↑} (T^{'}) .

t_{1}^{↑} (T^{'}) < t_{1}^{↓} (T^{'}) \leq t_{2}^{↑} (T^{'}) < \dots \leq t_{j - 1}^{↑} (T^{'}) < t_{j - 1}^{↓} (T^{'}) \leq t_{j}^{↑} (T^{'}) .

t_{1}^{↑} (T^{'}) < t_{1}^{↓} (T^{'}) \leq t_{2}^{↑} (T^{'}) < \dots \leq t_{j}^{↑} (T^{'}) < t_{j}^{↓} (T^{'}) \leq t_{j + 1}^{↑} (T^{'}) .

t_{1}^{↑} (T^{'}) < t_{1}^{↓} (T^{'}) \leq t_{2}^{↑} (T^{'}) < \dots \leq t_{j}^{↑} (T^{'}) < t_{j}^{↓} (T^{'}) \leq t_{j + 1}^{↑} (T^{'}) .

∣ M^{↓} (T^{'}) ∣ \leq ∣ M^{↑} (T^{'}) ∣ \leq ∣ M^{↓} (T^{'}) ∣ + 1.

∣ M^{↓} (T^{'}) ∣ \leq ∣ M^{↑} (T^{'}) ∣ \leq ∣ M^{↓} (T^{'}) ∣ + 1.

L_{\textsc G nn} (F_{\textsc G nn}) \leq W_{T} (F_{m df}) .

L_{\textsc G nn} (F_{\textsc G nn}) \leq W_{T} (F_{m df}) .

ℓ_{\textsc G nn} (μ) \leq δ (T^{'}) .

ℓ_{\textsc G nn} (μ) \leq δ (T^{'}) .

\ell_{\textsc{Gnn}}\big{(}\mu,v_{\mathit{src}}(\mu),v\big{)}\leq\ell_{\textsc{Gnn}}\big{(}\mu^{\prime},v_{\mathit{src}}(\mu^{\prime}),v\big{)}.

\ell_{\textsc{Gnn}}\big{(}\mu,v_{\mathit{src}}(\mu),v\big{)}\leq\ell_{\textsc{Gnn}}\big{(}\mu^{\prime},v_{\mathit{src}}(\mu^{\prime}),v\big{)}.

ℓ_{\textsc G nn} (μ)

ℓ_{\textsc G nn} (μ)

\forall p \in [2, i] : t_{p - 1}^{↓} \leq t_{p}^{↑}

\forall p \in [2, i] : t_{p - 1}^{↓} \leq t_{p}^{↑}

t_{i}^{↓} \leq t_{1}^{↑} .

t_{i}^{↓} \leq t_{1}^{↑} .

w_{T} (e_{z}^{n e w}) = δ (T_{1}^{'}) = 2 \cdot d_{T} (v_{src} (μ_{z}^{o l d}), v_{1}) .

w_{T} (e_{z}^{n e w}) = δ (T_{1}^{'}) = 2 \cdot d_{T} (v_{src} (μ_{z}^{o l d}), v_{1}) .

w_{T} (e_{z}^{o l d}) = w_{T} (e_{z}^{n e w}) + 2 \cdot (d_{T} (v_{i}, v) + p = 1 \sum i - 1 d_{T} (v_{p}, v_{p + 1})) .

w_{T} (e_{z}^{o l d}) = w_{T} (e_{z}^{n e w}) + 2 \cdot (d_{T} (v_{i}, v) + p = 1 \sum i - 1 d_{T} (v_{p}, v_{p + 1})) .

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.

Full text

Concurrent Distributed Serving with Mobile Servers111This work is supported by the Deutsche Forschungsgemeinschaft (DFG), under grant DFG

TU 221/6-3. A shorter version of this paper is to appear in the proceedings of ISAAC 2019.

Abdolhamid Ghodselahi Hamburg University of Technology, Germany. {abdolhamid.ghodselahi,turau}@tuhh.de

Fabian Kuhn University of Freiburg, Germany. [email protected]

Volker Turau22footnotemark: 2

Abstract

This paper introduces a new resource allocation problem in distributed computing called distributed serving with mobile servers (DSMS). In DSMS, there are $k$ identical mobile servers residing at the processors of a network. At arbitrary points of time, any subset of processors can invoke one or more requests. To serve a request, one of the servers must move to the processor that invoked the request. Resource allocation is performed in a distributed manner since only the processor that invoked the request initially knows about it. All processors cooperate by passing messages to achieve correct resource allocation. They do this with the goal to minimize the communication cost.

Routing servers in large-scale distributed systems requires a scalable location service. We introduce the distributed protocol Gnn that solves the DSMS problem on overlay trees. We prove that Gnn is starvation-free and correctly integrates locating the servers and synchronizing the concurrent access to servers despite asynchrony, even when the requests are invoked over time. Further, we analyze Gnn for “one-shot” executions, i.e., all requests are invoked simultaneously. We prove that when running Gnn on top of a special family of tree topologies—known as hierarchically well-separated trees (HSTs)—we obtain a randomized distributed protocol with an expected competitive ratio of $\operatorname{O}\bigl{(}\log n\bigr{)}$ on general network topologies with $n$ processors. From a technical point of view, our main result is that Gnn optimally solves the DSMS problem on HSTs for one-shot executions, even if communication is asynchronous. Further, we present a lower bound of $\Omega(\max\{k,\log n/\log\log n\})$ on the competitive ratio for DSMS. The lower bound even holds when communication is synchronous and requests are invoked sequentially.

Keywords: Distributed online resource allocation, Distributed directory, Asynchronous communication, Amortized analysis, Tree embeddings

1 Introduction

Consider the following family of online resource allocation problems. We are given a metric space with $n$ points. Initially, a set of $k\geq 1$ 222Table 1 provides an index for the essential notations used throughout the paper. identical mobile servers are residing at different points of the metric space. Requests arrive over time in an online fashion, that is, one or several requests can arrive at any point of time. A request needs to be served by a server at the requesting point sometime after its arrival. The goal is to provide a schedule for serving all requests. This abstract problem lies at the heart of many centralized and distributed online applications in industrial planning, operating systems, content distribution in networks, and scheduling [AP95, BFR92, BR92, HTW01, Ray89]. Each concrete problem of this family is characterized by a cost function. We study this abstract problem in distributed computing and call it the distributed serving with mobile servers (DSMS) problem. A distributed protocol Alg that solves the DSMS problem must compute a schedule for each server consisting of a queue of requests such that consecutive requests are successively served, and all requests are served. The $k$ schedules are distributedly stored at the requesting nodes: each node knows for each of its requests the node which invoked the subsequent request in the schedule so that a server after serving one request can subsequently move to the next node (not necessarily a different node). As long as new requests are invoked the schedule is extended. Therefore, in response to the appearance of a new request at a given processor, Alg must contact a processor that invoked a request but yet has no successor request in the global schedule, to instruct the motion of the corresponding server. This will result in the entry of a server to the requesting processor. Sending a server from a processor to another one is done using an underlying routing scheme that routes most efficiently. The goal is to minimize the ratio between the communication costs of an online and an optimal offline protocols that solve DSMS. We assume that an optimal offline DSMS protocol Opt knows the whole sequence of requests in advance. However, Opt still needs to send messages from each request to its predecessor request. The DSMS problem has some interesting applications. We state two of them:

Distributed $k$ -server problem: The $k$ -server problem [BBMN11, MMS88], is arguably one of the most influential research problems in the area of online algorithms and competitive analysis. The distributed $k$ -server was studied in [BR92] where requests arrive sequentially one by one, but only after the current request is served. The cost function for this problem is defined as the sum of all communication costs and the total movement costs of all servers. A generalization of the $k$ -server problem where requests can arrive over time is called the online service with delay (OSD) problem [AGGP17, BKS18]. The OSD cost function is defined as the sum of the total movement costs of all servers and the total delay cost. The delay of a request is the difference between the service and the arrival times.

Distributed queuing problem: This problem is an application of DSMS with $k=1$ , i.e., only one server or shared object [DH98, HKTW06, HTW01]. The distributed queuing problem is at the core of many distributed problems that schedule concurrent access requests to a shared object. The goal is to minimize the sum of the total communication cost and the total “waiting time”. The waiting time of a request is the difference between the times when the request message reaches the processor of the predecessor request and when the predecessor request is invoked. Note that in this problem, the processor of a request must only send one message to the processor of the predecessor request in the global schedule. Two well-known applications for this problem are distributed mutual exclusion [NT87, Ray89, vdS87] and distributed transactional memory [ZR10].

Next, we explain why DSMS is also interesting from a theoretical point of view even for one-shot executions, that is, when all requests are simultaneously invoked. Figure 1 shows a rooted tree $T$ , where the lengths of all edges of each level are equal. Further, the length of every edge is shorter than the length of its parent edge by some factor larger than one. A set of six requests arrive at the leaves of $T$ at the same time. Two servers $s_{0}$ , $s_{1}$ are initially located at the points that invoked requests $r_{0}^{1}$ and $r_{0}^{2}$ . Serving the requests $r_{0}^{1}$ and $r_{0}^{2}$ does not require communication, and these two requests are the current tails of the queues of $s_{0}$ and $s_{1}$ . The requests $r_{0}^{1}$ and $r_{0}^{2}$ are at the heads of the two queues. An optimal solution for serving the remaining requests is that $s_{0}$ consecutively serves the requests $r_{b}$ , $r_{c}$ , and $r_{a}$ after serving $r_{0}^{1}$ , while $s_{1}$ serves $r_{d}$ after having served $r_{0}^{2}$ . Next, consider an asynchronous network where message latencies are arbitrary and protocols have no control over these latencies. A possible schedule, in this case, is shown in Figure 1: Request $r_{a}$ is scheduled after $r_{0}^{1}$ , $r_{b}$ after $r_{a}$ , and $r_{d}$ after $r_{b}$ , since the message latency of a request further away can be much less than the latency of a closer request. This can lead to complications with regard to improving the locality as it is met in the above optimal solution.

GNN protocol: We devise the generalized nearest-neighbor (Gnn) protocol that greedily solves the DSMS problem on overlay trees. An overlay tree $T$ is a rooted tree that is constructed on top of the underlying network. The processors of the original network are in a one-to-one correspondence with the leaves of $T$ . Hence, only $T$ 's leaves can invoke requests, and the remaining overlay nodes are artificial. The $k$ servers reside at different leaves of $T$ . Initially, all edges of $T$ are oriented such that from each leaf there is a directed path to a leaf, where a server resides. This also implies that every leaf node with a server has a self-loop. Roughly speaking, the main idea of Gnn is to update the directions of edges with respect to future addresses of a server. A leaf invoking a request forwards a message along the directed links, the orientations of all these links are inverted. When a message reaches a node and finds several outgoing (upward/downward) links, it is forwarded via an arbitrary downward link to find the current or a future address of a server. We show that in Gnn a processor holding a request always sends a message through a direct path to the processor of the predecessor request in the global schedule. We refer to Section 3 for a formal description of Gnn.

1.1 Our Contribution

This paper introduces the DSMS problem as a distributed online allocation problem. We devise the greedy protocol Gnn that solves the DSMS problem on overlay trees. We prove that even in an asynchronous system Gnn operates correctly, that is, it does not suffer from starvation, nor livelocks, or deadlocks. To the best of our knowledge, Gnn is the first link-reversal-based protocol that supports navigating more than one server.

Theorem 1.1.

Suppose the overlay tree $T$ is constructed on top of a distributed network. Consider the DSMS problem on $T$ where a set of $k\geq 1$ identical mobile servers are initially located at different leaves of $T$ . Further, a sequence of requests can be invoked at any time by the leaves of $T$ . Then Gnn schedules all requests to be served by some server at the requested points in a finite time despite asynchrony.

While Gnn itself solves any instance of the DSMS problem, we analyze Gnn for the particular case that the requests are simultaneously invoked. We consider general distributed networks with $n$ processors. We model such a network by a graph $G$ . A hierarchically well-separated tree (HST) is an overlay tree with parameter $\alpha>1$ , that is, an $\alpha$ -HST is a rooted tree where every edge weight is shorter by a factor of $\alpha$ from its parent edge weight. A tree is an HST if it is an $\alpha$ -HST for some $\alpha>1$ . There is a randomized embedding of any graph into a distribution over HSTs [Bar96, FRT03]. We sample an HST $T$ according to the distribution defined by the embedding. We consider an instance $I$ of the DSMS problem where the communication is asynchronous, and the requests are simultaneously invoked by the nodes of $G$ . When running Gnn on $T$ , we get a randomized distributed protocol on $G$ that solves $I$ with an expected competitive ratio of $\operatorname{O}\bigl{(}\log n\bigr{)}$ against oblivious adversaries333This assumes that the sequence of requests is statistically independent of the randomness used for constructing the given tree..

Theorem 1.2.

Let $I$ denote an instance of the DSMS problem consisting of an asynchronous network with $n$ processors and a set of requests that are simultaneously invoked by processors of the network. There is a randomized distributed protocol that solves $I$ with an expected competitive ratio of $O(\log n)$ against an oblivious adversary.

Consider an instance $I$ of DSMS that consists of an HST $T$ where communication is asynchronous and a set of requests that are simultaneously invoked by the leaves of $T$ . Analyzing Gnn for $I$ turns out to be involved and non-trivial. The fact that the Gnn (as any other protocol) has no control on the message latencies bears a superficial resemblance to the case where the requests are invoked over time. Hence, when analyzing Gnn for $I$ , one faces the following complications: 1) A server may go back to a subtree of $T$ after having left it. 2) A request in a subtree of $T$ that initially hosts at least one server can be served by a server that is initially outside this subtree. 3) Different servers can serve two requests in a subtree of $T$ that does not initially host any server. Theorem 1.2 is derived from our main technical result for HSTs.

Theorem 1.3.

Consider an instance $I$ of DSMS that consists of an HST $T$ where even the communication is asynchronous and a set of requests that are simultaneously invoked by the leaves of $T$ . The Gnn protocol optimally solves $I$ .

One-shot executions of the distributed queuing problem for synchronous communication were already considered in [HTW01]. The following corollary follows from Theorem 1.3.

Corollary 1.4.

Gnn* optimally solves the distributed queuing problem on HSTs for one-shot executions even when the communication is asynchronous.*

We provide a simple reduction form the distributed $k$ -server problem to the DSMS problem. Our following lower bound is obtained using this reduction and an existing lower bound [BR92] on the competitive ratio for the distributed $k$ -server problem.

Theorem 1.5.

There is a network topology with $n$ processors—for all $n$ —such that there is no online distributed protocol that solves DSMS with a competitive ratio of $o(\max\{k,\log n/\log\log n\})$ against adaptive online adversaries where $k$ is the number of servers. This result even holds when requests are invoked one by one by processors in a sequential manner and even when the communication is synchronous.

1.2 Further Related Work

Distributed $k$ -server problem: In Section 1, we have seen that the distributed $k$ -server problem is an application of the DSMS problem. In [BR92], a general translator that transforms any deterministic global-control competitive $k$ -server algorithm into a distributed competitive one is provided. This yields poly $(k)$ -competitive distributed protocols for the line, trees, and the ring synchronous network topologies. In [BR92], a lower bound of $\Omega(\max\{k,(1/D)\cdot(\log n/\log\log n)\})$ on the competitive ratio for the distributed $k$ -server problem against adaptive online adversaries is also provided where $n$ is the number of processors. $D$ is the ratio between the cost to move a server and the cost to transmit a message over the same distance in synchronous networks. [AGGP17] and [BKS18] study OSD on HSTs and lines, respectively. [AGGP17] provides an upper bound of $\operatorname{O}\bigl{(}\log^{3}n\bigr{)}$ and [BKS18] provides an upper bound of $\operatorname{O}\bigl{(}\log n\bigr{)}$ on the competitive ratio for OSD where $n$ is the number of leaves of the input HST as well as the number of nodes of the input line.

Distributed queuing problem and link-reversal-based protocols: A well-known class of protocols has been devised based on link reversals to solve distributed problems in which the distributed queuing problem is at the core of them [AGM10, KW19, NT87, Ray89, vdS87, WW11, ZR10]. In a distributed link-reversal-based protocol nodes keep a link pointing to neighbors in the current or future direction of the server. When sending a message over an edge to request the server, the direction of the link flips. We devise the Gnn protocol that is—to the best of our knowledge—the first link-reversal-based protocol that navigates more than one server. A well-studied link-reversal-based protocol is called Arrow [NT87, Ray89, vdS87]. Several other tree-based distributed queueing protocols that are similar to Arrow have also been proposed. They operate on fixed trees. The Relay protocol has been introduced as a distributed transactional memory protocol [ZR10]. It is run on top of a fixed spanning tree similar to Arrow; however, to more efficiently deal with aborted transactions, it does not always move the shared object to the node requesting it. Further, in [AGM10], a distributed directory protocol called Combine has been proposed. Combine like Gnn runs on a fixed overlay tree, and it is in particular shown in [AGM10] that Combine is starvation-free.

The first paper to study the competitive ratio of concurrent executions of a distributed queueing protocol is [HTW01]. It shows that in synchronous executions of Arrow on a tree $T$ for one-shot executions, the total cost of Arrow is within a factor $\operatorname{O}\bigl{(}\log m\bigr{)}$ compared to the optimal queueing cost on where $m$ is the number of requests. This analysis has later been extended to the general concurrent setting where requests are invoked over time. In [HKTW06], it is shown that in this case, the total cost of Arrow is within a factor $O(\log D)$ of the optimal cost on $T$ where $D$ is the diameter of $T$ . Later, the same bounds have also been proven for Relay [ZR10]. Typically, these protocols are run on a spanning tree or an overlay tree on top of an underlying general network topology. In this case, the competitive ratio becomes $O(s\cdot\log D)$ , where $s$ is the stretch of the tree. Finally, [GK17] has shown that when running Arrow on top of HSTs, a randomized distributed online queueing protocol is obtained with expected competitive ratio $O(\log n)$ against an oblivious adversary even on general $n$ -node network topologies. The result holds even if the queueing requests are invoked over time and even if communication is asynchronous. The main technical result of the paper shows that the competitive ratio of Arrow is constant on HSTs.

Online tracking of mobile users: A similar problem to DSMS is the online mobile user tracking problem [AP95]. In contrast with DSMS where a request $r$ results in moving a server to the requesting point, here the request $r$ can have two types: find request that does not result in moving the mobile user and move request. A request in DSMS that is invoked by $v$ can be seen as a combination of a find request that is invoked at $v$ in the mobile user problem and a move request invoked at the current address of the mobile user. The goal is to minimize the sum of the total communication cost and the total cost incurred for moving the mobile user. [AP95] provides an upper bound of $\operatorname{O}\bigl{(}\log^{2}n\bigr{)}$ on the competitive ratio for the online mobile user problem for one-shot executions. Further, [AKRS92] provides a lower bound of $\Omega(\log n/\log\log n)$ on the competitive ratio for this problem against an oblivious adversary.

2 Model, Problem Statement, and Preliminaries

2.1 Communication Model

We consider a point-to-point communication network that is modeled by a graph $G=(V,E)$ , where the $n$ nodes in $V$ represent the processors of the network and the edges in $E$ represent bidirectional communication links between the corresponding processors. We suppose that the edge weights are positive and are normalized such that the weight of each edge will be at least $1$ . If $G$ is unweighted, then we assume that the weight of an edge is $1$ . We consider the message passing model [Pel00] where neighboring processors can exchange messages with each other. The communication links can have different latencies. These latencies are not even under control of an optimal offline distributed protocol. We consider both synchronous and asynchronous systems. In a synchronous system, the latency for sending a message over an edge equals the weight of the edge. In an asynchronous system, in contrast, the messages arrive at their destinations after a finite but unbounded amount of time. Messages that take a longer path may arrive earlier, and the receiver of a message can never distinguish whether a message is still in transit or whether it has been sent at all. For our analysis, however, we adhere to the conventional approach where the latencies are scaled such that the latency for sending a message over an edge is upper bounded by the edge weight in the “worst case” (for every legal input and in every execution scenario) (see Section 2.2 in [Pel00] for more information).

2.2 Distributed Serving with Mobile Servers (DSMS) Problem

The input for DSMS problem for a graph $G$ consists of $k\geq 1$ identical mobile servers that are initially located at different nodes of $G$ and a set $\mathcal{R}$ of requests that are invoked at the nodes at any time. A request $r_{i}\in\mathcal{R}$ is represented by $(v_{i},t_{i})$ where node $v_{i}$ invoked request $r_{i}$ at time $t_{i}\geq 0$ . A distributed protocol Alg that solves the DSMS problem needs to serve each request with one of the $k$ servers at the requested node. Hence, Alg must schedule all requests that access a particular server. Consequently, Alg outputs $k$ global schedules such that the request sets of these schedules form a partition of $\mathcal{R}$ and all requests of the schedule $\pi^{z}_{\textsc{Alg}}$ consecutively access the server $s^{z}$ where $z\in\left\{1,\dots,k\right\}$ . We assume that at time [math], when an execution starts, the tail of schedule $\pi^{z}_{\textsc{Alg}}$ is at a given node $v^{z}_{0}\in V$ that hosts $s^{z}$ . Formally, this is modeled as a “dummy request” $r^{z}_{0}=(v^{z}_{0},0)$ that has to be scheduled first in the schedule $\pi^{z}_{\textsc{Alg}}$ by Alg. Consider two requests $r_{i}$ and $r_{j}$ that are consecutively served by $s^{z}$ where $r_{i}$ is scheduled after $r_{j}$ . To schedule request $r_{i}$ the protocol needs to inform node $v_{j}$ , the predecessor request $r_{j}$ in the constructed schedule. As soon as $r_{j}$ is served by $s^{z}$ , node $v_{j}$ sends the server to $v_{i}$ for serving $r_{i}$ using an underlying routing facility that efficiently routes messages. The goal is to minimize the total communication cost, i.e., the sum of the latencies of all messages sent during the execution of Alg.

2.3 Preliminaries

Consider a distributed protocol Alg for the DSMS problem when requests can arrive at any time. Let $\mathcal{R}$ denote the set of requests, including the dummy requests. Assume that Alg partitions $\mathcal{R}$ into $k$ sets $\mathcal{R}^{1}_{\textsc{Alg}},\dots,\mathcal{R}^{k}_{\textsc{Alg}}$ , and that it schedules the requests in set $\mathcal{R}^{z}_{\textsc{Alg}}$ according to permutation $\pi^{z}_{\textsc{Alg}}$ . Denote the request at position $i$ of $\pi^{z}_{\textsc{Alg}}$ by $r_{\pi^{z}_{\textsc{Alg}}(i)}$ . The dummy request $r^{z}_{0}$ of $\pi^{z}_{\textsc{Alg}}$ is represented by $r_{\pi^{z}_{\textsc{Alg}}(0)}$ . Let $\ell_{\textsc{Alg}}(\mu)$ denote the latency of message $\mu$ as routed by Alg. For every $i\in\left\{1,\dots,|\mathcal{R}|-1\right\}$ , if $r_{i}$ belongs to $\mathcal{R}^{z}_{\textsc{Alg}}$ , the communication cost $\mathit{c}_{\textsc{Alg}}\big{(}r_{\pi^{z}_{\textsc{Alg}}(i-1)},r_{\pi^{z}_{\textsc{Alg}}(i)}\big{)}$ incurred for scheduling $r_{\pi^{z}_{\textsc{Alg}}(i)}$ as the successor of $r_{\pi^{z}_{\textsc{Alg}}(i-1)}$ is the sum of the latencies of all messages sent by Alg to schedule $r_{\pi^{z}_{\textsc{Alg}}(i)}$ immediately after $r_{\pi^{z}_{\textsc{Alg}}(i-1)}$ . The total communication cost of Alg for scheduling all requests in $\mathcal{R}^{z}_{\textsc{Alg}}$ is defined as

[TABLE]

The total communication cost of Alg for scheduling all requests in $\mathcal{R}$ , therefore, is

[TABLE]

2.4 Hierarchically Well-Separated Trees (HSTs)

Embedding of a metric space into probability distributions over tree metrics have found many important applications in both centralized and distributed settings [AGGP17, BBMN11, GK17]. The notion of a hierarchically well-separated tree was defined by Bartal in [Bar96].

Definition 2.1 ( $\alpha$ -HST).

For $\alpha>1$ an $\alpha$ -HST of depth $h$ is a rooted tree with the following properties: The children of the root are at a distance $\alpha^{h-1}$ from the root and every subtree of the root is an $\alpha$ -HST of depth $h-1$ . A tree is an HST if it is an $\alpha$ -HST for some $\alpha>1$ .

The definition implies that the nodes two hops away from the root are at a distance $\alpha^{h-2}$ from their parents. The probabilistic tree embedding result of [FRT03] shows that for every metric space $(X,d)$ with minimum distance normalized to $1$ and for every constant $\alpha>1$ there is a randomized construction of an $\alpha$ -HST $T$ with a bijection $f$ between the points in $X$ and the leaves of $T$ such that a) the distances on $T$ are dominating the distances in the metric space $(X,d)$ , i.e., $\forall x,y\in X:d_{T}\big{(}f(x),f(y)\big{)}\geq d(x,y)$ and such that b) the expected tree distance is $\mathbb{E}\big{[}d_{T}\big{(}f(x),f(y)\big{)}\big{]}=O(\alpha\log|X|/\log\alpha)\cdot d(x,y)$ for every $x,y\in X$ . The length of the shortest path between any two leaves $u$ and $v$ of $T$ is denoted by $d_{T}(u,v)$ . An efficient distributed construction of the probabilistic tree embedding of [FRT03] has been given in [GL14].

3 The Distributed GNN Protocol

In this section the Gnn protocol is introduced.

3.1 Description of GNN

Gnn runs on overlay trees and outputs a feasible solution for the DSMS problem. Consider a rooted tree $T=(V_{T},E_{T})$ whose leaves correspond to the nodes of the underlying graph $G=(V,E)$ , i.e., $V\subseteq V_{T}$ . Let $n=|V|$ . The $k\geq 1$ identical mobile servers are initially at different leaves of $T$ . Further, there is a dummy request at every leaf that initially hosts a server. The leaves of $T$ can invoke requests at any time. A leaf node can invoke a request while it is hosting a server and a leaf can also invoke a request while its previous requests have not been served yet. Initially, a directed version of $T$ is constructed and denoted by $H$ , the directed edges of $H$ are called links. During an execution of Gnn, Gnn changes the directions of the links. Denote by $v.\textit{links}$ the set of neighbors of $v$ that are pointed by $v$ . After a leaf $u$ has invoked a request it sends a find-predecessor message denoted by $\mu(u)$ along the links to inform the node of the predecessor request in the global schedule. The routing of $\mu(u)$ is explained below. At the beginning before any message is sent and for any server, all the nodes on the direct path from the root of $T$ to the leaf that hosts the server, point to the server. Further, the host points to itself and creates a self-loop. Hence, we have $k$ directed paths with downward links from the root of $T$ to the points of the current tails of the schedules. Any other node points to its parent with an upward link. Therefore, the sets $v.\textit{links}$ for all $v\in V_{T}$ are non-empty at the beginning of the executing the protocol. Figure 2(a) shows the directed HST at the beginning as an example.

Upon $u$ invoking a new request: Consider the leaf node $u$ when it invokes a new request $r$ . If $u$ has a self-loop, then $r$ is scheduled immediately behind the last request that has been invoked at $u$ . Otherwise, the leaf $u$ atomically sends $\mu(u)$ to its parent through an upward link, $u$ points to itself, and the link from $u$ to its parent is removed. We suppose that messages are reliably delivered. The details of this part of the protocol are given by Algorithm 2. See Figure 2(b) as an example.

Upon $w$ receiving $\mu(u)$ from node $v$ : Suppose that node $w$ receives a find-predecessor message $\mu(u)$ from node $v$ . The node $w$ executes the following steps atomically. If $w$ has at least one downward link, then $\mu(u)$ is forwarded to some child of $w$ through a downward link (ties are broken arbitrarily). Then, $w$ removes the downward link and adds a link to $v$ —independently of whether $v$ is the parent or a child of $w$ . If $w$ does not have a downward link, it either points to itself, or it has an upward link. In the latter case, $\mu(u)$ is atomically forwarded to the parent of $w$ , the upward link from $w$ to its parent is removed and then $w$ points to $v$ using a downward link. Otherwise, $w$ is a leaf and points to itself. The request $r$ invoked by $u$ is scheduled behind the last request that has been invoked by $w$ . Then, $w$ removes the link that points to itself and points to $v$ using an upward link. The details of this part of the protocol are given by Algorithm 3. Also, see Figure 2(c) and Figure 3.

3.2 Correctness of GNN

Regarding the description of Gnn, we need to show two invariants for Gnn. The first is that Gnn eventually schedules all requests. The second one is that Gnn is starvation-free so that a scheduled request is eventually served.

3.2.1 Scheduling Guarantee

Theorem 3.1.

Gnn* guarantees that the find-predecessor message of any node that invokes a request always reaches a leaf node $v$ in a finite time such that $v.\textit{links}=\left\{v\right\}$ .*

We prove the scheduling guarantee stated in Theorem 3.1 using the following properties of Gnn. First, we need to show that any node always has at least one outgoing edge in Gnn.

Lemma 3.2.

In Gnn, $v.\textit{links}$ is never empty for any node $v\in V_{T}$ .

Proof.

At the beginning of any execution, $v.\textit{links}$ is not empty for any $v\in V_{T}$ . The set $v.\textit{links}$ changes only when there is a (find-predecessor) message at $v$ (see Line 2 of Algorithm 2 and Line 3 and Line 3 of Algorithm 3). During an execution, every time $v$ receives a message, a node is removed from $v.\textit{links}$ while a new node is added to $v.\textit{links}$ . This also covers the case when at least two messages are received by $v$ at the same time. The node $v$ atomically processes all these messages in an arbitrary order. Therefore, $v.\textit{links}$ never gets empty. ∎

Lemma 3.3.

Gnn* always guarantees that on each edge of $H$ , there is either exactly one link or exactly one message in transit.*

Proof.

Initially, either a node points to its parent with an upward link or a node points to its children with downward links in the Gnn protocol. Consider the edge $(u,v)$ where $v\in u.\textit{links}$ . Further, consider the first time in which a message is in transit on $(u,v)$ . Immediately before this transition occurs, $u$ must point to $v$ , and there is not any message in transit on the edge. Therefore, w.r.t. the protocol description, the message must be sent by $u$ to $v$ , and the link that points from $u$ to $v$ has been removed. Since there is not any link while the message is in transit, it is not possible to have a second message to be in transit at the same time. When the message arrives at $v$ , the node $v$ points to $u$ , and the message is removed from the edge. The next time, if a message will be transited on the edge, then $v$ must have sent it to $u$ and removed the link that points from $v$ to $u$ . ∎

Lemma 3.4.

The directed tree $H$ always remains acyclic during an execution, hence a path from a node to another node in $H$ is always the direct path.

Proof.

The Gnn protocol runs on the directed tree $H$ in which the underlying tree—that is, $T$ —is fixed, and the directions of links on $H$ are only changed. Therefore, $H$ is acyclic because the tree is always fixed, and w.r.t. Lemma 3.3 that shows that it never occurs a state where on the edge $(u,v)$ , $u$ and $v$ point to each other at the same time. ∎

The following lemma implies that a find-predecessor message always reaches the node of its predecessor using a direct path constructed by Gnn.

Lemma 3.5.

Gnn* guarantees that there is always at least one direct path in $H$ from any leaf node $u$ to a leaf node $v$ where $v.\textit{links}=\left\{v\right\}$ .*

Proof.

If the leaf node $u$ points to itself, we are done. Otherwise, w.r.t. Lemma 3.2 there must be a path from $u$ to a leaf node $v$ since the tree $H$ is acyclic. This path must be a direct path w.r.t. Lemma 3.4. The leaf node $v$ must point to itself w.r.t. Lemma 3.2. ∎

Proof of Theorem 3.1.

Using Lemma 3.5, it remains to show that any message traverses a direct path between two leaves in a finite time. The number of edges on the direct path between any two leaves of $T$ is upper bounded by the diameter of the tree. Further, any message that is in transit at edge $(u,v)$ from $u$ to $v$ is delivered reliably at $v$ in a finite time. Therefore, to show that a request is eventually scheduled in a finite time, it remains to show that a message will never be at a node for the second time. To obtain a contradiction, assume that the message $\mu$ is the first message that visits a node twice, and the first node visited twice by $\mu$ denoted by $v\in V_{T}$ . With respect to Lemma 3.4, there is never a cycle in $H$ . Therefore, the edge $e=(u,v)$ must be the first edge that is traversed by $\mu$ first from $v$ to $u$ and immediately from $u$ to $v$ for the second time, and $\mu$ must be the first message that traverses an edge twice. This implies that immediately before $u$ receives $\mu$ , the node $u$ points to $v$ , and $\mu$ is in transit on $e$ at the same time. This is a contradiction with Lemma 3.3. ∎

3.2.2 Serving Guarantee

Theorem 3.6.

Gnn* is starvation-free. In other words, any scheduled request is eventually served by some server.*

Consider any of $k$ global schedules that produced by Gnn, say $\pi^{w}_{\textsc{Gnn}}$ . Assume that there is more than one request scheduled in $\pi^{w}_{\textsc{Gnn}}$ . For any two requests $r_{i}=(v_{i},t_{i})$ and $r_{j}=(v_{j},t_{j})$ in $\pi^{w}_{\textsc{Gnn}}$ where $r_{i}$ is scheduled immediately before $r_{j}$ , we see $e=(r_{i},r_{j})$ as a directed edge where $r_{j}$ points to $r_{i}$ . This edge is actually simulated by the direct path—by Lemma 3.5, a message always finds the node of its predecessor using a direct path on $H$ —between the leaves $v_{i}$ and $v_{j}$ that is traversed by the message sent from $v_{j}$ to $v_{i}$ . Let $F^{w}_{\textsc{Alg}}$ denote the graph constructed by the messages of all requests in $\mathcal{R}^{w}_{\textsc{Alg}}$ .

Lemma 3.7.

$F^{w}_{\textsc{Alg}}$ * is a directed path towards the head of the schedule, that is, $r^{w}_{0}=r_{\pi^{w}_{\textsc{Gnn}}(0)}$ .*

Proof.

The proof has three parts.

Any node of $F^{w}_{\textsc{Alg}}$ , except the dummy request, has exactly one outgoing edge: This is obvious since any node that invokes a request sends exactly one message. 2. 2)

Any node in $F^{w}_{\textsc{Alg}}$ has at most one incoming edge: For the sake of contradiction, assume that there is a node contained in $F^{w}_{\textsc{Alg}}$ denoted by $r=(v,t)$ with at least two incoming edges in $F^{w}_{\textsc{Alg}}$ . This implies that two messages must reach $v$ in $H$ before $v$ invokes any other request after $r$ . However, when the first message reaches $v$ —if any other message does not reach $v$ before these two messages— $v$ removes the link that points to itself and adds a link that points to its parent w.r.t. Line 3 and Line 3 of Algorithm 3. The second message cannot reach $v$ as long as at least one request is invoked by $v$ after invoking $r$ . This contradicts our assumption in which two messages reach $v$ before the time when $v$ invokes another request after invoking $r$ . 3. 3)

$F^{w}_{\textsc{Alg}}$ ** is connected:** To obtain a contradiction, assume that the graph $F^{w}_{\textsc{Alg}}$ is not connected. Hence, w.r.t. the first and second parts, we have at least one connected component with at least two requests in $\mathcal{R}^{w}_{\textsc{Alg}}$ that form a cycle, and the connected component does not include the dummy request in $r^{w}_{0}$ . Let $\mathcal{R}^{w,c}_{\textsc{Alg}}$ denote the requests in the connected component $F^{w,c}_{\textsc{Alg}}$ that forms a cycle. Consider the node $z$ in $V_{T}$ that is the lowest common ancestor of those leaves of $H$ that invoke the requests in $\mathcal{R}^{w,c}_{\textsc{Alg}}$ . Further, let the subtree $H^{w,c}$ of $H$ denote the tree rooted at $z$ . All messages of requests in $\mathcal{R}^{w,c}_{\textsc{Alg}}$ must traverse inside $H^{w,c}$ since $F^{w,c}_{\textsc{Alg}}$ is disconnected with any request in $\mathcal{R}^{w}_{\textsc{Alg}}\setminus\mathcal{R}^{w,c}_{\textsc{Alg}}$ .

Assume that at least one message of requests in $\mathcal{R}^{w,c}_{\textsc{Alg}}$ reaches $z$ . Consider the first message $\mu$ by $r$ that reaches $z$ at time $t$ . If there is not any downward link at $z$ at $t$ , then $\mu$ is forwarded to the parent of $z$ . This is a contradiction with the fact that $F^{w,c}_{\textsc{Alg}}$ is disconnected with any request in $\mathcal{R}^{w}_{\textsc{Alg}}\setminus\mathcal{R}^{w,c}_{\textsc{Alg}}$ . Hence, there must be at least one downward link at $z$ at $t$ . On the other hand, since $\mu$ is the first message of requests in $\mathcal{R}^{w,c}_{\textsc{Alg}}$ that reaches $z$ , all downward links at $z$ at time $t$ must have been created by some messages of requests in $H^{w,c}$ that are not in $\mathcal{R}^{w,c}_{\textsc{Alg}}$ . Note that if a downward link at $z$ is there since the beginning, then we assume that, w.l.o.g., it has been created by a “virtual message” sent by the node of the corresponding dummy request. Suppose $\mu$ is forwarded through one of these downward links that was created by the message of $r^{\prime}$ —as mentioned, $r^{\prime}$ can be a dummy request—that is in $H^{w,c}$ but not in $\mathcal{R}^{w,c}_{\textsc{Alg}}$ . The original downward path from $z$ to the leaf node of $r^{\prime}$ can be changed by the message of a request in $H^{w,c}$ —can be a request in $\mathcal{R}^{w,c}_{\textsc{Alg}}$ . Thus, either $r$ is scheduled immediately behind some request in $H^{w,c}$ that is not in $\mathcal{R}^{w,c}_{\textsc{Alg}}$ or some other request in $\mathcal{R}^{w,c}_{\textsc{Alg}}$ . In either case, we get a contradiction with our assumption in which $F^{w,c}_{\textsc{Alg}}$ is disconnected with any request in $\mathcal{R}^{w}_{\textsc{Alg}}\setminus\mathcal{R}^{w,c}_{\textsc{Alg}}$ .

If there is not any message of a request in $\mathcal{R}^{w,c}_{\textsc{Alg}}$ that can reach $z$ , then there must be at least two downward links during the execution at $z$ that have been created by some messages of requests that are not in $\mathcal{R}^{w,c}_{\textsc{Alg}}$ —this holds because if there is at most one downward link at $z$ , then a message of some request in $\mathcal{R}^{w,c}_{\textsc{Alg}}$ must reach $z$ w.r.t. the definition of $z$ . However, the existence of at least two downward links at $z$ implies that $F^{w,c}_{\textsc{Alg}}$ is not connected. This is true because there are at least two downward paths that partition the requests in $\mathcal{R}^{w,c}_{\textsc{Alg}}$ into two disjoint components in $F^{w}_{\textsc{Alg}}$ w.r.t. the definition of $z$ and our assumption in which there is not any message of request in $\mathcal{R}^{w,c}_{\textsc{Alg}}$ that can reach $z$ . This is a contradiction with our assumption in which $F^{w,c}_{\textsc{Alg}}$ is a connected component.

The above three parts all altogether show that $F^{w}_{\textsc{Alg}}$ is indeed a directed path that points towards the dummy request in $\mathcal{R}^{w}_{\textsc{Alg}}$ . ∎

Proof of Theorem 3.6.

Consider any of $k$ global schedules that is resulted by Gnn, say $\pi^{w}_{\textsc{Gnn}}$ . If there is only one request in $\pi^{w}_{\textsc{Gnn}}$ —there must be at least one request, that is the dummy request $r^{w}_{0}$ —then we are done. Otherwise, w.r.t. Lemma 3.7 there is a path of directed edges such as $e=(r_{i},r_{j})$ over the requests in $\mathcal{R}^{w}_{\textsc{Alg}}$ . When $v_{i}$ obtains a server, and after $r_{i}$ is served, $v_{i}$ sends the server to $v_{j}$ for serving $r_{j}$ using an underlying routing scheme. Consequently, all requests in $\mathcal{R}^{w}_{\textsc{Alg}}$ are served. ∎

Proof of Theorem 1.1.

Theorem 3.1 and Theorem 3.6 both together prove the claim of the theorem. ∎

4 Analysis in a Nutshell

From a technical point of view, we achieve our main result on HSTs. In this section, we provide an analysis of Gnn on HSTs in a nutshell. The complete analysis, including all proofs, appears in Section 5. Our analysis of Gnn for general networks appears in Section 5.4. The lower bound claimed in Theorem 1.5 is proved in Section 6.

Let Alg denote a particular distributed DSMS protocol that sends a unique message from the node of a request to the node of the predecessor request for scheduling the request (the message can be forwarded by many nodes on the path between the two nodes of the predecessor and successor requests). Consider a one-shot execution of Alg where requests are invoked at the same time [math]. Let $G=(V,E)$ denote the input graph. Further, let $B=\big{(}V_{B}=\mathcal{R},E_{B}={\mathcal{R}\choose 2}\big{)}$ be the complete graph, and consider two requests $r=(v,0)$ and $r^{\prime}=(v^{\prime},0)$ in $\mathcal{R}$ where $v,v^{\prime}\in V$ . Assume that $r^{\prime}$ is scheduled as the successor of $r$ by Alg in the global schedule, and w.r.t. the DSMS problem definition Alg informs $v$ by sending the (find-predecessor) message $\mu^{\prime}$ from $v^{\prime}$ to $v$ . Therefore, the communication cost for scheduling $r^{\prime}$ equals the latency of $\mu^{\prime}$ . Formally,

[TABLE]

Let $r_{\mathit{src}}(\mu^{\prime})=r^{\prime}$ denote the request corresponding with $\mu^{\prime}$ . Further, let $r_{\mathit{des}}(\mu^{\prime})=r$ denote the predecessor request $r$ in the global schedule. We see $e=(r,r^{\prime})$ as an edge in $E_{B}$ that is constructed by $\mu^{\prime}$ . Let us add $\mu(e)$ and $e(\mu)$ to the notation where $\mu(e)$ is the message that constructs the edge $e$ and $e(\mu)$ is the edge that is constructed by $\mu$ . For instance, here, $\mu(e)$ refers to $\mu^{\prime}$ and $e(\mu^{\prime})$ refers to the edge $(r,r^{\prime})$ .

Representing solution of ALG as a forest: We observe that any of the $k$ resulted schedules $\pi^{1}_{\textsc{Alg}},\dots,\pi^{k}_{\textsc{Alg}}$ can be seen as a TSP path that spans all requests in the corresponding schedule as follows (see Lemma 3.7). The TSP path $F^{z}_{\textsc{Alg}}$ starts with the dummy request $r^{z}_{0}$ that is the head of $\pi^{z}_{\textsc{Alg}}$ , and a request on the TSP path $F^{z}_{\textsc{Alg}}$ is connected using an edge to its predecessor in the schedule $\pi^{z}_{\textsc{Alg}}$ . As mentioned, the edge is constructed by the message sent by the requesting node to the node of its predecessor request. Therefore, an edge of any TSP path—that is an edge in $E_{B}$ —is actually a path on the input graph that is traversed by the corresponding message. For any $F\subseteq\mathcal{F}_{\textsc{Alg}}$ , we define the total communication cost of $F$ as follows.

[TABLE]

Therefore, the total communication cost of a TSP path equals the sum of latencies of all messages that construct the TSP path. The $k$ TSP paths represent a forest of $B$ . Let $\mathcal{F}_{\textsc{Alg}}$ be the forest that consists of the $k$ TSP paths $F^{1}_{\textsc{Alg}},F^{2}_{\textsc{Alg}},\dots,F^{k}_{\textsc{Alg}}$ constructed by Alg. We slightly abuse notation and identify a subgraph $F$ of $B=\big{(}\mathcal{R},{\mathcal{R}\choose 2}\big{)}$ with the set of edges contained in $F$ . The total communication cost of $\mathcal{F}_{ALG}$ equals the sum of total costs of the $k$ TSP paths $F^{1}_{\textsc{Alg}},F^{2}_{\textsc{Alg}},\dots,F^{k}_{\textsc{Alg}}$ . For the input graph $G=(V,E)$ , we denote the weight of edge $e=(r,r^{\prime})\in E_{B}$ by $w_{G}(e):=d_{G}(v,v^{\prime})$ where $v,v^{\prime}\in V$ (recall $r=(v,t)$ and $r^{\prime}=(v^{\prime},t^{\prime})$ ). Note that that $d_{G}(v,v^{\prime})$ is the weight of the shortest path between $v$ and $v^{\prime}$ on the input graph $G$ . Generally, the total weight of the subgraph $F$ of $B$ w.r.t. the input graph $G$ equals the sum of weights of all edges in $F$ . Formally,

[TABLE]

Definition 4.1 ( $S$ -Respecting $m$ -Forest).

Let $G=(V,E)$ be a graph and $m\leq|V|$ . A forest $\mathcal{F}$ of $G$ is called an $m$ -forest if $\mathcal{F}$ consists of $m$ trees. Further, let $S\subseteq V$ , $|S|\leq m$ be a set of at most $m$ nodes. An $m$ -forest $\mathcal{F}$ of $G$ is $S$ -respecting if the nodes in $S$ appear in different trees of $\mathcal{F}$ .

Let $\mathcal{R}_{D}$ denote the set of $k$ dummy requests in $\mathcal{R}$ . W.r.t. the Definition 4.1, $\mathcal{F}_{\textsc{Alg}}$ is an $\mathcal{R}_{D}$ -respecting spanning $k$ -forest of $B=\big{(}\mathcal{R},{\mathcal{R}\choose 2}\big{)}$ . From now on, we consider the HST $T$ as the input graph.

Locality-based forest: For any subtree $T^{\prime}$ of $T$ and any subgraph $F$ of $B$ , let $F(T^{\prime})$ denote the subgraph of $F$ that is induced by those requests contained in $F$ that are also in $T^{\prime}$ . Further, let $F^{1},F^{2},\dots,F^{k}$ denote the $k$ trees of the spanning $k$ -forest $\mathcal{F}$ of $B$ . Consider any $\mathcal{R}_{D}$ -respecting spanning $k$ -forest of $B$ with the following basic locality properties.

I.

[Intra-Component Property] For any subtree $T^{\prime}$ of $T$ and for any $w\in\left\{1,\dots,k\right\}$ , the component $F^{w}_{\textsc{Grd}}(T^{\prime})$ is a tree. 2. II.

[Inter-Component Property] For any subtree $T^{\prime}$ of $T$ , suppose that there are at least two non-empty components $F^{z}_{\textsc{Grd}}(T^{\prime})$ and $F^{w}_{\textsc{Grd}}(T^{\prime})$ where $w\neq z$ and $w,z\in\left\{1,\dots,k\right\}$ . Any of these components includes a dummy request.

We call such a forest a locality-based forest. Any locality-based forest is denoted by $\mathcal{F}_{\textsc{Grd}}$ . The following theorem provides a general version of Theorem 1.3.

Theorem 4.1.

Let $I$ denote an instance of DSMS that consists of an HST $T$ where the communication is asynchronous and a set $\mathcal{R}$ of requests that are simultaneously invoked at leaves of $T$ . The protocol Alg is optimal if the total cost of the resulted forest by Alg is upper bounded by the total weight of $\mathcal{F}_{\textsc{Grd}}$ .

4.1 Optimality of GNN on HSTs

Consider a one-shot execution of Gnn, and suppose that $\mathcal{F}_{\textsc{Gnn}}$ is the resulted forest when running Gnn on the given HST $T$ w.r.t. the input sequence $\mathcal{R}$ . With respect to Theorem 4.1, and the fact that Gnn only sends one uniques message for scheduling a request to its predecessor, it is sufficient to show that the forest $\mathcal{F}_{\textsc{Gnn}}$ can be transformed into a locality-based forest such that the total cost of $\mathcal{F}_{\textsc{Gnn}}$ is upper bounded by the total weight of $\mathcal{F}_{\textsc{Grd}}$ . During an execution of Gnn, the Intra or Inter-Component property can be violated (see Figure 1). Consider the following situations:

A server goes back to a subtree after the time when it leaves the subtree. 2. 2.

A request in a subtree of $T$ that initially hosts at least one server is served by a server that is not initially in the subtree. 3. 3.

Two requests in a subtree of $T$ that does not initially host any server, are served by different servers.

The first situation violates the Intra-Component property. Any of the second and the third situation violates the Inter-Component property. In the following, we characterize the Intra-Component and the Inter-Component properties by considering a timeline for the messages that enter and leave a subtree of $T$ . Consider a message $\mu$ that enters the subtree $T^{\prime}$ of $T$ . Another message can enter $T^{\prime}$ only after some message $\mu^{\prime}$ has left $T^{\prime}$ after $\mu$ entered $T^{\prime}$ — the arrival times of messages $\mu$ and $\mu^{\prime}$ at the root of $T^{\prime}$ can be the same (see Lemma 5.3 and Lemma 5.6). Similarly, a message can leave $T^{\prime}$ after $\mu^{\prime}$ left $T^{\prime}$ only after some message has entered $T^{\prime}$ after $\mu^{\prime}$ left $T^{\prime}$ . We refer to Lemma 5.6 for more details. Consider a message $\mu$ that enters $T^{\prime}$ . The fact that $\mu$ enters $T^{\prime}$ implies that a server will leave $T^{\prime}$ for serving $r_{\mathit{src}}(\mu)$ . Let $\mu^{\prime}$ denote the first message that leaves $T^{\prime}$ after $\mu$ entered $T^{\prime}$ . Leaving $\mu^{\prime}$ from $T^{\prime}$ implies that a server will enter $T^{\prime}$ for serving $r_{\mathit{src}}(\mu^{\prime})$ . If $r_{\mathit{src}}(\mu^{\prime})$ is in the same TSP path of $\mathcal{F}_{\textsc{Gnn}}$ with $r_{\mathit{des}}(\mu)$ , then the server that had served $r_{\mathit{des}}(\mu)$ goes back to $T^{\prime}$ for serving $r_{\mathit{src}}(\mu^{\prime})$ after it left $T^{\prime}$ , and therefore the Intra-Component property is violated. Otherwise, the Inter-Component property is violated since two requests in $T^{\prime}$ are served by two different servers in which at least one of the servers is initially outside of $T^{\prime}$ . We say Gnn makes an Inter-Component gap $(\mu,\mu^{\prime})$ on $T^{\prime}$ in the latter case and an Intra-Component gap $(\mu,\mu^{\prime})$ on $T^{\prime}$ in the former case.

Transformation: We transform $\mathcal{F}_{\textsc{Gnn}}$ through closing the gaps that are made by Gnn on all subtrees of $T$ . A message $\mu^{\prime}$ can leave from several subtrees of $T$ such that different messages enter the subtrees before $\mu^{\prime}$ . Therefore, Gnn can make different gaps with the same message $\mu^{\prime}$ on this set of subtrees of $T$ . We especially refer to Lemma 5.9 and Lemma 5.11 for more details on the gaps of the subtrees of $T$ . We consider the lowest subtree in this set and let $(\mu,\mu^{\prime})$ be a gap on that. We close the gap $(\mu,\mu^{\prime})$ by removing $e(\mu^{\prime})$ and by adding the new edge $\big{(}r_{\mathit{des}}(\mu),r_{\mathit{src}}(\mu^{\prime})\big{)}$ . In the example of Figure 1, for instance, the red edges are removed and the new edges $(r^{1}_{0},r_{b})$ and $(r_{b},r_{c})$ are added. When we close the gap $(\mu,\mu^{\prime})$ , all other gaps $(\mu^{\prime\prime},\mu^{\prime})$ that are on higher subtrees are also closed. Therefore, we transform $\mathcal{F}_{\textsc{Gnn}}$ into a new forest $\mathcal{F}_{mdf}$ by means of closing all gaps. The following lemma shows that $\mathcal{F}_{mdf}$ is indeed the locality-based forest.

Lemma 4.2.

$\mathcal{F}_{mdf}$ * is an $\mathcal{R}_{D}$ -respecting spanning $k$ -forest of $B$ that satisfies the Intra-Component and the Inter-Component properties.*

It remains to show that the total cost of $\mathcal{F}_{\textsc{Gnn}}$ is upper bounded by the total weight of the new forest $\mathcal{F}_{mdf}$ . Formally, we want to show that $L_{\textsc{Gnn}}(\mathcal{F}_{\textsc{Gnn}})\leq W_{T}(\mathcal{F}_{mdf})$ . Using Lemma 3.5, a message always finds the node of its predecessor using a direct path on $T$ in any execution of Gnn. Regarding to our communication model described in Section 2.1, therefore, for every edge $e\in\mathcal{F}_{\textsc{Gnn}}$ we have

[TABLE]

Let $(\mu,\mu^{\prime})$ be the gap on the lowest subtree of $T$ among all subtrees of $T$ with gaps $(\mu^{\prime\prime},\mu^{\prime})$ for any message $\mu^{\prime\prime}$ that makes a gap with $\mu^{\prime}$ . By closing the gap $(\mu,\mu^{\prime})$ , we remove $e^{old}:=\big{(}r_{\mathit{src}}(\mu^{\prime}),r_{\mathit{des}}(\mu^{\prime})\big{)}$ and add the new edge $e^{new}:=\big{(}r_{\mathit{src}}(\mu^{\prime}),r_{\mathit{des}}(\mu)\big{)}$ . Using (6), we are immediately done if the latency of $\mu^{\prime}$ is upper bounded by the weight of $e^{new}$ . However, the latency of $\mu^{\prime}$ can be larger than the weight of $e^{new}$ . By contrast, the weight of $e^{new}$ is lower bounded by the latency of $\mu$ (see Corollary 5.10 and Lemma 5.15). This lower bound gives us the go-ahead to show that the weight of $e^{new}$ can be seen as an “amortized” upper bound for $\ell_{\textsc{Gnn}}(\mu^{\prime})$ . In the following, we provide an overview of our amortized analysis that appears in Section 5.3.3. Let $E^{new}:=\mathcal{F}_{mdf}\setminus\mathcal{F}_{\textsc{Gnn}}$ and $E^{old}:=\mathcal{F}_{\textsc{Gnn}}\setminus\mathcal{F}_{mdf}$ be the sets of all edges that are added and removed during the transformation of $\mathcal{F}_{\textsc{Gnn}}$ , respectively. Further, we consider a set of edges that provides enough “potential” for our amortization.

[TABLE]

For every edge $e\in E^{old}$ , let $E^{pot}(e):=\left\{e^{\prime}\in E^{pot}:\big{(}\mu(e^{\prime}),\mu(e)\big{)}\ \text{is a gap}\right\}$ . Further, for every edge $e\in E^{pot}$ , let $E^{old}(e):=\left\{e^{\prime}\in E^{old}:\big{(}\mu(e),\mu(e^{\prime})\big{)}\ \text{is a gap}\right\}$ . In this overview, we consider the simple case where 1) $|E^{old}(e)|=1$ for every edge $e\in E^{pot}$ and $|E^{pot}(e)|=1$ for every edge $e\in E^{old}$ . Further, 2) the sets $E^{old}$ and $E^{pot}$ do not share any edge. The execution provided by Figure 1 represents an example of the above simple case. We define the potential function $\Phi(F)$ for a subset $F$ of $\mathcal{F}_{\textsc{Gnn}}$ as follows $\Phi(F):=W_{T}(F)-L_{\textsc{Gnn}}(F)$ . W.l.o.g., we assume that the edges in $E^{old}$ are sequentially replaced with the edges in $E^{new}$ . Hence, assume that $e^{old}_{i}$ is replaced with $e^{new}_{i}$ during the $i$ -th replacement. Let also $e^{pot}_{i}$ be the only edge in $E^{pot}(e^{old}_{i})$ .

Lemma 4.3.

If $|E^{old}(e)|=1$ for every edge $e\in E^{pot}$ , $|E^{pot}(e)|=1$ for every edge $e\in E^{old}$ , and $E^{old}\cap E^{pot}=\emptyset$ , then

[TABLE]

for every $i\geq 1$ .

Proof.

Using the definition of the potential function $\Phi$ and the definitions of the total weight and the total communication cost of a subset of edges in $\mathcal{F}_{\textsc{Gnn}}$ , we have

[TABLE]

Therefore, we need to show that $w_{T}(e^{old}_{i})\leq w_{T}(e^{new}_{i})+w_{T}(e^{pot}_{i})-\ell_{\textsc{Gnn}}(e^{pot}_{i})$ . Let the subtree $T^{\prime}$ of $T$ be the lowest subtree such that $\big{(}\mu(e^{pot}_{i}),\mu(e^{old}_{i})\big{)}$ is a gap on $T^{\prime}$ . This implies that $w_{T}(e^{new}_{i})=\delta(T^{\prime})$ . On the other hand, using Lemma 5.15 we have $\ell_{\textsc{Gnn}}(e^{pot}_{i})\leq\delta(T^{\prime})=w_{T}(e^{new}_{i})$ . It remains to show that $w_{T}(e^{old}_{i})\leq w_{T}(e^{pot}_{i})$ . Let $T^{\prime\prime}_{j}$ be the highest subtree of $T$ such that $\big{(}\mu(e^{pot}_{i}),\mu(e^{old}_{i})\big{)}$ is a gap on $T^{\prime\prime}_{j}$ and $T^{\prime\prime}_{j}$ is a child subtree of $T^{\prime\prime}$ . The message $\mu(e^{old}_{i})$ does not leave $T^{\prime\prime}$ since $E^{pot}(e^{old}_{i})=\left\{e^{pot}_{i}\right\}$ . Hence, $w_{T}(e^{old}_{i})=\delta(T^{\prime\prime})$ . On the other hand, the fact that the message $\mu(e^{pot}_{i})$ enters $T^{\prime\prime}_{j}$ indicates that $w_{T}(e^{pot}_{i})\geq\delta(T^{\prime\prime})$ . Consequently, $w_{T}(e^{pot}_{i})\geq w_{T}(e^{old}_{i})$ and we are done. ∎

When we sum up (7) for all $i$ , we get

[TABLE]

Using the definition of the potential function $\Phi$ and using $L_{\textsc{Gnn}}(E^{old})\leq W_{T}(E^{old})$ w.r.t (6), therefore we get $L_{\textsc{Gnn}}(E^{pot})+L_{\textsc{Gnn}}(E^{old})\leq W_{T}(E^{new})+W_{T}(E^{pot})$ . Hence, we have $L_{\textsc{Gnn}}(\mathcal{F}_{\textsc{Gnn}})\leq W_{T}(\mathcal{F}_{mdf})$ since $\mathcal{F}_{mdf}=\mathcal{F}_{\textsc{Gnn}}\setminus E^{old}\cup E^{new}$ and $L_{\textsc{Gnn}}\big{(}\mathcal{F}_{\textsc{Gnn}}\setminus(E^{old}\cup E^{pot})\big{)}\leq W_{T}\big{(}\mathcal{F}_{\textsc{Gnn}}\setminus(E^{old}\cup E^{pot})\big{)}$ w.r.t (6).

Lemma 4.4.

The total cost of $\mathcal{F}_{\textsc{Gnn}}$ is upper bounded by the total weight of $\mathcal{F}_{mdf}$ .

Theorem 4.5.

The forest $\mathcal{F}_{\textsc{Gnn}}$ can be transformed into the locality-based forest $\mathcal{F}_{\textsc{Grd}}$ such that the total cot of $\mathcal{F}_{\textsc{Gnn}}$ is upper bounded by the total weight of $\mathcal{F}_{\textsc{Grd}}$ .

5 Analysis

In this section, we provide a complete version of our analysis given in Section 4. At the end of this section, we consider the general graphs and show that the claim of Theorem 1.2 holds. We use the abbreviation $[i]:=\left\{0,\dots,i\right\}$ and $[i,j]:=\left\{i,\dots,j\right\}$ for non-negative integers $i$ and $j$ . Recall from Section 4 that Alg is a particular distributed DSMS protocol that sends a unique message from the node of a request to the node of the predecessor request for scheduling the request. In a one-shot execution of Alg, the total communication cost of the schedule $\pi^{z}_{\textsc{Alg}}$ for any $z\in[1,k]$ equals the total communication cost of the corresponding TSP path in the resulted forest by Alg w.r.t. (1) and (4).

[TABLE]

Using (2) and (9), therefore, the total cost of Alg equals the total cost of the resulted forest $\mathcal{F}_{\textsc{Alg}}$ that is sum of the total costs of the $k$ TSP paths.

[TABLE]

5.1 Optimal Distributed DSMS Protocols

When studying the cost of an optimal offline DSMS protocol Opt, we assume that Opt knows the whole sequence of requests in advance. However, Opt still needs to send messages from each request to its predecessor request. In Section 2.1, we explained that the message latencies are not even under control of an optimal distributed DSMS protocol, denoted by Opt.

Remark 5.1.

For lower bounding the cost of an optimal protocol that solves a distributed problem, one can assume that all communication is synchronous even in an asynchronous execution since a synchronous execution is a possible strategy of the asynchronous scheduler.

For lower bounding the total cost of Opt, we assume that all communication is synchronous w.r.t. Remark 5.1. Let $\mathcal{F}_{\textsc{Opt}}$ denote the resulted forest by Opt in a synchronous execution that includes $k$ TSP paths denoted by $F^{1}_{\textsc{Opt}},F^{2}_{\textsc{Opt}},\dots,F^{k}_{\textsc{Opt}}$ . Note that Opt only sends one message for scheduling of a request. Regarding to (3), the scheduling cost of any request $r^{\prime}=(v^{\prime},0)$ as the successor request of $r=(v,0)$ equals $d_{G}(v,v^{\prime})$ for the input graph $G=(V,E)$ in a synchronous system w.r.t. Section 2.1 if the corresponding find-predecessor message is sent through a direct path from $v^{\prime}$ to $v$ . Therefore, the total cost of Opt is at least the total weight of $\mathcal{F}_{\textsc{Opt}}$ w.r.t measurements of the input graph. Formally,

[TABLE]

Remark 5.2.

With respect to Definition 4.1, the resulted forest by any distributed protocol that solves the DSMS problem is an $\mathcal{R}_{D}$ -respecting spanning $k$ -forest of $B=\big{(}\mathcal{R},{\mathcal{R}\choose 2}\big{)}$ .

Regarding to Remark 5.2, the total weight of $\mathcal{F}_{\textsc{Opt}}$ can be lower bounded by the total weight of a minimum $\mathcal{R}_{D}$ -respecting spanning $k$ -forest of $B=\big{(}\mathcal{R},{\mathcal{R}\choose 2}\big{)}$ w.r.t. the measurements of the input graph $G$ . Let $\mathcal{F}_{\min}$ denote any minimum weight $\mathcal{R}_{D}$ -respecting spanning $k$ -forest of $B$ that includes $k$ trees denoted by $F^{1}_{\min},F^{2}_{\min},\dots,F^{k}_{\min}$ . Formally,

[TABLE]

5.2 Optimal Distributed DSMS Protocols on HSTs

We consider the HST $T$ (see Definition 2.1) as the input graph in this section. A set of requests $\mathcal{R}$ including the $k\geq 1$ dummy requests $\mathcal{R}_{D}$ as well as $k$ identical servers are initially located at some leaves of $T$ . As explained in the problem definition in Section 2.2, we assume w.l.o.g. that there is a dummy request at each leaf of $T$ that initially hosts a server. We observe that if Alg satisfies the following basic locality properties on $T$ , then it outputs an optimal solution w.r.t. $T$ . Later, we will formally show that this observation is indeed correct.

A server never goes back to a subtree after the time when it leaves the subtree. 2. 2.

All requests in any subtree of $T$ that initially hosts at least one server, are served by the servers inside the subtree. 3. 3.

All requests in any subtree of $T$ that does not initially host any server, are served by the same server.

However, w.r.t. (12) we would like to characterize the properties of $\mathcal{F}_{\min}$ instead of working with $\mathcal{F}_{\textsc{Opt}}$ . While any component of $\mathcal{F}_{\textsc{Opt}}$ is a TSP path that represents the movement of the corresponding server, any component of $\mathcal{F}_{\min}$ is a tree and not necessarily a TSP path. Hence, Property 1, Property 2, and Property 3 are adapted for any $\mathcal{R}_{D}$ -respecting spanning $k$ -forest of $B$ that has a minimum total weight as follows.

Let the $k$ components of any $\mathcal{R}_{D}$ -respecting spanning $k$ -forest $\mathcal{F}$ of $B$ denoted by $F^{1},F^{2},\dots,F^{k}$ . Further, let $\mathcal{R}^{w}$ denote the request set of the component $F^{w}$ for any $w\in[1,k]$ . For any subtree $T^{\prime}$ of $T$ , let $F^{w}(T^{\prime})$ denote the subgraph of $F^{w}$ that is induced by those requests in $\mathcal{R}^{w}$ that are also in $T^{\prime}$ and let $\mathcal{R}^{w}(T^{\prime})$ denote the request set of the component $F^{w}(T^{\prime})$ . Let $\mathcal{F}_{\textsc{Grd}}$ denote any $\mathcal{R}_{D}$ -respecting spanning $k$ -forest of $B$ that has the following basic locality properties.

I.

[Intra-Component Property] For any subtree $T^{\prime}$ of $T$ and for any $w\in[1,k]$ , the component $F^{w}_{\textsc{Grd}}(T^{\prime})$ is a tree. The Intra-Component property is adapted from the Property 1. 2. II.

[Inter-Component Property] For any subtree $T^{\prime}$ of $T$ , suppose that there are at least two non-empty components $F^{z}_{\textsc{Grd}}(T^{\prime})$ and $F^{w}_{\textsc{Grd}}(T^{\prime})$ where $w\neq z$ and $w,z\in[1,k]$ . Any of these components includes a dummy request. This property combines Property 2 and Property 3 into one property.

Note that the Property II implies that for any subtree $T^{\prime}$ of $T$ that does not initially host a server, all requests in $T^{\prime}$ are included in a unique component $F^{w}_{\textsc{Grd}}(T^{\prime})$ for some $w\in[1,k]$ . We generally say that removing an edge from any graph $G=(V,E)$ provides an $m$ -cut if the removal decomposes the graph into $m$ connected components. The following lemma elaborates more formally the Property I and Property II.

Lemma 5.1.

For every edge $e$ in $\mathcal{F}_{\textsc{Grd}}$ , consider the shortest weight edge $e^{*}$ in $E_{B}$ crossing the $(k+1)$ -cut induced by removing $e$ from $\mathcal{F}_{\textsc{Grd}}$ such that $\mathcal{F}_{\textsc{Grd}}\setminus\left\{e\right\}\cup\left\{e^{*}\right\}$ is again an $\mathcal{R}_{D}$ -respecting spanning $k$ -forest of $B$ . Then, the weight of $e$ equals the weight of $e^{*}$ .

Proof.

Let $e=(r_{p},r_{q})$ be in the component $F^{w}_{\textsc{Grd}}$ for some $w\in[1,k]$ . We consider two different cases as follows. 1) The edge $e^{*}$ crosses the cut—or $2$ -cut w.r.t. our definition of an $m$ -cut—over $F^{w}_{\textsc{Grd}}$ resulted by removing $e$ . 2) The edge $e^{*}$ crosses the $(k+1)$ -cut over $\mathcal{F}_{\textsc{Grd}}$ resulted by removing $e$ and connects two different components of $\mathcal{F}_{\textsc{Grd}}$ .

When we remove $e$ from $F^{w}_{\textsc{Grd}}$ , let $(\mathcal{R}^{w_{1}}_{\textsc{Grd}},\mathcal{R}^{w_{2}}_{\textsc{Grd}})$ be the resulted $2$ -cut. First, we show that the weight of $e^{*}=(r_{x},r_{y})$ is not smaller than weight of $e$ in the first case using the Property I. Regarding to the Property I, the tree $F^{w}_{\textsc{Grd}}(T^{\prime})$ is connected for every subtree $T^{\prime}$ of $T$ . Let $T^{\prime}$ be the lowest subtree of $T$ that consists of both $r_{p}$ and $r_{q}$ as shown in Figure 4. Hence, removing $e$ from $F^{w}_{\textsc{Grd}}(T^{\prime})$ does not decompose the tree $F^{w}_{\textsc{Grd}}(T^{\prime\prime})$ for any subtree $T^{\prime\prime}$ of $T$ whose root is not an ancestor of the root of $T^{\prime}$ —in this paper, we assume that a node is an ancestor of itself. Thus, the request set $\mathcal{R}^{w}_{\textsc{Grd}}(T^{\prime\prime})$ is completely either in $\mathcal{R}^{w_{1}}_{\textsc{Grd}}$ or $\mathcal{R}^{w_{2}}_{\textsc{Grd}}$ (this decomposition is shown with blue and gray colors in Figure 4). Therefore, the minimum depth of $T^{\prime\prime}$ is at least the depth of a child subtree of $T^{\prime}$ . We recall that the two requests $r_{x}$ and $r_{y}$ are on different sides of the cut $(\mathcal{R}^{w_{1}}_{\textsc{Grd}},\mathcal{R}^{w_{2}}_{\textsc{Grd}})$ . Hence, the least common ancestor of $v_{x}$ and $v_{y}$ has to be an ancestor of $T^{\prime}$ . Thus, we get $d_{T}(v_{p},v_{q})\leq d_{T}(v_{x},v_{y})$ .

Now, we show that the weight of $e^{*}=(r_{x},r_{y})$ is not smaller than the weight of $e$ in the second case using the Property II. W.l.o.g., assume that the dummy request is in $\mathcal{R}^{w_{1}}_{\textsc{Grd}}$ . Hence, one of the endpoints of $e^{*}$ must be in $\mathcal{R}^{w_{2}}_{\textsc{Grd}}$ and the other endpoint must belong to some different component $F^{z}_{\textsc{Grd}}$ . Let the subtree $T^{\prime}$ of $T$ be the lowest subtree that consists of both $r_{x}$ and $r_{y}$ . For the sake of contradiction, assume that the weight of $e^{*}$ is smaller than the weight of $e$ . Thus, the request set $\mathcal{R}^{w}_{\textsc{Grd}}(T^{\prime})$ that has one of the endpoints of $e^{*}$ , does not have any dummy request since $T^{\prime}$ is the lowest subtree that includes $e^{*}$ , and the weight of $e$ is larger than $e^{*}$ . However, using the Property II, the component $F^{w}_{\textsc{Grd}}(T^{\prime})$ must include a dummy request since there is another component $F^{z}_{\textsc{Grd}}(T^{\prime})$ that includes another endpoint of $e^{*}$ . This is a contradiction, and therefore the weight of $e^{*}$ is not smaller than the weight of $e$ . ∎

Lemma 5.2.

Any $\mathcal{R}_{D}$ -respecting spanning $k$ -forest of $B$ that has the Property I and Property II is indeed a minimum weight $\mathcal{R}_{D}$ -respecting spanning $k$ -forest of $B$ . Consequently,

[TABLE]

Proof.

Together with Lemma 5.1, Theorem A.1 implies that the total weight of $\mathcal{F}_{\textsc{Grd}}$ equals the total weight of $\mathcal{F}_{\min}$ . ∎

In an asynchronous system, the message latencies are unpredictable. Hence, the resulted forest by some optimal DSMS protocol on $T$ might violate the Property 1, Property 2, and Property 3.

Proof of Theorem 4.1.

Let $\mathcal{F}_{\textsc{Alg}}$ denote the resulted forest by Alg. Using the assumptions of the theorem, we have

[TABLE]

On the other hand, using (11), (12), and Lemma 5.2 we have

[TABLE]

∎

5.3 Optimality of GNN on HSTs

In this section, we provide a proof for Theorem 4.5. In an execution of Gnn protocol, we can have the situation where the Property 1, Property 2, and Property 3 are violated. Consider an example provided by Figure 1. In a one-shot execution of Gnn, there are initially two dummy $r^{1}_{0}$ and $r^{2}_{0}$ requests and four other requests $r_{a},r_{b},r_{c},r_{d}$ . The result of this execution is as follows. The find-predecessor message of $r_{a}$ reaches the root of $T^{\prime\prime}$ not later than the time when the find-predecessor message of $r_{b}$ reaches the root of $T^{\prime\prime}$ . This implies that the server that is initially in $T^{\prime\prime}$ leaves $T^{\prime\prime}$ for serving the request $r_{a}$ and it goes back again into $T^{\prime\prime}$ for serving $r_{b}$ . Therefore, the Property 1—or the Intra-Component property—is violated. Further, the find-predecessor message of $r_{d}$ reaches the root of $T^{\prime}$ not earlier than the find-predecessor messages of $r_{a}$ and $r_{b}$ and reaches the root of $T^{\prime\prime}$ not later than the find-predecessor messages of $r_{c}$ . Hence, the server that is not initially in $T^{\prime\prime}$ enters $T^{\prime\prime}$ for serving $r_{c}$ . Therefore, the Property 2—or the Inter-Component property—is violated.

5.3.1 Transforming $\mathcal{F}_{GNN}$

Although $\mathcal{F}_{\textsc{Gnn}}$ does not necessarily satisfy the Intra-Component and Inter-Component properties as it is shown by Figure 1 as an example, the “greedy nature” of Gnn helps us to transform $\mathcal{F}_{\textsc{Gnn}}$ into an $\mathcal{R}_{D}$ -respecting spanning $k$ -forest of $B$ that satisfies the Property I and Property II where $\mathcal{R}_{D}\subseteq\mathcal{R}$ such that the total cost of $\mathcal{F}_{\textsc{Gnn}}$ is upper bounded by the total weight of the new forest. Before we delve into details of the transformation, some preliminaries are provided in the following.

Let $M^{\uparrow}(T^{\prime}):=\{\mu^{\uparrow}_{1}(T^{\prime}),\mu^{\uparrow}_{2}(T^{\prime}),\dots\}$ denote the set of all find-predecessor messages of requests in $T^{\prime}$ that leave $T^{\prime}$ . We assume that $\mu^{\uparrow}_{1}(T^{\prime})$ is the first message that leaves $T^{\prime}$ . In general, the messages in $M^{\uparrow}(T^{\prime})$ are indexed in the order they leave $T^{\prime}$ . We also consider the set of all find-predecessor messages that enter the subtree $T^{\prime}$ . Let $M^{\downarrow}(T^{\prime}):=\{\mu^{\downarrow}_{1}(T^{\prime}),\mu^{\downarrow}_{2}(T^{\prime}),\dots\}$ denote the set of all find-predecessor messages of requests in $T^{\prime}$ that enter the subtree $T^{\prime}$ . The message $\mu^{\downarrow}_{1}(T^{\prime})$ is assumed to be the first message that enters $T^{\prime}$ . Similarly, the messages in $M^{\downarrow}(T^{\prime})$ are indexed in the order they enter $T^{\prime}$ . In the following, we provide a timeline from the first time when a message that is either in $M^{\uparrow}(T^{\prime})$ or in $M^{\downarrow}(T^{\prime})$ reaches the root of $T^{\prime}$ for any subtree $T^{\prime}$ of $T$ to the time when the last message among all messages in these two sets reaches the root of $T^{\prime}$ .

If the subtree $T^{\prime}$ only includes non-dummy requests, then the first message that reaches the root of $T^{\prime}$ must leave $T^{\prime}$ w.r.t. the description of Gnn. By contrast, if $T^{\prime}$ includes a dummy request, w.l.o.g., we assume that $\mu^{\uparrow}_{1}(T^{\prime})$ is a “virtual message” that reaches the root of $T^{\prime}$ at time [math]. Therefore, in either case, $M^{\uparrow}(T^{\prime})$ includes $\mu^{\uparrow}_{1}(T^{\prime})$ and $|M^{\uparrow}(T^{\prime})|\geq 1$ . The set $M^{\downarrow}(T^{\prime})$ , however, can be empty if there is not any request in $T^{\prime}$ that has a successor request outside of $T^{\prime}$ . Regarding the description of Gnn, note that the root of $T^{\prime}$ arbitrarily processes the messages that are received at the same time and Gnn does not take into account the processing time at the root of $T^{\prime}$ .

Lemma 5.3.

Consider any subtree $T^{\prime}$ of $T$ and any two messages that reach the root $v$ of $T^{\prime}$ at the same time $t$ in which one of them is from inside of $T^{\prime}$ denoted by $\mu$ and the other one is from outside of $T^{\prime}$ denoted by $\mu^{\prime}$ . The node $v$ processes $\mu^{\prime}$ before processing the message $\mu$ if the message $\mu$ leaves $T^{\prime}$ .

Proof.

The node $v$ does not point to its parent at time $t$ before it processes the message $\mu^{\prime}$ . Further, at the same time, $v$ must point to at least one of its children w.r.t. Lemma 3.2. Therefore, if $v$ processes $\mu$ before processing the message $\mu^{\prime}$ , then $\mu$ is forwarded inside $T^{\prime}$ w.r.t. the description of Gnn. This is a contradiction with the assumption of the lemma and consequently $v$ processes $\mu^{\prime}$ before processing the message $\mu$ . ∎

Lemma 5.4.

Consider any subtree $T^{\prime}$ of $T$ in which $M^{\downarrow}(T^{\prime})$ is not empty. The root $v$ of $T^{\prime}$ has an upward link since when $\mu^{\downarrow}_{i}(T^{\prime})$ reaches $v$ and it is processed by $v$ until the first time after processing $\mu^{\downarrow}_{i}(T^{\prime})$ when a find-predecessor message that leaves $T^{\prime}$ is processed by $v$ for any $i\in[1,|M^{\downarrow}(T^{\prime})|]$ .

Proof.

Let $\mu^{\uparrow}_{j}(T^{\prime})$ denote the first message that leaves $T^{\prime}$ not earlier than $t^{\downarrow}_{i}(T^{\prime})$ . Hence, we have $t^{\uparrow}_{j}(T^{\prime})\geq t^{\downarrow}_{i}(T^{\prime})$ . The message $\mu^{\downarrow}_{i}(T^{\prime})$ is processed by $v$ before processing $\mu^{\uparrow}_{j}(T^{\prime})$ even if $\mu^{\downarrow}_{i}(T^{\prime})$ and $\mu^{\uparrow}_{j}(T^{\prime})$ reach $v$ at the same time using Lemma 5.3. Therefore, $v$ forwards $\mu^{\downarrow}_{i}(T^{\prime})$ to $T^{\prime}$ and points to its parent w.r.t. the description of Gnn. The node $v$ has the pointer to its parent until when $v$ processes $\mu^{\uparrow}_{j}(T^{\prime})$ . The node $v$ forwards $\mu^{\uparrow}_{j}(T^{\prime})$ to its parent and the link that points to its parent is removed. ∎

Lemma 5.5.

Consider any subtree $T^{\prime}$ of $T$ that includes at least one request. The root $v$ of $T^{\prime}$ has a downward link since when $\mu^{\uparrow}_{i}(T^{\prime})$ reaches $v$ and it is processed by $v$ until the first time $t$ after processing $\mu^{\uparrow}_{i}(T^{\prime})$ when a find-predecessor message that enters $T^{\prime}$ is processed by $v$ for any $i\in[1,|M^{\uparrow}(T^{\prime})|]$ . Further, $t$ is strictly larger than $t^{\uparrow}_{i}(T^{\prime})$ .

Proof.

Let $\mu^{\downarrow}_{j}(T^{\prime})$ denote the first find-predecessor message that is processed by $v$ after processing $\mu^{\uparrow}_{i}(T^{\prime})$ . The messages $\mu^{\downarrow}_{j}(T^{\prime})$ and $\mu^{\uparrow}_{i}(T^{\prime})$ cannot reach $v$ at the same time as otherwise $\mu^{\downarrow}_{j}(T^{\prime})$ is processed before $\mu^{\uparrow}_{i}(T^{\prime})$ by $v$ using Lemma 5.3. Hence, we have $t^{\uparrow}_{i}(T^{\prime})<t=t^{\downarrow}_{j}(T^{\prime})$ .

If $t^{\uparrow}_{i}(T^{\prime})=0$ , then there is a downward directed path from $v$ at the beginning of the execution since there is a dummy request in $T^{\prime}$ and therefore $v$ has a downward link at time $t^{\uparrow}_{i}(T^{\prime})$ . Otherwise, $t^{\uparrow}_{i}(T^{\prime})$ must be larger than [math]. Suppose that the child node $u$ of $v$ sends the message $\mu^{\uparrow}_{i}(T^{\prime})$ to $v$ . The node $v$ atomically forwards the message $\mu^{\uparrow}_{i}(T^{\prime})$ at time $t^{\uparrow}_{i}(T^{\prime})$ to its parent and set a link that points from $v$ to $u$ w.r.t. the description of Gnn. Therefore, in either case, $v$ has a downward link at time $t^{\uparrow}_{i}(T^{\prime})$ . The node $v$ points to some other child $w$ if it receives another find-predecessor message from $w$ and forwards it either to $u$ or some other child node. Hence, $v$ has a downward link since $t^{\uparrow}_{i}(T^{\prime})$ as long as $v$ receives a find-predecessor message of some request that is inside $T^{\prime}$ . As soon as $\mu^{\downarrow}_{j}(T^{\prime})$ reaches $v$ , the node $v$ forwards it to $T^{\prime}$ . If $v$ has only one downward link immediately before $\mu^{\downarrow}_{j}(T^{\prime})$ reaches $v$ , the downward link is removed when the message $\mu^{\downarrow}_{j}(T^{\prime})$ is forwarded to $T^{\prime}$ . Therefore, the node $v$ has a downward link from time $t^{\uparrow}_{i}(T^{\prime})$ until at least $t^{\downarrow}_{j}(T^{\prime})$ . ∎

Finally, we are ready to provide a timeline from the time when the first message from the sets $M^{\downarrow}(T^{\prime})$ and $M^{\uparrow}(T^{\prime})$ reaches the root of $T^{\prime}$ to the time when the last message among all messages in these two sets reaches the root of $T^{\prime}$ .

Lemma 5.6.

Consider any subtree $T^{\prime}$ of $T$ that includes at least one request. Let $v$ denote the root of $T^{\prime}$ . We have

[TABLE]

Proof.

If the subtree $T^{\prime}$ includes only non-dummy requests, then the first message that reaches $v$ must be $\mu^{\uparrow}_{1}(T^{\prime})$ w.r.t. the description of Gnn. Even if the subtree $T^{\prime}$ includes a dummy request, then $\mu^{\uparrow}_{1}(T^{\prime})$ is again the first message that reaches $v$ since $\mu^{\uparrow}_{1}(T^{\prime})$ is a virtual message in this case and $t^{\uparrow}_{1}(T^{\prime})=0$ .

First, we show that

[TABLE]

We know that if $\mu^{\uparrow}_{1}(T^{\prime})$ is a virtual message, then $t^{\uparrow}_{1}(T^{\prime})=0$ . Therefore, the message $\mu^{\downarrow}_{1}(T^{\prime})$ can only reach $v$ after time [math] in this case. Otherwise, the subtree $T^{\prime}$ does not include any dummy request if $\mu^{\uparrow}_{1}(T^{\prime})$ is an actual message. Therefore, w.r.t. the initialization of Gnn, the root $v$ of $T^{\prime}$ has an upward link since there is not any dummy request in $T^{\prime}$ until time $t^{\uparrow}_{1}(T^{\prime})$ when $\mu^{\uparrow}_{1}(T^{\prime})$ reaches $v$ . Hence, the messages $\mu^{\downarrow}_{1}(T^{\prime})$ can only reach $v$ after $t^{\uparrow}_{1}(T^{\prime})$ since $v$ has an upward link immediately before $t^{\uparrow}_{1}(T^{\prime})$ and the message $\mu^{\downarrow}_{1}(T^{\prime})$ cannot be in transit on that. Consequently, in either case the message $\mu^{\downarrow}_{1}(T^{\prime})$ can only reach $v$ after $t^{\uparrow}_{1}(T^{\prime})$ . On the other hand, $\mu^{\downarrow}_{1}(T^{\prime})$ is the first message among all messages in $M^{\downarrow}(T^{\prime})$ that reaches $v$ and therefore $v$ has a downward link from $t^{\uparrow}_{1}(T^{\prime})$ to $t^{\downarrow}_{1}(T^{\prime})$ using Lemma 5.5. Therefore, $\mu^{\uparrow}_{2}(T^{\prime})$ cannot reach $v$ before $t^{\downarrow}_{1}(T^{\prime})$ as otherwise it cannot leave $T^{\prime}$ . Consequently, $t^{\uparrow}_{1}(T^{\prime})<t^{\downarrow}_{1}(T^{\prime})\leq t^{\uparrow}_{2}(T^{\prime})$ .

Assume that the following holds,

[TABLE]

We now show that the claim of lemma also holds for the following.

[TABLE]

The message $\mu^{\downarrow}_{j}(T^{\prime})$ can only reach $v$ after $t^{\uparrow}_{j}(T^{\prime})$ since $v$ has an upward link from $t^{\downarrow}_{j-1}(T^{\prime})$ to $t^{\uparrow}_{j}(T^{\prime})$ using Lemma 5.4. On the other hand, $\mu^{\uparrow}_{j+1}(T^{\prime})$ cannot reach $v$ before time $t^{\downarrow}_{j}(T^{\prime})$ as otherwise $\mu^{\uparrow}_{j+1}(T^{\prime})$ finds a downward link at $v$ using Lemma 5.5 and therefore it cannot leave $T^{\prime}$ . Consequently, the calim of the lemma holds. ∎

Corollary 5.7.

Consider any subtree $T^{\prime}$ of $T$ that includes at least one request. We have

[TABLE]

Proof.

The claim of the corollary holds using Lemma 5.6 since $\mu^{\uparrow}_{1}(T^{\prime})\in M^{\uparrow}(T^{\prime})$ . ∎

Gaps: Consider any subtree $T^{\prime}$ of $T$ . Assume that $|M^{\uparrow}(T^{\prime})|=m$ . We say that $\mathcal{F}_{\textsc{Gnn}}$ has the gap $\big{(}\mu^{\downarrow}_{i}(T^{\prime}),\mu^{\uparrow}_{i+1}(T^{\prime})\big{)}$ on $T^{\prime}$ for any $i\in[1,m-1]$ .

We may refer to a gap as an Intra-Component gap if the messages of the gap are corresponding with the requests that are in the same component of $\mathcal{F}_{\textsc{Gnn}}$ . If they are corresponding with the requests that are in two different components of $\mathcal{F}_{\textsc{Gnn}}$ , then the gap is called an Inter-Component gap. In fact, the Intra-Component and Inter-Component properties are violated when the Intra-Component and Inter-Component gaps are made, respectively.

Let $\delta(T^{\prime})$ denote the diameter of any subtree $T^{\prime}$ of $T$ that is the weight of the longest direct path between any two leaves in $T^{\prime}$ . Further, let $v_{\mathit{src}}(\mu)$ and $v_{\mathit{des}}(\mu)$ the source and destination of the message $\mu$ , respectively. In general, when we refer to the gap $(\mu,\mu^{\prime})$ , we assume that it is the gap on any subtree $T^{\prime}$ of $T$ in which $\mu$ enters $T^{\prime}$ as the $i$ -th message in $M^{\downarrow}(T^{\prime})$ and $\mu^{\prime}$ leaves $T^{\prime}$ as the $(i+1)$ -th message in $M^{\uparrow}(T^{\prime})$ for any $i\geq 1$ . In the following, we characterize the situations where a subtree of $T$ has a gap.

Size of a gap: The size of the gap $(\mu,\mu^{\prime})$ equals $d_{T}\big{(}v_{\mathit{des}}(\mu),v_{\mathit{src}}(\mu^{\prime})\big{)}$ .

We say that a subtree $T^{\prime}$ of $T$ is isolated if no find-predecessor message can enter or exit $T^{\prime}$ .

Lemma 5.8.

A subtree $T^{\prime}$ of $T$ is isolated if the root of $T^{\prime}$ has an upward and a downward links.

Proof.

Let $v$ denote the root of $T^{\prime}$ . The upward link implies that no find-predecessor message can enter $T^{\prime}$ as long as $v$ has an upward link. On the other hand, when the first find-predecessor message reaches $v$ from some node $u$ , a new downward link from $v$ to $u$ is created while the find-predecessor is forwarded to an already existed downward link w.r.t. the Gnn protocol. The same happens for all other find-predecessor messages when reaching $v$ afterward. Thus, $v$ always has a downward link, and the upward link remains unchanged. Consequently, $T^{\prime}$ is isolated since any other find-predecessor message cannot enter or exit $T^{\prime}$ . ∎

Lemma 5.9.

Consider the lowest subtree $T^{\prime}$ of $T$ in which $\mathcal{F}_{\textsc{Gnn}}$ has the gap $(\mu_{i},\mu_{j})$ on $T^{\prime}$ . The message $\mu_{i}$ does not visit any node on the path between $v_{\mathit{src}}(\mu_{j})$ and the root of $T^{\prime}$ (excluding the root of $T^{\prime}$ ).

Proof.

Let $v^{\prime}$ denote the root of $T^{\prime}$ and $T^{\prime}_{z}$ be the child subtree of $T^{\prime}$ that includes the leaf node $v_{\mathit{src}}(\mu_{j})$ . Further, let $v^{\prime}_{z}$ be the root of $T^{\prime}_{z}$ . For the sake of contradiction, assume that $\mu_{i}$ reaches $v^{\prime}_{z}$ . First, suppose that $\mu_{i}$ enters $T^{\prime}_{z}$ before the time when $\mu_{j}$ leaves $T^{\prime}_{z}$ . Since $T^{\prime}$ is the lowest subtree that has the gap $(\mu_{i},\mu_{j})$ and w.r.t. Lemma 5.6, we must have the gaps $(\mu_{i},\mu_{p})$ and $(\mu_{q},\mu_{j})$ on $T^{\prime}_{z}$ for some messages $\mu_{p}\in M^{\uparrow}(T^{\prime}_{z})$ and $\mu_{q}\in M^{\downarrow}(T^{\prime}_{z})$ . Using Lemma 5.6 the time when $\mu_{p}$ reaches $v^{\prime}_{z}$ is earlier than the time $\mu_{j}$ reaches $v^{\prime}_{z}$ . Hence, $\mu_{p}$ reaches $v^{\prime}$ earlier than the time when $\mu_{j}$ reaches $v^{\prime}$ since $\mu_{j}$ cannot overtake $\mu_{p}$ using Lemma 3.3. If $\mu_{p}$ leaves $T^{\prime}$ , then we cannot have the gap $(\mu_{i},\mu_{j})$ since $\mu_{p}$ makes the gap $(\mu_{i},\mu_{p})$ on $T^{\prime}$ . Consider the case where $\mu_{p}$ does not leave $T^{\prime}$ . This implies that $\mu_{p}$ must find a downward link at $v^{\prime}$ that points to a different child than $v^{\prime}_{z}$ when it reaches $v^{\prime}$ w.r.t. Lemma 3.2 while $v^{\prime}$ has also an upward link since the time when $\mu_{i}$ enters $T^{\prime}$ . Hence, the subtree $T^{\prime}$ is isolated using Lemma 5.8 and $\mu_{j}$ can never leave $T^{\prime}$ . Therefore, in either case, the forest $\mathcal{F}_{\textsc{Gnn}}$ cannot have $(\mu_{i},\mu_{j})$ as the gap on $T^{\prime}$ that is a contradiction.

Now, assume that $\mu_{i}$ enters $T^{\prime}_{z}$ after the time when $\mu_{j}$ leaves $T^{\prime}_{z}$ . Therefore, $\mu_{i}$ reaches $v^{\prime}_{z}$ after the time when $\mu_{j}$ reaches $v^{\prime}_{z}$ . Since only one message can be in transit on the edge $(v^{\prime},v^{\prime}_{z})$ w.r.t. Lemma 3.3, $\mu_{j}$ is forwarded to $(v^{\prime},v^{\prime}_{z})$ by $v^{\prime}_{z}$ earlier than the time when $\mu_{i}$ is forwarded in $(v^{\prime},v^{\prime}_{z})$ by $v^{\prime}$ . Therefore $\mu_{j}$ cannot reach $v^{\prime}$ later than the time when $\mu_{i}$ reaches $v^{\prime}$ . On the other hand, it cannot reach $v^{\prime}$ earlier than the time when $\mu_{i}$ reaches $v^{\prime}$ since $(\mu_{i},\mu_{j})$ is a gap. Hence, they must reach $v^{\prime}$ at the same time. This implies that $v^{\prime}$ must have a downward link using Lemma 3.2 that points to a different child than $v^{\prime}_{z}$ and therefore $T^{\prime}$ must be isolated w.r.t. Lemma 5.8 since $v^{\prime}$ has had also an upward link since $\mu_{i}$ enters $T^{\prime}$ . This is a contradiction with the fact that $\mu_{j}$ must leave $T^{\prime}$ . Consequently, the claim of the lemma holds. ∎

Corollary 5.10.

Consider the lowest subtree $T^{\prime}$ of $T$ in which $\mathcal{F}_{\textsc{Gnn}}$ has the gap $(\mu_{i},\mu_{j})$ on $T^{\prime}$ . The size of the gap $(\mu_{i},\mu_{j})$ equals the diameter of $T^{\prime}$ .

Proof.

Lemma 5.9 implies that $v_{\mathit{src}}(\mu_{j})$ and $v_{\mathit{des}}(\mu_{i})$ are in two different children subtrees of $T^{\prime}$ and therefore the claim of the corollary holds. ∎

Lemma 5.11.

Let $T^{\prime}$ be the lowest subtree of $T$ in which the message $\mu_{z}$ traverses one of the longest direct paths in $T^{\prime}$ . Suppose $T^{\prime}_{i}$ is the lowest subtree of $T^{\prime}$ that has the gap $(\mu_{i},\mu_{z})$ for some message $\mu_{i}$ that enters $T^{\prime}_{i}$ . The forest $\mathcal{F}_{\textsc{Gnn}}$ has the gap $(\mu_{i},\mu_{z})$ on all subtrees of $T^{\prime}$ that are rooted at the nodes on the direct path between the root of $T^{\prime}_{i}$ and either the root of $T^{\prime}$ —excluding the root of $T^{\prime}$ —or the root of the lowest subtree $T^{\prime}_{j}$ of $T^{\prime}$ —excluding the root of $T^{\prime}_{j}$ —that has the larger gap $(\mu_{j},\mu_{z})$ for some message $\mu_{j}$ .

Proof.

Let $v^{\prime}$ denote the root of $T^{\prime}$ and $v^{\prime}_{i}$ be the root of $T^{\prime}_{i}$ . Further, if there is not a larger gap than $(\mu_{i},\mu_{z})$ , then let $v^{\prime\prime}$ be $v^{\prime}$ . Otherwise, let $v^{\prime\prime}$ be the root of $T^{\prime}_{j}$ . The subtree $T^{\prime}_{j}$ must have a larger diameter than $T^{\prime}_{i}$ w.r.t. Corollary 5.10. Hence, in either case, the subtree rooted at $v^{\prime\prime}$ has a larger height than $T^{\prime}_{i}$ . Assume that $v^{\prime\prime}_{p}\neq v^{\prime\prime}$ is the closest node with $v^{\prime}_{i}$ on the direct path between $v^{\prime\prime}$ and $v^{\prime}_{i}$ in which $(\mu_{i},\mu_{z})$ is not a gap on the subtree rooted at $v^{\prime\prime}_{p}$ . Let $T^{\prime\prime}_{p}$ denote the subtree of $T$ that is rooted at $v^{\prime\prime}_{p}$ . The message $\mu_{z}$ must leave $T^{\prime\prime}_{p}$ since it visits $v^{\prime}$ and $T^{\prime}$ has a larger height than $T^{\prime\prime}_{p}$ . Since $\mu_{z}$ is an actual find-predecessor message, $\mu_{z}$ must make a gap on $T^{\prime\prime}_{p}$ that is larger than the gap $(\mu_{i},\mu_{z})$ . This contradicts the fact that $T^{\prime}_{j}$ is the lowest subtree that has a larger gap than $(\mu_{i},\mu_{z})$ . Thus, the claim of the lemma holds. ∎

Local predecessor: Any non-dummy request $r_{\mathit{src}}(\mu^{\prime})$ has a unique local predecessor if there is a gap $(\mu,\mu^{\prime})$ for any message $\mu$ that makes a gap with $\mu^{\prime}$ . The request $r_{\mathit{des}}(\mu)$ is the local predecessor of $r_{\mathit{src}}(\mu^{\prime})$ if $(\mu,\mu^{\prime})$ be the smallest gap among all gaps $(\mu^{\prime\prime},\mu^{\prime})$ for any message $\mu^{\prime\prime}$ that makes a gap with the massage $\mu^{\prime}$ . We may refer to $r_{\mathit{des}}(\mu)$ as the Intra-Component local predecessor of $r_{\mathit{src}}(\mu^{\prime})$ if $(\mu^{\prime},\mu)$ is an Intra-Component gap. Otherwise, it is called an Inter-Component local predecessor of $r_{\mathit{src}}(\mu^{\prime})$ if $(\mu,\mu^{\prime})$ is an Inter-Component gap.

For instance, in Figure 1, the request $r^{1}_{0}$ is the Intra-Component local predecessor of $r_{b}$ and the request $r_{b}$ is the Inter-Component local predecessor of $r_{c}$ . We can replace the edge $(r_{a},r_{b})$ with the new edge $(r^{1}_{0},r_{b})$ to satisfy the Intra-Component property. Further, we can replace the edge $(r^{2}_{0},r_{c})$ with the new edge $(r_{b},r_{c})$ to satisfy the Inter-Component property.

Remark 5.3.

Consider the Intra-Component local predecessor $r_{\mathit{des}}(\mu)$ of request $r_{\mathit{src}}(\mu^{\prime})$ . The request $r_{\mathit{des}}(\mu)$ is indeed scheduled before the request $r_{\mathit{src}}(\mu^{\prime})$ in the global schedule. The reason is as follows. Let $T^{\prime}$ be the lowest subtree of $T$ in which $\mathcal{F}_{\textsc{Gnn}}$ has the gap $(\mu,\mu^{\prime})$ on $T^{\prime}$ . Consider the directed path that is constructed by Gnn in the directed graph $H$ —the directed version of $T$ —during moving $\mu$ from the node of the successor request of $r_{\mathit{des}}(\mu)$ —that is, $r_{\mathit{src}}(\mu)$ —to the root of $T^{\prime}$ —it continues until $v_{\mathit{des}}(\mu)$ . This directed path can be deflected towards some successor request of $r_{\mathit{src}}(\mu)$ in the meantime when $\mu^{\prime}$ leaves $T^{\prime}$ until it finds the node of the predecessor request—that is, $r_{\mathit{des}}(\mu^{\prime})$ . Since $(\mu,\mu^{\prime})$ is an Intra-Component gap, then $r_{\mathit{des}}(\mu^{\prime})$ must be either $r_{\mathit{src}}(\mu)$ or some request that is scheduled after $r_{\mathit{src}}(\mu)$ .

Transformation: Now, we are ready to describe our transformation on $\mathcal{F}_{\textsc{Gnn}}$ using some modifications. In each modification, for every request $r$ that has a local predecessor, we replace the edge in $\mathcal{F}_{\textsc{Gnn}}$ whose endpoints are $r$ and its actual predecessor with an edge in ${\mathcal{R}\choose 2}$ whose endpoints are $r$ and its local predecessor.

Gap closing: A gap $(\mu_{i},\mu_{j})$ is closed when the edge $e(\mu_{j})$ is replaced with the new edge $\big{(}r_{\mathit{des}}(\mu_{i}),r_{\mathit{src}}(\mu_{j})\big{)}$ in a modification.

5.3.2 The Locality-Based Structure of the New Resulted Forest

In this section, we show that $\mathcal{F}_{\textsc{Gnn}}$ is transformed into an $\mathcal{R}_{D}$ -respecting spanning $k$ -forest of $B$ that satisfies the Property I and Property II after all modifications. We recall that $\mathcal{F}_{mdf}$ is the forest that is resulted after the transformation of $\mathcal{F}_{\textsc{Gnn}}$ that consists of all possible replacements.

Constructing $\mathcal{F}_{mdf}$ in a button-up approach: We consider all subtrees of the HST $T$ and close the gaps in a button-up approach on each subtree. We consider $h+1$ steps where $h$ is the height of $T$ . The leaves of $T$ are supposed to be subtrees of $T$ with height [math]. Assume that the gaps on all subtrees with height less than $i$ are already closed in steps $1,\ldots,i$ for any $i\geq 0$ . Now, we consider any subtree $T^{\prime}$ of $T$ with height $i$ in the $(i+1)$ -th step and we close all gaps on $T^{\prime}$ . Let $\mathcal{F}^{i+1}_{mdf}$ denote the result of the transformation at the end of $(i+1)$ -th step and therefore, $\mathcal{F}_{mdf}=\mathcal{F}^{h+1}_{mdf}$ . Let $\mathcal{F}^{0}_{mdf}:=\mathcal{F}_{\textsc{Gnn}}$ .

Remark 5.4.

This button-up approach for constructing $\mathcal{F}_{mdf}$ implies that when a gap is closed in the $(i+1)$ -th step on $T^{\prime}$ , $T^{\prime}$ is the lowest subtree of $T$ in which $\mathcal{F}_{\textsc{Gnn}}$ has the gap on $T^{\prime}$ as otherwise the gap must have been closed in the previous steps.

Corollary 5.12.

Using Remark 5.4 and Corollary 5.10, a new edge that is added as a result of closing any gap on $T^{\prime}$ in the $(i+1)$ -th step, the new edge connects two requests in two different children subtrees of $T^{\prime}$ .

Corollary 5.13.

Corollary 5.12* implies that closing the gaps on $T^{\prime}$ in the $(i+1)$ -th step does not change the structure of $\mathcal{F}^{i}_{mdf}(T^{\prime\prime})$ for any subtree $T^{\prime\prime}$ of $T^{\prime}$ . Formally, $\mathcal{F}^{i+1}_{mdf}(T^{\prime\prime})=\mathcal{F}^{i}_{mdf}(T^{\prime\prime})$ where $T^{\prime\prime}$ has height less than $i$ .*

Remark 5.5.

As a result of closing all gaps on $T^{\prime}$ , the edge $e\big{(}\mu^{\uparrow}_{p}(T^{\prime})\big{)}$ is removed for any message $\mu^{\uparrow}_{p}(T^{\prime})\in M^{\uparrow}(T^{\prime})$ where $p>1$ . If $T^{\prime}$ does not have any dummy request, then $\mu^{\uparrow}_{1}(T^{\prime})$ must be an actual message. However, since $\mu^{\uparrow}_{1}(T^{\prime})$ cannot make a gap with any other message in $M^{\downarrow}(T^{\prime})$ w.r.t. Lemma 5.6 and the definition of a gap, then $e\big{(}\mu^{\uparrow}_{1}(T^{\prime})\big{)}$ is not removed.

Lemma 5.14.

Consider any subtree $T^{\prime}$ of $T$ with height $i$ for any $i\geq 0$ such that $\mathcal{F}_{\textsc{Gnn}}(T^{\prime})$ is not empty. Let $v$ denote the root of $T^{\prime}$ . Assume that $T^{\prime}$ includes $m\geq 0$ dummy requests. We claim that

$\mathcal{F}^{i+1}_{mdf}(T^{\prime\prime})=\mathcal{F}^{i}_{mdf}(T^{\prime\prime})$ * for any subtree $T^{\prime\prime}$ of $T^{\prime}$ that has a smaller height than $T^{\prime}$ .* 2. 2.

$\mathcal{F}^{i+1}_{mdf}(T^{\prime})$ * has $\max\{1,m\}$ components in which any of these $m$ components is a connected tree that includes at most one dummy request.*

Proof.

The Claim 1 is true w.r.t. Corollary 5.13 for all $i\geq 0$ . Let $i=0$ and hence consider any subtree $T^{\prime}$ of $T$ with height [math]. The subtree $T^{\prime}$ is actually a leaf node. The subtree $T^{\prime}$ either does not host any dummy request or it hosts exactly one dummy request w.r.t. the DSMS problem definition. From a theoretical point of view, a leaf node can invoke more than one request at the same time in a one-shot execution. However, all requests are scheduled consecutively in a one-shot execution w.r.t. the description of Gnn. Hence, $T^{\prime}$ does not have any gap since there is only one message in $M^{\uparrow}(T^{\prime})$ . Therefore, all requests on $u$ are connected as a TSP path that is a sub-component of some component of $\mathcal{F}_{\textsc{Gnn}}$ . This TSP path remains unchanged at the end of the first step since $T^{\prime}$ does not have any gap. In fact, $\mathcal{F}^{1}_{mdf}(T^{\prime})=\mathcal{F}_{\textsc{Gnn}}(T^{\prime})$ . The tail of this TSP path is $r_{\mathit{src}}\big{(}\mu^{\uparrow}_{1}(T^{\prime})\big{)}$ that is either a dummy request if $T^{\prime}$ hosts one dummy request or is an actual request if $T^{\prime}$ does not host any dummy request. Consequently, the Claim 2 holds for any leaf node.

Assume that $i\geq 1$ steps have been done and the Claim 2 now holds for any subtree with height less than $i$ . Consider the $(i+1)$ -th step and any subtree $T^{\prime}$ of $T$ with height $i$ that includes $m\geq 0$ dummy requests such that $\mathcal{F}_{\textsc{Gnn}}(T^{\prime})$ is not empty. Some of the gaps on $T^{\prime}$ might have been already closed in the previous steps. We show that the Claim 2 holds for $T^{\prime}$ at the end of $(i+1)$ -th step since a) any component of $\mathcal{F}^{i+1}_{mdf}(T^{\prime})$ includes at most one dummy request, b) any component of $\mathcal{F}^{i+1}_{mdf}(T^{\prime})$ is a tree, and c) $\mathcal{F}^{i+1}_{mdf}(T^{\prime})$ has $\max\{1,m\}$ components.

a.

Any component of $\mathcal{F}^{i+1}_{mdf}(T^{\prime})$ includes at most one dummy request: Using Corollary 5.13 and w.r.t. our assumption of the induction hypothesis, any component of $\mathcal{F}^{i+1}_{mdf}(T^{\prime}_{z})$ for any child subtree $T^{\prime}_{z}$ of $T^{\prime}$ includes at most one dummy request. Therefore, w.r.t. Corollary 5.12 we need to show that there is not any edge in $\mathcal{F}^{i+1}_{mdf}(T^{\prime})$ that connects one component of $\mathcal{F}^{i+1}_{mdf}(T^{\prime}_{z})$ that includes a dummy request and another component of $\mathcal{F}^{i+1}_{mdf}(T^{\prime}_{w})$ that also includes a dummy request where $T^{\prime}_{z}$ and $T^{\prime}_{w}$ are children subtrees of $T^{\prime}$ . The subtrees $T^{\prime}_{z}$ and $T^{\prime}_{w}$ must include dummy requests. Since $T^{\prime}_{w}$ and $T^{\prime}_{z}$ include dummy requests and have height $i-1$ , all edges $e\big{(}\mu^{\uparrow}_{p}(T^{\prime}_{w})\big{)}$ and $e\big{(}\mu^{\uparrow}_{p}(T^{\prime}_{z})\big{)}$ for $p\geq 2$ are removed in steps $1,\dots,i$ w.r.t. Remark 5.5 and the messages $\mu^{\uparrow}_{1}(T^{\prime}_{w})$ and $\mu^{\uparrow}_{1}(T^{\prime}_{z})$ are both virtual messages w.r.t. the definition of $M^{\uparrow}(T^{\prime\prime})$ for any subtree $T^{\prime\prime}$ of $T$ . This implies that: First, any original edge—an edge in $\mathcal{F}_{\textsc{Gnn}}$ —that connects two requests in $T^{\prime}_{w}$ and $T^{\prime}_{z}$ has been removed in previous steps. Second, there is not any open gap on $T^{\prime}$ that is made with a message in $M^{\uparrow}(T^{\prime}_{z})$ or in $M^{\uparrow}(T^{\prime}_{w})$ . Thus, closing gaps on $T^{\prime}$ in the $(i+1)$ -th step cannot add a new edge between $T^{\prime}_{w}$ and $T^{\prime}_{z}$ . 2. b.

Any component of $\mathcal{F}^{i+1}_{mdf}(T^{\prime})$ is a tree: Using Corollary 5.13 and w.r.t. our assumption of the induction hypothesis, any component of $\mathcal{F}^{i+1}_{mdf}(T^{\prime}_{z})$ for any child subtree $T^{\prime}_{z}$ of $T^{\prime}$ is a tree. Therefore, w.r.t. Corollary 5.12 we need to show that there is not any cycle that consists of some edges in $\mathcal{F}^{i+1}_{mdf}(T^{\prime})$ such that every edge of the cycle connects two children subtrees of $T^{\prime}$ . For the sake of contradiction, assume that there is such a cycle. We see the “nodes” of the cycle as a subset of children subtrees of $T^{\prime}$ . Any child subtree of $T^{\prime}$ that includes a dummy request, cannot be a node of the cycle since all edges corresponding with the message that leave the subtree with height $i-1$ have been removed in previous steps w.r.t. Remark 5.5. Hence, any node of the cycle must be a child subtree of $T^{\prime}$ that does not include any dummy request. Let $J$ denote the set of those children subtrees of $T^{\prime}$ that are seen as the nodes of the cycle. Consider the first find-predecessor message $\mu$ that is processed by $v$ —that is, the root of $T$ —among all messages that leaves the children subtrees in $J$ . The message $\mu$ either leaves $T^{\prime}$ or finds a downward link on $v$ . In the latter case, the downward link does not point to any request that is in a subtree in $J$ since $\mu^{\uparrow}_{1}(T^{\prime}_{z})$ is an actual message for any $T^{\prime}_{z}$ in $J$ and $\mu$ is the first message among all messages in $\cup_{\forall T^{\prime}_{z}\in J}M^{\uparrow}(T^{\prime}_{z})$ that is processed by $v$ , and therefore a message cannot enter any subtree in $J$ before $\mu$ reaches $v$ Lemma 5.6. Therefore, the request $r_{\mathit{des}}(\mu)$ is in a child subtree of $T^{\prime}$ that is not in $J$ and consequently the cycle is broken that is a contradiction. Consider the former case where $\mu$ leaves $T^{\prime}$ . Hence, using Lemma 5.6 and w.r.t. the definition of a gap the message $\mu$ must make a gap $(\mu^{\prime},\mu)$ on $T^{\prime}$ for some message $\mu^{\prime}$ that enters $T^{\prime}$ . The gap $(\mu^{\prime},\mu)$ is closed in $(i+1)$ -th step. Since $\mu$ is the first message among all messages in $\cup_{\forall T^{\prime}_{z}\in J}M^{\uparrow}(T_{z}^{\prime})$ that reaches the root of $T^{\prime}$ and processed by the root of $T^{\prime}$ , and the time when $\mu$ reaches the root of $T^{\prime}$ is not earlier than the time $\mu^{\prime}$ reaches the root of $T^{\prime}$ because $(\mu^{\prime},\mu)$ is a gap on $T^{\prime}$ , then $\mu^{\prime}$ cannot enter any subtree in $J$ . As a result of closing the gap $(\mu^{\prime},\mu)$ a new edge is added w.r.t. our transformation described in Section 5.3.1. The new edge must connect two requests $r_{\mathit{src}}(\mu)$ and $r_{\mathit{des}}(\mu^{\prime})$ in two different children subtrees of $T^{\prime}$ using Corollary 5.12. Since $\mu^{\prime}$ does not enter any subtree in $J$ , the new edge must connect a subtree in $J$ with a child subtree of $T^{\prime}$ that is not in $J$ . We again get a contradiction since the cycle is broken. Consequently, there is not such a cycle and any component of $\mathcal{F}^{i+1}_{mdf}(T^{\prime})$ is indeed a tree. 3. c.

$\mathcal{F}^{i+1}_{mdf}(T^{\prime})$ has exactly $\max\{1,m\}$ components: If $\mathcal{F}_{\textsc{Gnn}}(T^{\prime})$ is not empty, $\mathcal{F}^{i+1}_{mdf}(T^{\prime})$ cannot have less than $\max\{1,m\}$ components w.r.t. the fact—it is already proved—that any component of $\mathcal{F}^{i+1}_{mdf}(T^{\prime})$ includes at most one dummy request. By contrast, assume that $\mathcal{F}^{i+1}_{mdf}(T^{\prime})$ has more than $\max\{1,m\}$ components for the sake of contradiction. Therefore, there are at least two components in $\mathcal{F}^{i+1}_{mdf}(T^{\prime})$ and at least one of the components in $\mathcal{F}^{i+1}_{mdf}(T^{\prime})$ does not include any dummy request since $T^{\prime}$ includes $m$ dummy requests. Consider any component $F^{z}$ of $\mathcal{F}^{i+1}_{mdf}(T^{\prime})$ that does not include any dummy request. The first message among all messages corresponding with the requests in $F^{z}$ that is processed by $v$ , must leave $T^{\prime}$ as otherwise the message is forwarded inside $T^{\prime}$ towards some request that is not in $F^{z}$ w.r.t. Lemma 5.6 and therefore $F^{z}$ must also include some other request in $T^{\prime}$ . Let $F^{z}$ be the component of $\mathcal{F}^{i+1}_{mdf}(T^{\prime})$ that does not include any dummy request such that the first message $\mu$ corresponding with any request included in $F^{z}$ leaves $T^{\prime}$ after $\mu^{\uparrow}_{1}(T^{\prime})$ . The message $\mu$ must make a gap $(\mu^{\prime},\mu)$ on $T^{\prime}$ w.r.t. Lemma 5.6 and the definition of a gap for some message $\mu^{\prime}$ that enters $T^{\prime}$ . However, the gap $(\mu^{\prime},\mu)$ is closed in the $(i+1)$ -th step and therefore the local predecessor $r_{\mathit{des}}(\mu^{\prime})$ must be in $F^{z}$ . This is a contradiction, since $\mu$ is the first message that leaves $T^{\prime}$ among all messages corresponding with requests in $F^{z}$ and therefore $r_{\mathit{des}}(\mu^{\prime})$ cannot be in $F^{z}$ Lemma 5.6.

∎

Proof of Lemma 4.2.

The Claim 2 of Lemma 5.14 implies that at the end of $(h+1)$ -th step of our button-up constructing of $\mathcal{F}_{mdf}$ , $\mathcal{F}^{h+1}_{mdf}(T)=\mathcal{F}_{mdf}$ is an $\mathcal{R}_{D}$ -respecting spanning $k$ -forest of $B$ since the HST $T$ includes $k\geq 1$ dummy requests.

Further, the Property I and Property II are guaranteed on any subtree $T^{\prime}$ of $T$ with height $i\geq 0$ using the Claim 2 of Lemma 5.14 at the end of $(i+1)$ -th step. The two properties are not also violated later in the $j$ -th step where $j>i+1$ w.r.t. the Claim 1 of Lemma 5.14. ∎

5.3.3 Total Cost of GNN: An Upper Bound

In this section, we show that the total weight of $\mathcal{F}_{mdf}$ is at least the total cost of $\mathcal{F}_{\textsc{Gnn}}$ . Formally, we want to show that

[TABLE]

The latency of a message $\mu$ from $u$ to $v$ on $T$ is denoted by $\ell_{\textsc{Gnn}}(\mu,u,v)$ . Hence, $\ell_{\textsc{Gnn}}\big{(}e(\mu)\big{)}:=\ell_{\textsc{Gnn}}(\mu)=\ell_{\textsc{Gnn}}(\mu,v_{\mathit{src}}(\mu),v_{\mathit{des}}(\mu))$ . Let $(\mu,\mu^{\prime})$ be the smallest gap among all gaps $(\mu^{\prime\prime},\mu^{\prime})$ for any message $\mu^{\prime\prime}$ that makes a gap with $\mu^{\prime}$ . Therefore, $e(\mu^{\prime})$ is removed and replaced with a new edge that connects two requests $r_{\mathit{des}}(\mu)$ and $r_{\mathit{src}}(\mu^{\prime})$ . Since we want to show that (13) holds, we need to upper bound the latency of $\mu^{\prime}$ —that is, $\ell_{\textsc{Gnn}}(\mu^{\prime})$ —with the weight of the new edge $e^{new}=\big{(}r_{\mathit{des}}(\mu),r_{\mathit{src}}(\mu^{\prime})\big{)}$ . However, the $\ell_{\textsc{Gnn}}(\mu^{\prime})$ can be larger than $w_{T}(e^{new})$ . By contrast, the following lemma shows that the latency of $\mu$ is upper bounded by $w_{T}(e^{new})$ . This lemma gives us the go-ahead to show that $w_{T}(e^{new})$ can be seen as an “amortized” upper bound for $\ell_{\textsc{Gnn}}(\mu^{\prime})$ .

Lemma 5.15.

Consider any subtree $T^{\prime}$ of $T$ . Assume that $\mathcal{F}_{\textsc{Gnn}}$ has any gap $(\mu,\mu^{\prime})$ on $T^{\prime}$ . The latency of the message $\mu$ is upper bounded by the diameter of $T^{\prime}$ . Formally,

[TABLE]

Proof.

Let $v$ denote the root of $T^{\prime}$ . Using Lemma 3.5, a find-predecessor message always finds the node of its predecessor using a direct path constructed by Gnn. Using Lemma 5.6, the message $\mu^{\prime}$ reaches $v$ not earlier than the time when $\mu$ reaches $v$ . Therefore,

[TABLE]

On the other hand we can have:

[TABLE]

The second inequality follows because the latency of an edge is at most the weight of the edge (see Section 2.1). ∎

Amortized analysis: In the overview of our amortization that has been provided in Section 5.3 using the simple case, we use the potential $w_{T}(e^{pot}_{i})-\ell_{\textsc{Gnn}}(e^{pot}_{i})$ to take $w_{T}(e^{new}_{i})$ into account as an amortized upper bound of $\ell_{\textsc{Gnn}}\big{(}\mu(e^{old}_{i})\big{)}$ . In general, the same approach can be used to show that (13) holds with a more complicated analysis. The complication appears in two directions: 1) when $|E^{old}(e)|>1$ for any edge $e\in E^{pot}$ or $|E^{pot}(e)|>1$ for any edge $e\in E^{old}$ . Further, 2) the sets $E^{old}$ and $E^{pot}$ can share some edges that create a dependency graph between the edges in $E^{old}$ and $E^{pot}$ . Because of the latter situation, we cannot replace an edge $e\in E^{pot}\cap E^{old}$ before replacing the edges in $E^{old}(e)$ since we require the potential of the edge $e$ for amortizing the edges in $E^{old}(e)$ . Hence, we consider priorities for edges to be replaced. Regarding to the first complication, we will show that for any edge $e\in E^{old}$ , all edges in $E^{pot}(e)$ contribute enough potential for amortizing the weight of $e$ . Further, we will guarantee that the maximum potential of any edge $e\in E^{opt}$ that is distributed among all edges in $E^{old}(e)$ is $w_{T}(e)-\ell_{\textsc{Gnn}}(e)$ .

Priority directed graph (PDG): We consider the dependencies between the edges in $E^{old}$ and $E^{pot}$ as a priority directed graph in which any edge in $E^{old}\cup E^{pot}$ is represented by a node in PDG and there is a directed edge from the node $e$ to another node $e^{\prime}$ in PDG if $e^{\prime}\in E^{old}$ and $e\in E^{pot}(e^{\prime})$ .

Lemma 5.16.

The priority directed graph (PDG) is acyclic.

Proof.

For the sake of contradiction, assume that there is a cycle in PDG consists of $e_{1},e_{2},\dots,e_{i}$ such that $e_{p}$ points to $e_{p+1}$ where $p\in[1,i-1]$ and $e_{i}$ points to $e_{1}$ . When an edge $e$ points to another edge $e^{\prime}$ in PDG, it implies that there is a gap $\big{(}\mu(e),\mu(e^{\prime})\big{)}$ in $\mathcal{F}_{\textsc{Gnn}}$ . Let $T_{p}$ be any subtree of $T$ in which $\mathcal{F}_{\textsc{Gnn}}$ has the gap $\big{(}\mu(e_{p-1}),\mu(e_{p})\big{)}$ on it for $p\in[2,i]$ and let $T_{1}$ be any subtree of $T$ such that $\mathcal{F}_{\textsc{Gnn}}$ has the gap $\big{(}\mu(e_{i}),\mu(e_{1})\big{)}$ on it. Let $t^{\uparrow}_{p}$ denote the time when $\mu(e_{p})$ leaves $T_{p}$ for all $p\in[1,i]$ and $t^{\downarrow}_{p}$ denote the time when it enters $T_{p+1}$ for all $p\in[1,i-1]$ . Finally, let $t^{\downarrow}_{i}$ denote the time when it enters $T_{1}$ . Using the definition of a gap and Lemma 5.6, we have

[TABLE]

and

[TABLE]

On the other hand, we have $t^{\uparrow}_{p}<t^{\downarrow}_{p}$ for all $p\in[1,i]$ . Therefore, we get $t^{\downarrow}_{p}<t^{\downarrow}_{p}$ for all $p\in[1,i]$ that is a contradiction. Consequently, PDG is acyclic. ∎

For our analysis, we consider steps, and in each step, we replace those edges in $E^{old}$ whose corresponding nodes in PDG do not have any outgoing edges. Note that in each step until the end when all edges in $E^{old}$ are replaced, there is such a node in PDG w.r.t. Lemma 5.16. Further, we remove these nodes and the incident edges from PDG at the end of each step.

The following lemma shows that the total weight of the edges that are removed during the transformation of $\mathcal{F}_{\textsc{Gnn}}$ are amortized with the total weight of edges that are added during the transformation.

Lemma 5.17.

In the overview of our amortized analysis, using Lemma 4.3, it was shown that (8) holds for the simple case. Even in a general case (8) holds.

Proof.

Consider the edge $e^{old}_{z}\in E^{old}$ that does not have any outgoing edge in PDG in the current step of transformation. Suppose that during the transformation, $e^{old}_{z}$ is replaced with $e^{new}_{z}$ . Let $T^{\prime}$ be the subtree of $T$ such that $w_{T}(e^{old}_{z})=\delta(T^{\prime})$ . Further, let $E^{pot}(e^{old}_{z})=\big{\{}e^{pot}_{1},e^{pot}_{2},\dots,e^{pot}_{i}\big{\}}$ . We assume that, w.l.o.g., the gap $\big{(}\mu(e^{pot}_{p+1}),\mu(e^{old}_{z})\big{)}$ is larger than the gap $(\mu(e^{pot}_{p}),\mu(e^{old}_{z}))$ for all $p\in[1,i-1]$ . Suppose $T^{\prime}_{p}$ is the lowest subtree of $T^{\prime}$ such that $\mathcal{F}_{\textsc{Gnn}}$ has the gap $(\mu^{pot}_{p},\mu^{old}_{z})$ on that for all $p\in[1,i]$ . Let $v_{p}$ denote the root of $T^{\prime}_{p}$ and $v$ denote the root of $T^{\prime}$ . For simplicity, let $\mu^{old}_{q}=\mu(e^{old}_{q})$ , $\mu^{new}_{q}=\mu(e^{new}_{q})$ , and $\mu^{pot}_{q}=\mu(e^{pot}_{q})$ for all $q$ . Using Corollary 5.10, $T^{\prime}_{p+1}$ must be higher than $T^{\prime}_{p}$ as you can see in Figure 6.

The gap $(\mu^{pot}_{1},\mu^{old}_{z})$ is the smallest gap among all gaps $(\mu^{pot}_{p},\mu^{old}_{z})$ for any $p\in[1,i]$ using the assumption of the lemma. Since $T^{\prime}_{1}$ is the lowest subtree of $T$ that has the gap $(\mu^{pot}_{1},\mu^{old}_{z})$ , w.r.t. Corollary 5.10, therefore,

[TABLE]

Since $w_{T}(e^{old}_{z})=2\cdot d_{T}\big{(}v_{\mathit{src}}(\mu^{old}_{z}),v\big{)}$ , hence we have

[TABLE]

Lemma 5.11 implies that all subtrees rooted at the nodes on the direct path between $v_{p}$ and $v_{p+1}$ for any $p\in[1,i-1]$ cannot have another gap $\big{(}\mu^{pot}_{p},\mu^{\prime}\big{)}$ for any edge $e(\mu^{\prime})\in E^{old}$ and all subtrees rooted at the nodes on the direct path between $v_{i}$ and $v$ cannot have another gap $\big{(}\mu^{pot}_{i},\mu^{\prime}\big{)}$ for any edge $e(\mu^{\prime})\in E^{old}$ . Therefore, the direct path between $v_{p}$ and $v_{p+1}$ for any $p\in[1,i-1]$ is a sub-path of the whole path that is traversed by $\mu^{pot}_{p}$ . Further, the direct path between $v_{i}$ and $v$ is a sub-path of the whole path that is traversed by $\mu^{pot}_{i}$ . Consequently, the amount $d_{T}(v_{p},v_{p+1})$ for any $p\in[1,i-1]$ as well as the amount $d_{T}(v_{i},v)$ are counted exactly once and do not appear in the right side of (15) for any other edge in $E^{old}$ . Therefore we can have the following. Consider any edge $e$ in $E^{pot}$ . Assume that we sum up the right side of (15) for all $e^{old}_{z}\in E^{old}$ . Regarding to the edge $e$ , at most the amount $w_{T}\big{(}e)-\delta(T_{1}(e)\big{)}$ appears where $\delta\big{(}T_{1}(e)\big{)}$ is the diameter of the lowest subtree of $T$ in which $\mathcal{F}_{\textsc{Gnn}}$ has the gap $(\mu(e),\mu^{\prime})$ for any $e(\mu^{\prime})\in E^{old}$ . Note that the amount $2\cdot d_{T}\big{(}v_{\mathit{des}}(\mu(e)),v_{1}(e)\big{)}$ where $v_{1}(e)$ is the root of $T_{1}(e)$ is never used in the right side of (15) for any edge in $E^{old}$ and therefore $\delta\big{(}T_{1}(e)\big{)}$ can be subtracted when we sum up the right side of (15) for all $e^{old}_{z}\in E^{old}$ . Hence, we sum up (15) for all $e^{old}_{z}\in E^{old}$ and we get

[TABLE]

On the other hand, using Lemma 5.15 we can have the following for every $e\in E^{pot}$ ,

[TABLE]

If we sum up the above equation for all edges in $E^{pot}$ , we get

[TABLE]

Using (16) and (17) we get

[TABLE]

Regarding to the definition of the potential function $\Phi$ , the claim of the lemma holds. ∎

Proof of Lemma 4.4.

Although for our analysis we replace the edges w.r.t. the priority directed graph (PDG), we still use the potential of edges in $E^{old}\cap E^{pot}$ for computing (18) while they are removed during the transformation. However, we show that $\Phi\left(E^{pot}\cap E^{old}\right)$ is actually used only as an auxiliary potential and can be removed.

Consider Lemma 5.17. If we subtract $W_{T}(E^{pot}\cap E^{old})$ from both side of (18), then we get

[TABLE]

Since w.r.t (6) $L_{\textsc{Gnn}}\left(E^{old}\setminus E^{pot}\right)\leq W_{T}\left(E^{old}\setminus E^{pot}\right)$ and $E^{old}=\left(E^{old}\setminus E^{pot}\right)\cup\left(E^{old}\cap E^{pot}\right)$ we can have

[TABLE]

Thus, the actual potential that is used for amortizing $L_{\textsc{Gnn}}(E^{old})$ is $\Phi(E^{pot}\setminus E^{old})$ and the edges in $E^{pot}\setminus E^{old}$ are indeed in $\mathcal{F}_{mdf}$ . Since we have $E^{old}\cup E^{pot}=\left(E^{old}\cup\left(E^{pot}\setminus E^{old}\right)\right)$ , therefore

[TABLE]

Using (6) we can have $L_{\textsc{Gnn}}\left(\mathcal{F}_{\textsc{Gnn}}\setminus\left(E^{old}\cup E^{pot}\right)\right)\leq W_{T}\left(\mathcal{F}_{\textsc{Gnn}}\setminus\left(E^{old}\cup E^{pot}\right)\right)$ . Together with $\mathcal{F}_{mdf}=\mathcal{F}_{\textsc{Gnn}}\setminus E^{old}\cup E^{new}$ we get

[TABLE]

∎

Proof of Theorem 4.5.

The claim of the theorem immediately follows Lemma 4.2 and Lemma 4.4. ∎

Proof of Theorem 1.3.

Theorem 4.1 and Theorem 4.5 both together show that the claim of the theorem holds. ∎

Proof of Corollary 1.4.

As described in Section 1, the distributed queuing problem is an application of DSMS where $k=1$ . The goal in the distributed queuing problem is to minimize sum of the total communication cost and the total waiting time. When all requests are simultaneously invoked, the total waiting time gets [math]. Consequently, Gnn optimally solves the distributed queuing problem for one-shot executions on HSTs in the light of Theorem 1.3. ∎

5.4 DSMS Problem on General Networks

In this section, we consider a general graph $G=(V,E)$ as the input graph. We show that when running any distributed DSMS protocol Alg that satisfies the conditions of Theorem 4.1 on top of HST $T$ , we obtain a randomized protocol with an expected competitive ratio of at most $\operatorname{O}\bigl{(}\log n\bigr{)}$ against an oblivious adversary. The following theorem provides a general version of Theorem 1.2.

Theorem 5.18.

Suppose we are given a graph $G=(V,E)$ and a set of requests $\mathcal{R}$ that all are invoked at the same time by the nodes of $G$ where $|V|=n$ . There is a randomized embedding of $G$ into a distribution over HSTs in which we sample an HST $T$ according to the distribution defined by the embedding. Consider any distributed protocol Alg that that satisfies the conditions of Theorem 4.1. When running Alg on $T$ , we get a distributed randomized protocol for $G$ with an expected competitive ratio of at most $\operatorname{O}\bigl{(}\log n\bigr{)}$ against an oblivious adversary. This even holds if communication is asynchronous.

Proof.

Assume that the HST $T$ is constructed on top of $G$ by using the randomized algorithm of [FRT03]. Let $\mathcal{F}_{\textsc{Opt}}(T)$ and $\mathcal{F}_{\textsc{Opt}}(G)$ denote the resulted forests by Opt where communication is synchronous on $T$ and $G$ as the input graph. We get

[TABLE]

The first inequality follows from the fact that $\mathcal{F}_{\textsc{Opt}}(G)$ is not necessarily an optimal weight forest w.r.t. the edge weights of $T$ . The second inequality follows from the expected stretch bound of the HST construction of [FRT03]. Given Theorem 4.1 and (19), the claim of the theorem holds w.r.t. Remark 5.1. In fact, using the assumptions of Theorem 4.1 that is also stated in the theorem, Lemma 5.2, and (12) we have $\mathit{C}_{\textsc{Alg}}\leq W_{T}\left(\mathcal{F}_{\textsc{Opt}}(T)\right)$ . ∎

Note that the statement of Theorem 5.18 also holds when communication is synchronous on $G$ . Because the statement of Theorem 4.1 applies to the general asynchronous case, it also captures a synchronous scenario, where the latency on each edge is fixed but might be smaller than the actual weight of the edge on $T$ . Note that such executions are relevant because an HST is often built as an overlay graph on top of an underlying network graph $G$ and the latency of simulating a single HST edge might be smaller than the weight of the edge.

Proof of Theorem 1.2.

Given Theorem 4.5 and Theorem 5.18, we immediately get the theorem. ∎

6 Lower Bound

We provide a simple reduction from the distributed $k$ -server problem [BR92] (a statement of this problem is given in Section 1) to the DSMS problem that preserves the competitive ratio up to some constant factor. We utilize the lower bound presented in [BR92] together with our reduction to prove our lower bound stated in Theorem 1.5.

The reduction is trivial since the DSMS problem when requests are sequentially invoked is identical with the distributed $k$ -server problem but their cost functions. We consider instances that consist of a synchronous network that is modeled by a graph $G=(V,E)$ and a set of requests that are sequentially invoked one by one. Let $I$ denote such an instance. Our reduction neither changes the sequence of request nor the input network. The only difference is with respect to their cost functions. Hence, let us provide our analysis of their costs.

Proof of Theorem 1.5.

As before, let $\mathcal{R}$ denote a sequence of requests including the $k$ dummy requests in $\mathcal{R}_{D}$ . Let $\mathcal{F}$ denote the resulted forest by an optimal offline protocol that solves the instance $I$ . $\mathcal{F}$ consists of $k$ TSP paths that span all requests in $\mathcal{R}$ . The total communication cost incurred by the optimal offline DSMS protocol equals the total weight of the forest $\mathcal{F}$ , that is, $W_{G}(\mathcal{F})$ (see (5)) since communication is synchronous. Suppose that there is a $c$ -competitive online DSMS protocol that solves the instance $I$ . The cost incurred by the online DSMS protocol is at most $c\cdot W_{G}(\mathcal{F})$ . However, the total cost incurred by the online distributed $k$ -server protocol generated by our reduction on the set of requests $\mathcal{R}$ is $\operatorname{O}\bigl{(}c\cdot D\cdot W_{G}(\mathcal{F})\bigr{)}$ where $D$ is the ratio between the cost to move a server and the cost to transmit a message over the same distance in synchronous networks. Note that $c\cdot W_{G}(\mathcal{F})$ is the maximum total weight of the resulted forest by the online protocol. Therefore, $c\cdot D\cdot W_{G}(\mathcal{F})$ is the maximum total movement cost of all servers of the online protocol. On the other hand, the total cost incurred by an optimal offline protocol for the distributed $k$ -server problem is $\Omega\big{(}D\cdot W_{G}(\mathcal{F})\big{)}$ . Consequently, the claim of the theorem holds using also the lower bound of $k$ [MMS88]. ∎

Appendix A Minimum Spanning Forest Approximation

In the following, we prove a generic result about spanning forests of a weighted graph $G=(V,E,w)$ , and let $\mathcal{F}$ denote a forest that spans the nodes in $V$ . For any edge $e\in\mathcal{F}$ , let $w(e)$ denote the weight of the edge on $G$ . Further, assume that when removing $e$ from $\mathcal{F}$ , the node sets of the resulting $(m+1)$ ( $m>0$ ) connected components are $V_{e^{1}},\ldots,V_{e,m+1}$ . Let $(V_{e^{1}},\ldots,V_{e,m+1})$ be the $(m+1)$ -cut induced by removing $e$ from $\mathcal{F}$ . If $m=1$ , Theorem A.1 in particular implies the following result about a spanning tree $T$ of a weighted graph $G$ . If for every edge $e\in T$ , and every edge $e^{*}$ over the cut induced by $T$ when removing $e$ from $T$ it holds that $w(e^{*})\geq w(e)/\lambda$ , then the total weight of $T$ is within a factor $\lambda$ of the total weight of a minimum spanning tree (MST) of $G$ .

Theorem A.1.

Let $\lambda\geq 1$ , $m\geq 1$ , and $G=(V,E,w)$ be a weighted connected graph with non-negative edge weights $w(e)\geq 0$ . Further, let $S\subseteq V$ , $|S|\leq m$ and let $\mathcal{F}$ and $\mathcal{F}^{*}$ be two arbitrary $S$ -respecting spanning $m$ -forests of $G$ . Further assume that for every pair $(e,e^{*})$ of edges $e\in\mathcal{F}$ and $e^{*}\in\mathcal{F}^{*}$ such that $\mathcal{F}\setminus\left\{e\right\}\cup\left\{e^{*}\right\}$ is an $S$ -respecting spanning $m$ -forest of $G$ , it holds that $w(e^{*})\geq w(e)/\lambda$ . Then, the total weight of all edges of $\mathcal{F}$ is at most $\lambda$ times the total weight of the edges of $\mathcal{F}^{*}$ .

Proof.

For an edge set $F\subseteq E$ , we use $W(F)$ to denote the total weight of the edges in $F$ . We prove the stronger statement that

[TABLE]

We show (20) by induction on $|\mathcal{F}\setminus\mathcal{F}^{*}|=|\mathcal{F}^{*}\setminus\mathcal{F}|$ . First note that if $|\mathcal{F}\setminus\mathcal{F}^{*}|=0$ , we have $\mathcal{F}=\mathcal{F}^{*}$ and thus (20) is clearly true. Further, if $|\mathcal{F}\setminus\mathcal{F}^{*}|=1$ , there is exactly one edge $e\in\mathcal{F}\setminus\mathcal{F}^{*}$ and exactly one edge $e^{*}\in\mathcal{F}^{*}\setminus\mathcal{F}$ . We therefore have $\mathcal{F}^{*}=\mathcal{F}\setminus\left\{e\right\}\cup\left\{e^{*}\right\}$ and by the assumptions of the theorem we have $w(e)\leq\lambda\cdot w(e^{*})$ , implying (20).

Let us therefore assume that $|\mathcal{F}\setminus\mathcal{F}^{*}|=\gamma\geq 2$ and let $e$ be a maximum weight edge of $\mathcal{F}\setminus\mathcal{F}^{*}$ . Let $(V_{e^{1}},\ldots,V_{e,m+1})$ be the $(m+1)$ -cut induced by removing $e$ from $\mathcal{F}$ . Let $\mathcal{F}^{\prime}$ be a spanning forest of $G$ that is obtained by removing $e$ from $\mathcal{F}$ and by adding some edge $e^{*}\in\mathcal{F}^{*}\setminus\mathcal{F}$ that connects two components $V_{e,i}$ and $V_{e,j}$ where $1\leq i\neq j\leq m+1$ such that $\mathcal{F}^{\prime}$ is an $S$ -respecting $m$ -forest. Note that such an edge $e^{*}$ must exist for the following reason. Let $s:=|S|$ , $s\leq m$ be the size of $S$ , let $V_{e,i_{1}}\dots,V_{e,i_{s}}$ be components of $\mathcal{F}\setminus\mathcal{F}^{*}$ that contain some node of $S$ , and let $V^{\prime}:=\bigcup_{j=1}^{s}V_{e,i_{j}}$ . The number of edges of $\mathcal{F}$ that connect two nodes in $V^{\prime}$ is exactly $|V^{\prime}|-s$ and because $\mathcal{F}^{*}$ is also $S$ -respecting, the number of edges of $\mathcal{F}^{*}$ that connect two nodes in $V^{\prime}$ is at most $|V^{\prime}|-s$ . Further, note that $e\in\mathcal{F}\setminus\mathcal{F}^{*}$ contains at least one node $v\not\in V^{\prime}$ . Hence, since $\mathcal{F}\setminus\left\{e\right\}$ has $m+1$ components and $\mathcal{F}^{*}$ has only $m$ components, $\mathcal{F}^{*}\setminus\mathcal{F}$ must contain at least one edge $e^{*}$ that connects two components of $\mathcal{F}\setminus\left\{e\right\}$ , where at most one of those components is contained in $V^{\prime}$ . When choosing this edge $e^{*}$ , $\mathcal{F}\setminus\left\{e\right\}\cup\left\{e^{*}\right\}$ is an $S$ -respecting spanning $m$ -forest of $G$ .

By the assumptions of the theorem, we have $w(e)\leq\lambda\cdot w(e^{*})$ . To prove (20), it thus suffices to show that $W(\mathcal{F}^{\prime}\setminus\mathcal{F}^{*})\leq\lambda\cdot W(\mathcal{F}^{*}\setminus\mathcal{F}^{\prime})$ . We have $|\mathcal{F}^{\prime}\setminus\mathcal{F}^{*}|=\gamma-1$ and thus, if the spanning forest $\mathcal{F}^{\prime}$ satisfies the conditions of the theorem, $W(\mathcal{F}^{\prime}\setminus\mathcal{F}^{*})\leq\lambda\cdot W(\mathcal{F}^{*}\setminus\mathcal{F}^{\prime})$ and (20) follows from the induction hypothesis. We therefore need to show that $\mathcal{F}^{\prime}$ satisfies the conditions of the theorem. That is, we need to show that for every edge $e^{\prime}\in\mathcal{F}^{\prime}\setminus\mathcal{F}^{*}$ and for every edge $\hat{e}^{*}\in\mathcal{F}^{*}\setminus\mathcal{F}^{\prime}$ such that $\mathcal{F}^{\prime}\setminus\left\{e^{\prime}\right\}\cup\left\{\hat{e}^{*}\right\}$ is an $S$ -respecting spanning $m$ -forest, it holds that $w(\hat{e}^{*})\geq w(e^{\prime})/\lambda$ .

Let us therefore consider such a pair of edges $e^{\prime}\in\mathcal{F}^{\prime}\setminus\mathcal{F}^{*}$ and $\hat{e}^{*}\in\mathcal{F}^{*}\setminus\mathcal{F}^{\prime}$ such that $\mathcal{F}^{\prime}\setminus\left\{e^{\prime}\right\}\cup\left\{\hat{e}^{*}\right\}$ is an $S$ -respecting spanning $m$ -forest. We make a case distinction on whether $\hat{e}^{*}$ connects two nodes of inside a single component of $\mathcal{F}\setminus\left\{e\right\}$ or whether $\hat{e}^{*}$ connects two components of $\mathcal{F}\setminus\left\{e\right\}$ .

•

Let us first assume that $\hat{e}^{*}$ connects two nodes $u$ and $v$ inside a single component $V_{e,i}$ of $\mathcal{F}\setminus\left\{e\right\}$ . In this case, the edge $e^{\prime}$ must connect two nodes $u^{\prime}$ and $v^{\prime}$ of the same component $V_{e,i}$ . As a consequence, $\mathcal{F}\setminus\left\{e^{\prime}\right\}\cup\left\{\hat{e}^{*}\right\}$ is a spanning $m$ -forest of $G$ , which has the same component structure as $\mathcal{F}^{\prime}$ . Hence, $\mathcal{F}\setminus\left\{e^{\prime}\right\}\cup\left\{\hat{e}^{*}\right\}$ is an $S$ -respecting spanning $m$ -forest and the assumptions of the theorem thus imply that $w(\hat{e}^{*})\geq w(e^{\prime})/\lambda$ .

•

Let us now assume that $\hat{e}^{*}$ connects two nodes $u$ an $v$ of different components $V_{e,i}$ and $V_{e,j}$ of $\mathcal{F}\setminus\left\{e\right\}$ . If both components $V_{e,i}$ and $V_{e,j}$ contain a node of $S$ , the edge $e^{\prime}$ must either connect two nodes in $V_{e,i}$ or two nodes in $V_{e,j}$ and we again have that $\mathcal{F}\setminus\left\{e^{\prime}\right\}\cup\left\{\hat{e}^{*}\right\}$ is an $S$ -respecting spanning $m$ -forest. Hence, the assumptions of the theorem again imply that $w(\hat{e}^{*})\geq w(e^{\prime})/\lambda$ .

It thus remains to consider the case where at most one of the components $V_{e,i}$ and $V_{e,j}$ contains a node of $S$ . However, in this case, we can get an $S$ -respecting $m$ -forest by considering the tree $\mathcal{F}\setminus\left\{e\right\}\cup\left\{\hat{e}^{*}\right\}$ and the assumptions of the theorem yield that $w(\hat{e}^{*})\geq w(e)/\lambda$ . This implies that $w(\hat{e}^{*})\geq w(e^{\prime})/\lambda$ because we assumed that $e$ is a maximum weight edge of $\mathcal{F}\setminus\mathcal{F}^{*}$ and thus $w(e)\geq w(e^{\prime})$ .∎

Bibliography23

The reference list from the paper itself. Each links out to its DOI / PubMed record.

1[AGGP 17] Y. Azar, A. Ganesh, R. Ge, and D. Panigrahi. Online service with delay. In STOC , 2017.
2[AGM 10] H. Attiya, V. Gramoli, and A. Milani. A provably starvation-free distributed directory protocol. In SSS , 2010.
3[AKRS 92] N. Alon, G. Kalai, M. Ricklin, and L. Stockmeyer. Lower bounds on the competitive ratio for mobile user tracking and distributed job scheduling. In FOCS , 1992.
4[AP 95] B. Awerbuch and D. Peleg. Online tracking of mobile users. Journal of the ACM , 1995.
5[Bar 96] Y. Bartal. Probabilistic approximations of metric spaces and its algorithmic applications. In FOCS , 1996.
6[BBMN 11] N. Bansal, N. Buchbinder, A. Madry, and J. S. Naor. A polylogarithmic-competitive algorithm for the k-server problem. In FOCS , 2011.
7[BFR 92] Y. Bartal, A. Fiat, and Y. Rabani. Competitive algorithms for distributed data management. In STOC , 1992.
8[BKS 18] M. Bienkowski, A. Kraska, and P. Schmidt. Online service with delay on a line. In SIROCCO , 2018.

TL;DR

Contribution

Findings

Abstract

Peer Reviews

Videos

Concurrent Distributed Serving with Mobile Servers111This work is supported by the Deutsche Forschungsgemeinschaft (DFG), under grant DFG

Abstract

1 Introduction

1.1 Our Contribution

Theorem 1.1**.**

Theorem 1.2**.**

Theorem 1.3**.**

Corollary 1.4**.**

Theorem 1.5**.**

1.2 Further Related Work

2 Model, Problem Statement, and Preliminaries

2.1 Communication Model

2.2 Distributed Serving with Mobile Servers (DSMS) Problem

2.3 Preliminaries

2.4 Hierarchically Well-Separated Trees (HSTs)

Definition 2.1** (α\alphaα-HST**).

3 The Distributed GNN Protocol

3.1 Description of GNN

3.2 Correctness of GNN

3.2.1 Scheduling Guarantee

Theorem 3.1**.**

Lemma 3.2**.**

Proof.

Lemma 3.3**.**

Proof.

Lemma 3.4**.**

Proof.

Lemma 3.5**.**

Proof.

Proof of Theorem 3.1.

3.2.2 Serving Guarantee

Theorem 3.6**.**

Lemma 3.7**.**

Proof.

Proof of Theorem 3.6.

Proof of Theorem 1.1.

4 Analysis in a Nutshell

Definition 4.1** (SSS-Respecting mmm-Forest**).

Theorem 4.1**.**

4.1 Optimality of GNN on HSTs

Lemma 4.2**.**

Lemma 4.3**.**

Proof.

Lemma 4.4**.**

Theorem 4.5**.**

5 Analysis

5.1 Optimal Distributed DSMS Protocols

Remark 5.1**.**

Remark 5.2**.**

5.2 Optimal Distributed DSMS Protocols on HSTs

Lemma 5.1**.**

Proof.

Lemma 5.2**.**

Proof.

Proof of Theorem 4.1.

5.3 Optimality of GNN on HSTs

5.3.1 Transforming FGNN\mathcal{F}_{GNN}FGNN​

Lemma 5.3**.**

Proof.

Lemma 5.4**.**

Proof.

Lemma 5.5**.**

Proof.

Lemma 5.6**.**

Proof.

Corollary 5.7**.**

Proof.

Lemma 5.8**.**

Proof.

Lemma 5.9**.**

Proof.

Corollary 5.10**.**

Proof.

Lemma 5.11**.**

Theorem 1.1.

Theorem 1.2.

Theorem 1.3.

Corollary 1.4.

Theorem 1.5.

Definition 2.1 ( $\alpha$ -HST).

Theorem 3.1.

Lemma 3.2.

Lemma 3.3.

Lemma 3.4.

Lemma 3.5.

Theorem 3.6.

Lemma 3.7.

Definition 4.1 ( $S$ -Respecting $m$ -Forest).

Theorem 4.1.

Lemma 4.2.

Lemma 4.3.

Lemma 4.4.

Theorem 4.5.

Remark 5.1.

Remark 5.2.

Lemma 5.1.

Lemma 5.2.

5.3.1 Transforming $\mathcal{F}_{GNN}$

Lemma 5.3.

Lemma 5.4.

Lemma 5.5.

Lemma 5.6.

Corollary 5.7.

Lemma 5.8.

Lemma 5.9.

Corollary 5.10.

Lemma 5.11.

Remark 5.3.

Remark 5.4.

Corollary 5.12.

Corollary 5.13.

Remark 5.5.

Lemma 5.14.

Lemma 5.15.

Lemma 5.16.

Lemma 5.17.

Theorem 5.18.

Theorem A.1.