Toward Self-Adjusting k-ary Search Tree Networks

TL;DR

This paper introduces self-adjusting k-ary search tree networks that optimize datacenter topologies by balancing reconfiguration costs and traffic patterns, improving routing efficiency and adaptability over existing binary search tree networks.

Contribution

It presents the first development of self-adjusting k-ary tree networks, including algorithms for offline optimal and online dynamic reconfigurations, with experimental validation against SplayNets.

Findings

Outperforms SplayNet on most real network traces

Achieves near-optimal static networks in linear time for uniform traffic

Provides a scalable approach for dynamic topology reconfiguration

Abstract

Datacenter networks are becoming increasingly flexible with the incorporation of new networking technologies, such as optical circuit switches. These technologies allow for programmable network topologies that can be reconfigured to better serve network traffic, thus enabling a trade-off between the benefits (i.e., shorter routes) and costs of reconfigurations (i.e., overhead). Self-Adjusting Networks (SANs) aim at addressing this trade-off by exploiting patterns in network traffic, both when it is revealed piecewise (online dynamic topologies) or known in advance (offline static topologies). In this paper, we take the first steps toward Self-Adjusting k-ary tree networks. These are more powerful generalizations of existing binary search tree networks (like SplayNets), which have been at the core of SAN designs. k-ary search tree networks are a natural generalization offering nodes of higher degrees, reduced route lengths for a fixed number of nodes, and local routing in spite of reconfigurations. We first compute an offline (optimal) static network for arbitrary traffic patterns in $O(n^3 \cdot k)$ time via dynamic programming, and also improve the bound to $O(n^2 \cdot k)$ for the special case of uniformly distributed traffic. Then, we present a centroid-based topology of the network that can be used both in the offline static and the online setting. In the offline uniform-workload case, we construct this quasi-optimal network in linear time $O(n)$ and, finally, we present online self-adjusting k-ary search tree versions of SplayNet. We evaluate experimentally our new structure for $k=2$ (allowing for a comparison with existing SplayNets) on real and synthetic network traces. Our results show that this approach works better than SplayNet in most of the real network traces and in average to low locality synthetic traces, and is only little inferior to SplayNet in all remaining traces.

Equations

$$\mathrm{TotalDistance}(D,T)=\sum _{(u,v)\in [n]\times [n]}{d}_T(u,v)\cdot D[u,v],$$

$$\{\begin{array}{l}dp[i][j][1]=\underset{r\in [i,j]}{\min }\underset{d_l+d_r\le k}{\min }dp[i][r-1][d_l]+dp[r+1][j][d_r]+W[i,j]\\ dp[i][j][t]=\underset{l\in [i,j-1]}{\min }dp[i][l][1]+dp[l+1][j][t-1],t>1\end{array}$$

$$(1+|V(S_{11})|+\sum _{i=2}^k|V(S_{1i})|)\cdot (|V(R)|+|V(S_2)|+\sum _{i=3}^k|V(S_j)|),$$

$$(1+|V(S_2)|+\sum _{i=2}^k|V(S_{1i})|)\cdot (|V(R)|+|V(S_{11})|+\sum _{i=3}^k|V(S_i)|).$$

$$(|V(S_{11})|-|V(S_2)|)\cdot (|V(R)|+\sum _{i=3}^k|V(S_i)|-\sum _{i=2}^k|V(S_{1i})|-1),$$

$${\Delta }_1:=\sum _{w\in V(S)}{d}_G(u,w)-\sum _{w\in V(S)}{d}_G(v,w).$$

$${\Delta }_2:=\sum _{w\in V(T)}{d}_G(v,w)-\sum _{w\in V(T)}{d}_G(u,w).$$

$${\Delta }_3:=\sum _{w\in V(R)}{d}_G(u,w)-\sum _{w\in V(R)}{d}_G(v,w).$$

$${\Delta }_3=(h_2-h_1)\cdot |V(R)|\ge (h_2-h_1)\cdot (9k-1)(|V(T)|+|V(S)|)>8k|V(T)|$$

$$\sum _{w\in V(T)}{d}_G(v,w)=\sum _{i=1}^{h_2}\left(|V(T_i)|\cdot (h_1+i+1)+TDR(T_i)\right)$$

$$\sum _{w\in V(T)}{d}_G(u,w)=\sum _{i=1}^{h_2}\left(|V(T_i)|\cdot (h_2-i+1)+TDR(T_i)\right)$$

$${\Delta }_2$$

$$=-(2(h_2-1)+h_1-h_2)+\sum _{i=1}^{h_2+1}|V(T_i)|(2i+h_1-h_2)$$

$$=-(h_2+h_1-2)+(h_1-h_2)\sum _{i=1}^{h_2+1}|V(T_i)|+2\sum _{i=1}^{h_2+1}i\cdot |V(T_i)|$$

$$=-(h_2+h_1-2)+|V(T)|(h_1-h_2)+2\sum _{i=1}^{h_2+1}i\cdot |V(T_i)|$$

$$\le 1-|V(T)|+2\sum _{i=1}^{h_2+1}i\cdot |V(T_i)|\le 2\sum _{i=1}^{h_2+1}i\cdot |V(T_i)|$$

$$|V(T_i)|$$

$$=1+(k-1)\cdot \frac{k^{h_2-i+1}-1}{k-1}$$

$$=k^{h_2-i+1}$$

$$k|V(T)|\ge k(1+k+\dots +k^{h_2-1})=\frac{k^{h_2+1}-1}{k-1}-1>\frac{k^{h_2+1}-1}{k-1},$$

$${\Delta }_2\le 2k^{h_2+1}\sum _{i=1}^{h_2+1}\frac{i}{k^i}\le 2k^{h_2+1}\frac{k}{(k-1{)}^2}=2\frac{k^{h_2+1}-1}{k-1}\cdot \frac{k}{k-1}+\frac{2k}{(k-1{)}^2}\le \frac{2k}{k-1}k|V(T)|+4\le 8k|V(T)|$$

Full text

In this paper, we take the first steps toward Self-Adjusting $k$-ary tree networks. These are more powerful generalizations of existing binary search tree networks (like SplayNets), which have been at the core of SAN designs. $k$-ary search tree networks are a natural generalization offering nodes of higher degrees, reduced route lengths for a fixed number of nodes, and local routing in spite of reconfigurations. We first compute an offline (optimal) static network for arbitrary traffic patterns in $\mathcal{O}(n^{3}\cdot k)$ time via dynamic programming, and also improve the bound to $\mathcal{O}(n^{2}\cdot k)$ for the special case of uniformly distributed traffic. Then, we present a centroid-based topology of the network that can be used both in the offline static and the online setting. In the offline uniform-workload case, we construct this quasi-optimal network in linear time $\mathcal{O}(n)$ and, finally, we present online self-adjusting $k$-ary search tree versions of SplayNet. We evaluate experimentally our new structure for $k=2$ (allowing for a comparison with existing SplayNets) on real and synthetic network traces. Our results show that this approach works better than SplayNet in most of the real network traces and in average to low locality synthetic traces, and is only little inferior to SplayNet in all remaining traces.

1 Introduction

With more services being offloaded to the cloud and the ever increasing numbers of connected devices to the internet, inter- and intra-datacenter traffic follows a clearly increasing trend. Therefore, datacenter network design has been attracting a lot of attention. Traditional datacenter network designs are static and perform well only under certain workloads. However, datacenter traffic follows patterns which can be exploited in the design of more efficient networks. It has been shown that a small fraction of network nodes accounts for a large fraction of traffic, the traffic distribution is sparse, and it exhibits locality features which change over time [3].

As a result, dynamic network topologies have emerged. Supported by advances in networking hardware (e.g., optical circuit switches or even experimental designs as in [8]), physical network topologies now have the ability to self-adjust. That is, the physical network topology is now programmable and can be manipulated to serve traffic more efficiently. Interestingly, leading cloud providers have already attempted to incorporate dynamic networks into their datacenters [12] (and previously [8]).

This flexibility provided by networking hardware raises an optimization challenge: how can we use it in the best possible way to get more efficient networks? There is a trade-off between the cost of changing the network topology (reconfiguration cost) and the benefit of reducing the distance of frequently communicating nodes (routing cost). In the online case, where future communication demand is unknown and only revealed piecewise, we would opt for topology updates that will pay off in the future. In the offline case, we aim at computing an optimal network topology with low time complexity.

The developing field of Self-Adjusting Networks (SANs) aims to address these optimization challenges. SANs often assume a family of allowed topologies, e.g., lists, trees, skip lists, etc., within which the network has to remain. This restriction is not only practically motivated (e.g., optical switches are of bounded degree), but also simplifies algorithm design and allows for theoretical performance guarantees. Specifically, self-adjusting tree networks have been at the core of SAN designs. SplayNet [13], a self-adjusting binary search tree network generalizing splay trees [15], was the first proposed SAN. SplayNet has been extended to ReNet [6], a static optimal SAN for sparse communication patterns, but also to a distributed version, DiSplayNet [11].

In this work, we take the first step to generalize to $k$-ary search tree networks, since they provide higher node degrees, shorter routes than binary search trees (BSTs) for a fixed number of nodes, and local (and greedy) routing regardless of reconfigurations. We present offline static and online self-adjusting networks and evaluate our newly proposed heuristic for SANs experimentally.

Contributions. We present offline static and online self-adjusting $k$-ary search tree networks.

1. We construct an optimal static $k$-ary tree network in $O(n^{3}\cdot k)$ time using dynamic programming. We then reduce the complexity to $O(n^{2}\cdot k)$ for the special case of uniformly distributed traffic. This case is non-trivial, since the topology is not restricted to perfectly balanced trees.

2. We present a $k$-ary tree network which is built by $k+1$ trees with almost equal size connected around at most two centroid nodes. We first present a linear offline algorithm for optimally constructing the static version of this topology for uniformly distributed traffic. We then present two online self-adjusting variants: $k$-ary SplayNet which is the direct generalization of SplayNet and $(k+1)$-SplayNet which is obtained by applying the found centroid heuristic. We experimentally evaluate them for $k=2$ (BST network) with synthetic network traces and real ones from datacenter traffic. We compare 3-SplayNet to SplayNet, and to static demand aware and oblivious trees. The results show that our SAN performs better than SplayNet in most real network traces and in synthetic ones that have average to low temporal locality, while its performance is similar to SplayNet for the remaining datasets.

**Related work. ** Self-Adjusting Networks were introduced with SplayNet [13]. SplayNet is a binary search tree network that generalizes Splay Trees [15]. SplayNet uses the tree rotations of splay trees to reduce the distance of communicating nodes to 1. The same paper presents a dynamic programming algorithm for computing an optimal binary search tree network when the demand is known, among other results. SANs were further surveyed and classified in [5]. The authors present a classification of network topologies, which depends on whether they are (i) oblivious or aware to traffic patterns, (ii) fixed or reconfigurable, and (iii) aware of the input sequence of communication requests (offline, online, generated by a distribution). This taxonomy allows for optimizing for certain properties according to each case, e.g. diameter or competitive ratio.

Tree-based SANs were further studied following SplayNet, possibly due to being more easy to analyze and deploy. ReNets [6] are bounded-degree SANs based on combining ego-trees, which are trees where the source is a node and the leaves are the communicated destinations. In this design, ego-trees are stars or splay trees, depending on the number of destinations. ReNets achieve desirable optimality properties (static optimality) for sparse communication patterns. Ego-trees were further studied in the form of self-adjusting single-source tree networks in [4, 2], which provided a number of constant competitive (dynamically optimal) randomized and deterministic algorithms with good experimental performance. SplayNet has also been the basis of distributed tree SANs [11, 10]. All the results mentioned above are for binary tree networks. SANs that are not tree-based have also been studied but are not related to our work.

2 Model

We consider a network of $n$ nodes $V=\{1,\ldots,n\}$ and a finite or infinite communication sequence $\sigma=(\sigma_{1},\sigma_{2},\ldots)$, where $\sigma_{t}=(u,v)\in V^{2}$ is a communication request from source $u$ to destination $v$. The network topology $G$ must be chosen from a family of desired topologies $\mathcal{G}$, for example, search trees, expander graphs, etc. Each topology $G\in\mathcal{G}$ is a graph $G=(V,E)$. The routing cost of $\sigma_{t}$ is given by the distance between the two endpoints in the topology the network has when serving the request. The topology can be reconfigured between requests with a cost equal to the number of links (edges) added or removed. The total service cost of $\sigma$ is the sum of routing and reconfiguration costs. Our goal is to serve the communication sequence with minimum total cost.

We distinguish two problem variants. In the offline static variant, $\sigma$ is known but no reconfigurations occur. We have to build a network with topology $G_{static}\in\mathcal{G}$ that does not change during or in between requests. Such a graph $G_{static}$ needs to optimize the total cost function $sumCost(\text{static},G_{static},\sigma)=\sum_{i=1}^{m}l_{i}$, where $l_{i}$ is the distance between the communication endpoints of $\sigma_{i}$ in $G_{static}$ and $m$ is the size of $\sigma$. In the online self-adjusting variant we assume that we can change the network after each request. We are provided with an arbitrary initial network (before the first request arrives), which we denote by $G_{0}\in\mathcal{G}$. Our task is to build an online algorithm $\mathcal{A}$ that adjusts the network at every time instant $G_{i}$, $i=1,\ldots,m$, and minimizes the total cost, which is calculated as $sumCost(\mathcal{A},G_{0},\sigma)=\sum_{i=1}^{m}\left(routingCost(G_{i-1},\sigma_{i})\right.$ $+$ $adjustmentCost(G_{i-1}$, $\left.G_{i})\right)$, where $routingCost(G_{i-1},\sigma_{i})$ is the path length in edges of $G_{i-1}$ to process request $\sigma_{i}$ and $adjustmentCost(G_{i-1},G_{i})$ is the adjustment cost to reconfigure the network from step $i-1$, $G_{i-1}\in\mathcal{G}$, to step $i$, $G_{i}\in\mathcal{G}$. Note that $\mathcal{A}$ may choose to perform no reconfigurations.

This paper focuses on both problems in a setting where the set of topologies $\mathcal{G}$ is the set of $k$-ary search trees. These trees are the generalization of binary search trees, which were investigated in [13] in the context of SANs. The main advantage of search tree networks is that we can route locally: given a destination identifier (or address), each node can decide locally to which neighbor to forward the packet. This is particularly useful in the online setting, as routing tables do need to be updated upon reconfiguration. With increasing $k$, route lengths decrease and node degree increases.

Definition 1

A $k$-ary Search Tree is a rooted tree on keys $1,\ldots,n$ with each node storing a key and having at most $k$ children. In each node, children are ordered and maintain the following property: for every two children $u$ and $v$, if $u<v$, then all the keys in a subtree of $u$ are smaller than all the keys in a subtree of $v$.

The local transformations of search tree networks are called rotations. A rotation in a $k$-ary search tree changes up to $k$ adjacency relationships, while keeping subtrees intact and maintaining the search property (Definition 1). Such rotations can be implemented in a different manner, for example, as done by Sherk [14]. Note that it is possible to transform any $k$-ary search tree into any other $k$-ary search tree by a sequence of local transformations.

3 Optimal static $k$-ary search tree networks

In this section we construct optimal $k$-ary search tree networks via dynamic programming. We present the case of generic traffic patterns in Section 3.1, which has cubic time complexity $\mathcal{O}(n^{3}\cdot k)$. Then, in Section 3.2 we drop the complexity to quadratic $\mathcal{O}(n^{2}\cdot k)$ for the special case of uniformly distributed traffic. Note that we are not restricted to balanced trees, thus the constructing the optimal network in the latter case is non-trivial.

3.1 Algorithm for arbitrary traffic patterns

In our first result we construct an optimal (offline) static $k$-ary search tree network. We are given a number $n$ and a demand matrix $D\in\mathbb{N}_{0}^{n\times n}$ that shows the total number of requests between $u$ and $v$. We have to find a $k$-ary Search Tree $T$ on $n$ vertices that minimizes the total distance:

[TABLE]

where $d_{T}(u,v)$ is the distance between nodes $u$ and $v$ in the tree $T$. It is convenient to think about this problem in terms of edge potentials.

Definition 2

Given a demand matrix $D\in\mathbb{N}_{0}^{n\times n}$ and a tree $T$ on $n$ vertices the potential of an edge $e\in E(T)$ is $\mathrm{potential}(D,T,e)=\sum\limits_{(u,v)\in\mathrm{passThrough}(T,e)}D[u,v]$, where $\mathrm{passThrough}(T,e)$ is a set of pairs $(u,v)\in[n]\times[n]$ such that the shortest path connecting $u$ and $v$ in $T$ passes through $e$. Note that since this is a tree, the shortest path is unique.

By their definitions, the total distance can be expressed using the potentials as follows: $\mathrm{TotalDistance}(D,T)=\sum\limits_{e\in E(T)}\mathrm{potential}(D,T,e).$ Now, we present the required algorithm.

Theorem 3.1

The construction of an offline static $k$-ary Search Tree network, i.e. one with minimal total distance given the requests in advance, can be solved in $O(n^{3}k)$.

Proof

Our algorithm uses the dynamic programming approach. Throughout the proof, if we are talking about the segment $[i,j]$, we assume that $i\leq j$. For a segment $[i,j]$,we denote a submatrix of $D[i\ldots j,i\ldots j]$ as $D|_{[i,j]}$. We define $\mathbb{N}_{0}^{n\times n}$ matrix $W$ such that $W[i,j]=\sum\limits_{u\in[n]\setminus[i,j]}\sum\limits_{v\in[i,j]}D[u,v]+D[v,u]$. $W[i,j]$ intuitively means a total number of requests going out of the segment $[i,j]$.

Claim

There exists an algorithm that computes $W$ in $O(n^{3})$ time.

Proof

We express $W[i,j]$ in terms of forward and backward functions. Namely for each pair of nodes $(u,v),\ u<v$ we define $F[u,v]=\sum\limits_{w=v}^{n}D[u,w]+D[w,u].$ In other words, it calculates the number of requests from $u$ to $[v,n]$. Analogously, we define for each pair of nodes $(u,v),\ v<u$, $B[u,v]=\sum\limits_{w=1}^{v}D[u,w]+D[w,u]$. In other words, it calculates the number of requests from $u$ to $[1,v]$. The whole prefix function $F[u,\cdot]$ can be computed in $O(n)$. First, we compute $F[u,u+1]$ by the definition. Then, $F[u,v]$ for $v>u+1$ is computed as $F[u,v-1]-D[u,v]-D[v,u]$. Symmetrically, $B[u]$ can be computed in $O(n)$. Thus, both $F$ and $B$ can be precomputed in $O(n^{2})$. Now, we can compute $W[i,j]$ in $O(n)$ using prefix functions $F$ and $B$ in the following manner: $W[i,j]=\sum\limits_{u\in[i,j]}F[u,j+1]+B[u,i-1]$, i.e., for each node $u$ in the segment we calculate the number of requests to the left out of the segment and the number of requests to the right out of the segment. Thus, we computed $W$ in $O(n^{3})$.

We define a target $\mathrm{cost}$ of a segment $[i,j]$ as the cost of the optimal $k$-ary Search Tree build on that segment plus the number of requests going out of that segment calculated in $W$: $\mathrm{cost}(i,j)=\min\limits_{T}\mathrm{TotalDistance}(D|_{[i,j]},T)+W[i,j]$. Now, finally we can define our dynamic programming $dp$ for $1\leq i\leq j\leq n$ and $1\leq t\leq k$ as $dp[i][j][t]=\min\limits_{i=i_{1}<i_{2}<\ldots<i_{t+1}=j+1}\sum\limits_{p=1}^{t}cost(i_{p},i_{p+1}-1)$.

Intuitively, $dp[i][j][t]$ means the minimal cost of partitioning a segment $[i,j]$ into $t$ children that are $k$-ary search trees. We can compute $dp$ by using the following equalities:

[TABLE]

The logic is that in order to partition the segment into $t>1$ trees one should first choose the prefix subsegment for the first tree and build $t-1$ trees on the remaining segment.

The case $t=1$ is special. It means that we want to build a single search tree on this segment. In order to do so, we first choose the root node $r\in[i,j]$ and after that the number of children $d_{l}$ to the left of a root node $[i,r-1]$ and a number of children $d_{r}$ to the right of a root node $[r+1,j]$. This covers all the possible cases. And in each case we can optimize each subtree out of $d_{l}+d_{r}$ independently, which equal to the corresponding $dp$ value. Finally, we have to add the number of requests that passes an edge from $r$ to the parent which is $W[i,j]$ — which is the potential of that edge.

When calculating $dp[i][j][t]$ we refer to the answer on subsegments of $[i,j]$, so we make sure that this value is already calculated by processing segments increasing their length. Namely, we start by setting the answer on the segments of length $1$, and, then, proceed by considering all the segments of length $2$, then $3$, and so on, up to $n$.

We need to consider all the possible segments: there are $O(n^{2})$ of them. For each segment we calculate dynamic for $t\in[1,k]$. When $i,j$ and $t>1$ are fixed, we spend $O(n)$ time iterating over $[i,j]$ looking for a minimum. This results in $O(n^{2}(k-1)n)$ in total. And when $i,j$ and $t=1$ are fixed, we spend $O(n)$ considering different roots and $O(k^{2})$ possibilities of distributing number of subtrees to the left and to the right of the root. So, in this case we obtain $O(n^{3}k^{2})$.

It is possible to reduce the complexity by $k$. For that we introduce $dp_{2}[i][j][x]=\min\limits_{y\leq x}dp[i][j][y]$. If we can calculate that, then we don’t have to iterate over all pairs $d_{l}$ and $d_{r}$. Now, for $t=1$ case, we need to find $\min\limits_{d_{l}+d_{r}=k}dp_{2}[i][r-1][d_{l}]+dp_{2}[r+1][j][d_{r}]$. It gives $O(n^{3}k)$ in total. $dp_{2}$ can be easily computed in the desired time.

3.2 Algorithm for uniformly distributed traffic

In this section we improve the cubic complexity proven in Section 3.1 for the special case of uniform workloads. A uniform workload is an infinite workload where each pair of nodes is requested uniformly at random. Our goal is to find a static $k$-ary search tree that responds to an infinite uniform workload as fast as possible, i.e., the expectation of the cost of each query is minimal. To simplify the analysis we consider a finite version of this workload. Note that a finite and a normal uniform workload are the same in terms of expected values of query costs. A finite uniform workload is a workload where each pair of nodes is requested exactly once. Note that we are interested in constructing an optimal and not necessarily a full $k$-ary search tree network; the latter if trivial in uniform workloads, but the former is not. Specifically, we show that in the uniform workload case the pipeline of the dynamic programming from Theorem 3.1 can be updated to have $O(n^{2}k)$ complexity.

Claim

In the uniform workload scenario, $W[i,i-1+l]=W[j,j-1+l]$ for any $l\in[1,n]$ and any $i,j\in[1,n-l]$. In other words, $W$ of the segment depends only on its length, not position. Moreover, $W[i,j]$ can be computed in $O(1)$.

Proof

Recall that intuitively $W[i,j]$ indicates the number of requests going out of the segment $[i,j]$. Since each node within the segment communicates exactly once with each node outside the segment, then $W[i,i-1+l]=l\ldots(n-l)$.

Claim

In the uniform workload scenario, $cost(i,i-1+l)=cost(j,j-1+l)$ for any $l\in[1,n]$ and any $i,j\in[1,n-l]$. In other words, the cost of the segment depends only on its length, not its position.

Proof

Recall that $\mathrm{cost}(i,j)=\min\limits_{T}\mathrm{TotalDistance}(D|_{[i,j]},T)+W[i,j]$. By the Claim 3.2 the second term is equal for any two segments of an equal length. As for the first term, it is also equal since $D|_{[i,i-1+l]}=D|_{[j,j-1+l]}$ for all $i,j,l$ in the uniform case.

By Claim 3.2, we can simplify our $dp$ from three parameters $dp[i][j][t]$ to two $dp[l][t]$, where $l$ now signifies the length of the segment. By that we reduce the dynamic programming by one dimension, and, hence, we get rid of $n$ in the complexity, resulting in $O(n^{2}k)$.

4 Centroid $k$-ary search tree networks

In this section we present offline static and online self-adjusting $k$-ary search tree networks. In this context, we propose a topology with a centroid node and $k+1$ trees connected around it. We first study the offline static case and present a construction of the proposed topology in $O(k\cdot n)$ (Section 4.1). Then we present online heuristics in Section 4.2 and experimentally evaluate it for the case of $k=2$ in Section 6.

4.1 Quasi-optimal static $k$-ary search tree network in $O(n)$

In a finite uniform workload a potential from Definition 2 of an edge connecting two subtrees $S$ and $T$ is equal to $|V(S)|\cdot|V(T)|$. A $k$-ary search tree is weakly-complete when all its levels are fully filled (i.e., each node has $k$ children) except for the last level. Nodes on the last level can be distributed arbitrarily. The height of a tree is the length of the path in edges from the root to the nodes on the last non-empty level.

Definition 3

A quasi-optimal tree of degree $k+1$ is a rooted tree with the root having $k+1$ weakly-complete $k$-ary trees. All the levels of the whole tree are fully filled except possibly the last one. We can change the relative positions of subtrees such that the leaves on the last level are all grouped together to the left. The tree is shown of Figure 1.

Though for the proof purposes it is more convenient to look at the quasi-optimal tree as rooted at the vertex with $k+1$ children described in the definition, we accentuate the fact that that tree is still a $k$-ary tree if we root it at an (arbitrary) leaf.

Definition 4

Consider two neighbouring weakly-complete subtrees. A push-up operation moves a leaf from the last level of one tree to the last level of another.

Lemma 1

Assume that we do a push-up operation in the tree $G$ from the weakly-complete subtree $T$ of height $h_{2}$ to a weakly-complete sibling subtree $S$ of height $h_{1}$ ($h_{2}>h_{1}$ where $h_{1}$ is calculated after moving the node and $h_{2}$ is calculated before moving the node). Assuming $|V(T)|+|V(S)|\leq\frac{n}{9k}$, the total distance for uniform workload decreases.

In the proof of this lemma we just move the node and calculate the cost. We present the proof in Appendix.

Corollary 1

For each subtree $S$ of an optimal tree $T$ if $|V(S)|\leq\frac{|V(T)|}{9k}$ then $S$ is a weakly-complete tree.

Proof

We prove this statement by the induction on the height of $S$.

At first, we prove the base. If $S$ is of height $2$, then all of its subtrees are either empty or of height $1$ or [math] and, thus, they are weakly-complete. Suppose that $S$ is not weakly-complete. Thus, we deduce that there is a subtree of height $1$ and an empty subtree, so we can perform a push up operation improving the total distance which contradicts the optimality of $T$.

So, now, we may assume by the inductive hypothesis that all the subtrees of $S$ are weakly-complete.

Suppose that $S$ is not weakly-complete. By the induction hypothesis, there are two subtrees of $S$ such that we can perform a push-up operation between them decreasing the total cost which contradicts the optimality of $T$.

Corollary 2

Assume that we do a push-up operation from the weakly-complete subtree $T$ of height $h_{2}$ to a weakly-complete sibling subtree $S$ of height $h_{1}$ ($h_{1}<h_{2}$, where $h_{1}$ is calculated after moving the node and $h_{2}$ is calculated before moving the node). The total distance increases by $O(kn)$.

Proof

Using the notation of Lemma 1, after the push-up operation the total distance increases by at most $\Delta_{2}$ which according to Claim 0.A is $\leq 8k|V(T)|=O(k\cdot n)$

Definition 5

Centroid of a tree $T$ is a node $c\in V(T)$ such that when removed, $T$ will be split into $m$ subtrees $T_{1},\ldots,T_{m}$ with $|V(T_{i})|\leq\frac{|V(T)|}{2}$ for all $i$. The centroid decomposition is represented by $\{c\}\cup\{T_{1},\ldots,T_{m}\}$.

Claim (Jordan [9])

Any tree has a centroid decomposition.

Assume we know the optimal tree $T$ of size $n$ to serve uniform requests. We make a centroid decomposition of it obtaining a centroid $C$ and $k+1$ trees $T_{1},T_{2},\ldots T_{k+1}$. ($T_{i}$ could be empty.) From now on we assume that $T$ is rooted at $C$.

Lemma 2

If we root an optimal tree $T$ at its centroid, then, for each subtree $S$ its centroid is either a root of $S$ or a child of a root.

Proof

Denote the root of $S$ as $r$.

If all subtrees of $r$ have size $\leq\frac{|V(S)|}{2}$, then $r$ is a centroid of $T$ and the statement holds.

Denote the subtrees of $r$ as $S_{1},\ldots,S_{k}$.

If $r$ is not a centroid, one of $S_{j}$ is bigger than $\frac{|V(S)|}{2}$. Suppose, for simplicity, it is $S_{1}$. We now prove that the root of $S_{1}$ is a centroid of $S$.

Denote the root of $S_{1}$ as $r_{1}$ and its subtrees as $S_{11},\ldots,S_{1k}$. The visualisation for the lemma is presented in Figure 3.

Assume $r_{1}$ is not a centroid. Then, it means that either $\left(\bigcup\limits_{i\in[2,\ldots,k]}S_{i}\right)\cup r$ is bigger than $\frac{|V(S)|}{2}$ or $S_{1j}$ is bigger than $\frac{|V(S)|}{2}$ for some $j\in[1,\ldots,k]$.

• •

Suppose that $\left(\bigcup\limits_{i\in[2,\ldots,k]}S_{i}\right)\cup r$ is bigger than $\frac{|V(S)|}{2}$. This is impossible since we already know that $|V(S_{1})|>\frac{|V(S)|}{2}$.

• •

$S_{1i}$ is bigger than $\frac{|V(S)|}{2}$ for some $i\in[1,\ldots,k]$. Suppose, for simplicity, this tree is $S_{11}$.

Now, we are going to prove that if we swap $S_{11}$ with any of $S_{i}$, say $S_{2}$ to be certain, the total cost will decrease.

We refer to the total cost expressed in terms of edge potentials. Note that the potential for the edges within $S_{i},S_{ij}$ and $R$ does not change. Neither does it change for the edges going out of $S_{i}$ and $S_{ij}$. So, the only change is in the potential of $(r_{1},r)$ edge.

The old value for its potential is

[TABLE]

while the new one is

[TABLE]

Now we calculate the difference between the potentials:

[TABLE]

which is positive since: 1) $|V(S_{11})|>|V(S_{2})|$; and 2) due to the fact that $C$ is a centroid we know that $|V(R)|$ is bigger than the half of the tree, or in other words: $|V(R)|\geq\frac{n}{2}>\sum\limits_{i=2}^{k}|V(S_{1i})|+1$

So we can only have two possibilities for the inner structure of each subtree of an optimal tree (rooted at its centroid).

Corollary 3

If we root an optimal tree $T$ at its centroid, then $|V(S)|\leq\frac{|V(T)|}{2^{h}}$ holds for each subtree $S$ at level $2h$.

Proof

We prove this statement by the induction.

The statement holds for $h=0$.

Consider a subtree $Q$ at level $2\cdot(h+1)$ and a tree $P$ rooted at a grandparent of a root of $Q$. By Lemma 2, $|V(Q)|\leq\frac{|V(P)|}{2}$ which by induction hypothesis $\leq\frac{|V(T)|}{2^{h}\cdot 2}=\frac{|V(T)|}{2^{h+1}}$

Combining Corollary 1 and Corollary 3, we obtain that each subtree of an optimal tree at level $\geq 2\lceil\log_{2}(9k)\rceil$ must be weakly-complete.

Lemma 3

If there are two neighbouring subtrees of the same height both having their last level not empty and not full, the total distance can be decreased.

This lemma is also proved straightforwardly. We suggest the opposite and try to move nodes in between subtrees. We calculate the difference and show that the total cost decreases. The formal proof appears in Appendix.

Remark 1

If a tree $T$ has all its levels filled except possibly the last one, and there are no two neighbouring subtrees of the same height both having their last level not empty and not full, then, we can change the order on the children of each node of $T$, so, that all the leaves of the last level are placed as left as possible, one by one.

Proof

We prove this statement by an induction on the height. If the tree has height one, we simply can make the “leftmost” numbering on the non-empty children. Now, we discuss the case when the tree has height $h>1$. By the statement of the remark, there can be at most one child of a root with its last level not fully filled and not empty. By the induction hypothesis, we assume that its leaves on the last level are placed as “left” as possible. We now order the sons of the root in the following manner. First, we add the subtrees which have their last level full from left to right. Note, that they can be in arbitrary order. Then, we place the subtree with the last level not full and not empty (it might not exists, but if it exists, there is only one such subtree). By the induction statement, all its leaves are at the left. Finally, we place the subtrees which have their last level empty, in arbitrary order. We got exactly the “leftmost” position of leaves.

Theorem 4.1

The difference in the total distance between an optimal tree $T$ and the quasi-optimal tree is $O(n^{2}k\log k)$.

Proof

Our plan is to reconfigure $T$ into the quasi-optimal tree while controlling the increase of the total distance.

We push-up some nodes to ensure that all the subtrees at level $l$ are weakly-complete starting from $l=2\lceil\log_{2}(9k)\rceil$ and up to $l=0$ (the whole tree).

Suppose we want to make a subtree $S$ at level $l$ weakly-complete. Since we go through levels decreasingly, we can argue that all the subtrees of $S$ are already weakly-complete (this holds for $l=2\lceil\log_{2}(9k)\rceil$).

If $S$ is not weakly-complete, it means that there are two subtrees of $S$ with height difference at least $2$. So, we take the subtree with the biggest height and the subtree with the smallest height and perform a push-up operation between them.

We act in this manner until there are two subtrees of height difference $\geq 2$. Once there are none, we say that $S$ is weakly-complete by definition.

When processing certain level, each node is moved at most once (in its subtree), so each node is moved no more then $2\lceil\log_{2}(9k)\rceil$ times, thus, by Corollary 2, the total cost change is $O(n^{2}k\log k)$: at most $n$ nodes move $O(\log k)$ times each increases by $O(nk)$.

And the last step would be to reshuffle leaves on the last level, so they are as far left as possible, so we get a quasi-optimal tree.

Assume there are two neighbouring subtrees such that their last level is not empty and not full. By Lemma 3, we can decrease the cost by moving leaves from the smaller subtree to the bigger one.

We perform those movements until our tree is quasi-optimal.

Theorem 4.2

Assuming $k$ is a constant, the total distance in optimal tree $T$ is $\Omega(n^{2}\log n)$.

Proof

We root tree $T$ by its centroid $C$. At least two subtrees of $T$, $T_{i}$ and $T_{j}$, have at least $\frac{n}{2k}$ nodes. Otherwise, $C$ is not the centroid. Each such $T_{i}$ has $\Omega(n)$ nodes at levels $\geq\log_{k}n-2$. Thus, the total pairwise distance between these nodes is $\Omega(n^{2}\log n)$.

Theorem 4.3

The quasi-optimal tree can be built in $O(n)$.

Remark 2

By Theorem 4.1 we know that the quasi-optimal tree differs from the optimal by $O(n^{2})$ (considering $k$ constant). Since, in the uniform workload there are $O(n^{2})$ requests, thus, in total we add just a constant to the cost of each request.

Remark 3

In our experiments, we found that quasi-optimal tree is indeed optimal for all $n$ less than $10^{3}$.

4.2 Online self-adjusting $k$-ary search tree networks

We present two online heuristics. The first one is the $k$-ary SplayNet which is the self-adjusting version of $k$-ary search tree and direct generalization of SplayNet [13]. In this new structure, we use splay operations for $k$-ary search trees proposed by Sherk [14]. Upon serving a request between two nodes, we $k$-splay them to their lowest common ancestor.

We also propose $(k+1)$-SplayNet, a centroid-based structure, which is the online equivalent of Section 4.1. The topology is presented in Figure 6. We split the nodes in $k+1$ parts and specify two nodes-centroids: $c_{1}$ and $c_{2}$ (centroid decomposition) which have subtrees of size $(n-2)/(k+1)$. Centroid $c_{1}$ has $k-1$ children except for $c_{2}$ that are $k$-ary SplayNets of size $[(n-2)/(k+1)]/(k-1)$. Centroid $c_{2}$ is the rightmost centroid. $c_{2}$ has $k$ $k$-ary SplayNets of size $(n-2)/(k+1)$ as children. When we want to serve a request $(u,v)$ we $k$-splay $u$ and $v$ to their lowest common ancestor, as was done in SplayNet. However, we never move nodes $c_{1}$ and $c_{2}$. That is, upon requests originating in different subtrees of $c_{1}$ and $c_{2}$, we splay the endpoints to their subtree roots, such that $c_{1}$ and $c_{2}$. The sets of nodes in the $2k-1$ subtrees remain intact, but these trees can self-adjust.

4.3 A case study for $k=2$

We study the two online heuristics experimentally for the case of $k=2$. The $k$-ary SplayNet is the standard SplayNet for $k=2$, which we compare to the centroid-based 3-SplayNet. We implemented it and run against standard SplayNet on different workloads. As a result, it appears that on workloads with low temporal complexity $3$-SplayNet works better than SplayNet.

Setup and data

The code for the algorithms was written in C++ and Python. We have three types of experiments: on the uniform workload with $100$ nodes, on the synthetic workloads with $1023$ nodes and different temporal complexities [3] ($0.25$, $0.5$, $0.75$, $0.9$), and on the data from three real-world datasets: a high performance computing (HPC) workload [7], a workload on ProjectToR [8], and a synthetic pFabric (pFab) [1] workload. We restrict all datasets to $10^{6}$ requests on: uniform workload with $100$ nodes, HPC with $500$ nodes, ProjectToR with $100$ nodes, and Facebook with $100$ nodes.

We run these workloads on four different structures: static full binary search tree (green), static optimal binary search tree (purple), 3-SplayNet (red), and SplayNet (blue). All our plots show the average cost of requests after serving the first $x$ requests.

Results

On the plots, we show the average cost of the requests on different data sets; lower costs are better. We observe that 3-SplayNet performs better or similarly to SplayNet on average and low temporal complexity workloads (0.25 and 0.5), while on high temporal complexity workloads (0.75 and 0.9) it works a bit worse. Also, 3-SplayNet outperfors SplayNet for the uniform workload, and for the ProjecToR and Facebook workloads, but not for the HPC workload (higher locality than the other two real-world workloads). We interpret this as the effect of having fixed centroid nodes.

5 Conclusion and Future Work

We presented online and offline algorithms for self-adjusting $k$-ary search tree networks. Specifically, we presented dynamic programming algorithms for computing an optimal static network in generic and uniformly distributed traffic. We also presented an offline and online $k$-ary search tree network that has a centroid node and $k+1$ trees of almost equal size connected to it. Our experimental results show that for real and synthetic traces of average to low locality it outperforms SplayNet and that its performance is always close to the best out of the algorithms tested. We believe that our work paves the way to new SANs for $k$-ary search tree networks for general or specific traffic patterns.

Acknowledgements

This research was supported by the Austrian Science Fund (FWF), project I 4800-N (ADVISE), 2020-2023.

Appendix 0.A Proofs

Lemma 1

Assume that we do a push-up operation in the tree $G$ from the weakly-complete subtree $T$ of height $h_{2}$ to a weakly-complete sibling subtree $S$ of height $h_{1}$ ($h_{2}>h_{1}$ where $h_{1}$ is calculated after moving the node and $h_{2}$ is calculated before moving the node). Assuming $|V(T)|+|V(S)|\leq\frac{n}{9k}$, the total distance for uniform workload decreases.

Proof

Let a leaf $u$ of $T$ be the removed node and let a leaf $v$ of $S$ is where we place the moved node. The total distance is affected: all the terms with $u$, i.e., $d_{G}(u,x)$ terms, are removed and $n-1$ new terms $d_{G}(v,x)$ with $v$ are added, where $G$ is the whole tree. Let us denote the path from the root of $T$ to $u$: $\mathrm{root}=t_{1},t_{2},\ldots,t_{h_{2}+1}=u$. Let us also denote the subtree formed by $t_{i}$ and its child trees other than the one with $u$ as $T_{i}$. The same notation we use for the tree $S$ and the node $v$. You can see the tree at Figure 9. We define $R:=G\setminus(S\cup T)$.

Our goal now is to calculate the difference in the total distance after the push up operation. This difference consists of three parts:

We denote the change in the distance for nodes in $S$ ($v$ is closer to them than $u$):

[TABLE] 2. 2.

We denote the change in the distance for nodes in $T$ ($u$ is closer to some nodes than $v$, note that not all nodes in $T$ are closer to $u$ since $v$ has smaller depth):

[TABLE] 3. 3.

We denote the change in the distance for nodes in $R$ ($v$ is closer to them than $u$ since the depth of $v$ is smaller):

[TABLE]

Hence, the total distance is changed by $\Delta:=\Delta_{2}-\Delta_{1}-\Delta_{3}$. We want to prove that $\Delta$ is negative, thus, the total distance decreases when we move $u$ to $v$.

We can lower bound $\Delta_{3}$ easily:

[TABLE]

Let us now find an upper bound for $\Delta_{2}$. At first, we define the Total Distance to Root (or TDR) function for tree $W$ rooted at $r$ as $TDR(W)=\sum\limits_{v\in V(W)}d_{W}(v,r)$. We say that $T_{i}$ is rooted at $t_{i}$.

So, the total distance from $u$ and $v$ to the nodes of $T$ can be expressed in terms of this function TDR:

[TABLE]

The intuition behind those formulas is that in order to travel from $v$ to all the nodes in $T_{i}$ we first need to travel to its root $t_{i}$ which is at the distance $(h_{1}+i+1)$. We do it for each node, so $|V(T_{i})|$ times. And, then, we travel from the root of $T_{i}$ to a corresponding node, accumulating $TDR(T_{i})$ in total. The same is calculated for $u$ but the distance to $t_{i}$ decreases.

Thus,

[TABLE]

Each $T_{i}$ consists of root $t_{i}$ and not more than $k-1$ weakly-complete $k$-ary trees of height not exceeding $h_{2}-i$. Therefore,

[TABLE]

By that, we notice that

[TABLE]

Using this inequality, we can upper bound $\Delta_{2}$ further.

Claim

$\Delta_{2}\leq 8k|V(T)|$

Proof

[TABLE]

Recall that $\Delta_{3}>8k|V(T)|$ and $\Delta_{1}\geq 0$. So we obtain that $\Delta<0$.

Lemma 3

If there are two neighbouring subtrees of the same height both having their last level not empty and not full, the total distance can be decreased.

Proof

We consider two such subtrees with the smallest height, in a sense that they have all their leaves as far to the “left” as possible.

Suppose that in each subtree the last level contains at most $m$ leaves. The left subtree has $0<l<m$ leaves on its last layer and the right subtree has $0<r<m$ leaves on its last layer. Furthermore, we can assume that $r\leq l$. (The other way around is symmetrical)

We consider two cases: either $l+r\leq m$ (Fig. 11) or $l+r>m$ (Fig. 11).

• •

In the first case, $l+r\leq m$. Consider Figure 11. Leaves of the left tree are depicted green, leaves of the right tree are depicted blue. In this case we move all the leaves from the right tree to the right-most positions in the left tree.

• –

The total distance among blue leaves did not change.

• –

The total distance between blue leaves and the nodes outside considered trees did not change.

• –

The total distance between blue nodes and the right subtree (without leaves) is now equal to the total distance between blue nodes and the left subtree (without leaves). And vice versa.

• –

The total distance between blue nodes and green nodes is decreased.

• •

In the second case, $l+r>m$. Consider Figure 11. We move $m-l$ left-most leaves from the right tree to the left tree. Left-most $m-r$ leaves of the left tree are depicted green. Other leaves of the left tree are depicted yellow. Moved leaves of the right tree are depicted blue. Other leaves of the right tree ($r-(m-l)$ of them) are depicted red.

• –

The total distance among blue leaves did not change.

• –

The total distance between blue leaves and the nodes outside considered trees did not change.

• –

The total distance between blue nodes and the right subtree (without leaves) is now equal to the total distance between blue nodes and the left subtree (without leaves). And vice versa.

• –

The total distance between blue nodes and green nodes is decreased.

• –

The total distance between blue nodes and red nodes is now equal to the total distance between blue nodes an yellow nodes. And vice versa.