Upper Bounds on Number of Steals in Rooted Trees

TL;DR

This paper derives tight upper bounds on the number of work steals in parallel computations modeled by rooted trees, relevant for optimizing multithreaded processing efficiency.

Contribution

It provides a novel mathematical bound on steals in work stealing algorithms for rooted tree models, extending understanding of parallel computation limits.

Findings

Maximum steals are bounded by a sum involving binomial coefficients and tree parameters.

The bounds are tight for the specified rooted tree configurations.

Results inform optimal scheduling in parallel computing environments.

Abstract

Inspired by applications in parallel computing, we analyze the setting of work stealing in multithreaded computations. We obtain tight upper bounds on the number of steals when the computation can be modeled by rooted trees. In particular, we show that if the computation with $n$ processors starts with one processor having a complete $k$-ary tree of height $h$ (and the remaining $n-1$ processors having nothing), the maximum possible number of steals is $\sum_{i=1}^n(k-1)^i\binom{h}{i}$.

Equations

$$\left(\genfrac{}{}{0ex}{}{n}{k}\right)=\{\begin{array}{ll}\frac{n!}{k!(n-k)!}& \text{mbox}ifn\ge k\\ 0& \text{mbox}ifn<k.\end{array}$$

$$\left(\genfrac{}{}{0ex}{}{n}{k}\right)=\left(\genfrac{}{}{0ex}{}{n-1}{k}\right)+\left(\genfrac{}{}{0ex}{}{n-1}{k-1}\right)$$

$$\Phi (T,n)\ge 1+\Phi (T_l,n-1)+\Phi (T_r,n).$$

$$\Phi (T,n)\ge 1+\Phi (T_r,n-1)+\Phi (T_l,n).$$

$$\Phi (T,n)\ge 1+\max \{\Phi (T_l,n-1)+\Phi (T_r,n),\Phi (T_r,n-1)+\Phi (T_l,n)\}.$$

$$\Phi (T,n)=1+\max \{\Phi (T_l,n-1)+\Phi (T_r,n),\Phi (T_r,n-1)+\Phi (T_l,n)\}.$$

$$\Phi (T,n)\le 1+\max \{\Phi (T_l,n-1)+\Phi (T_r,n),\Phi (T_r,n-1)+\Phi (T_l,n)\},$$

$$\Phi (CBT(h),n)$$

$$=\sum _{i=1}^n\left(\genfrac{}{}{0ex}{}{h}{i}\right),$$

$$\Phi (CBT(0),n)=\sum _{i=1}^n\left(\genfrac{}{}{0ex}{}{0}{i}\right)=0.$$

$$\Phi (CBT(h),n)=1+\Phi (CBT(h-1),n-1)+\Phi (CBT(h-1),n).$$

$$\Phi (CBT(h),n)$$

$$=\left(\genfrac{}{}{0ex}{}{h-1}{0}\right)+\sum _{i=1}^{n-1}\left(\genfrac{}{}{0ex}{}{h-1}{i}\right)+\sum _{i=1}^n\left(\genfrac{}{}{0ex}{}{h-1}{i}\right)$$

$$=\sum _{i=1}^n\left(\left(\genfrac{}{}{0ex}{}{h-1}{i-1}\right)+\left(\genfrac{}{}{0ex}{}{h-1}{i}\right)\right)$$

$$=\sum _{i=1}^n\left(\genfrac{}{}{0ex}{}{h}{i}\right),$$

$$\Phi (CBT(h),n)=1+\Phi (CBT(h-1),n-1)+\Phi (CBT(h-1),n)$$

$$F(h,n)=F(h-1,n-1)+F(h-1,n),$$

$$\sum _{i=1}^n\left(\genfrac{}{}{0ex}{}{h}{i}\right)\le h^n$$

$$\left(\genfrac{}{}{0ex}{}{h}{i}\right)=\frac{h(h-1)\cdots (h-i+1)}{i!}\le h(h-1{)}^{i-1}$$

$$\Phi (ACT(b,k,h),n)=$$

$$+(b-1)\left(\left(\genfrac{}{}{0ex}{}{h}{0}\right)+(k-1)\left(\genfrac{}{}{0ex}{}{h}{1}\right)+\cdots +(k-1{)}^{n-1}(\genfrac{}{}{0ex}{}{h}{n-1})\right)$$

$$=$$

$$\Phi (ACT(1,k,h+1),n)=$$

$$=$$

$$+\cdots +(k-1{)}^n\left(\left(\genfrac{}{}{0ex}{}{h}{n-1}\right)+\left(\genfrac{}{}{0ex}{}{h}{n}\right)\right)$$

$$=$$

$$+(k-1)\left(\left(\genfrac{}{}{0ex}{}{h}{0}\right)+(k-1)\left(\genfrac{}{}{0ex}{}{h}{1}\right)+\cdots +(k-1{)}^{n-1}(\genfrac{}{}{0ex}{}{h}{n-1})\right)$$

$$=$$

$$\Phi (ACT(b,k,h),n)=1+\max \{A,B\},$$

$$A$$

$$=\left(\sum _{i=1}^n(k-1{)}^i(\genfrac{}{}{0ex}{}{h}{i})+(b-1)\sum _{i=0}^{n-1}(k-1{)}^i\left(\genfrac{}{}{0ex}{}{h}{i}\right)\right)-1$$

$$B$$

$$=A-(b-2)(k-1{)}^{n-1}(\genfrac{}{}{0ex}{}{h}{n-1})$$

$$\le A.$$

$$\Phi (ACT(b,k,h),n)$$

$$=\sum _{i=1}^n(k-1{)}^i(\genfrac{}{}{0ex}{}{h}{i})+(b-1)\sum _{i=0}^{n-1}(k-1{)}^i\left(\genfrac{}{}{0ex}{}{h}{i}\right),$$

$$\Phi (T_1,T_2,\dots ,T_P)\ge \Phi (T_{\sigma (1)},0)+\Phi (T_{\sigma (2)},1)+\cdots +\Phi (T_{\sigma (P)},P-1)$$

$$\Phi (T_1,T_2,\dots ,T_P)\ge \underset{\sigma \in S_P}{\max }\left(\Phi (T_{\sigma (1)},0)+\Phi (T_{\sigma (2)},1)+\cdots +\Phi (T_{\sigma (P)},P-1)\right),$$

Full text

1 Introduction

The two main scheduling paradigms that are commonly used for scheduling multithreaded computations are work sharing and work stealing. The two paradigms differ in how the threads are distributed. In work sharing, the scheduler migrates new threads to other processors so that underutilized processors have more work to do. In work stealing, on the other hand, underutilized processors attempt to “steal” threads from other processors. Intuitively, the migration of threads occurs more often in work sharing than in work stealing, since no thread migration occurs in work stealing when all processors have work to do, whereas a work-sharing scheduler always migrates threads regardless of the current utilization of the processors.

The idea of work stealing has been around at least as far back as the 1980s. Burton and Sleep’s work [4] on functional programs on a virtual tree of processors and Halstead’s work [7] on the implementation of Multilisp are among the first to outline the idea of work stealing. These authors point out the heuristic benefits of the work-stealing paradigm with regard to space and communication. Since then, several other researchers [1, 2, 6, 8, 10] have found applications of the work-stealing paradigm or analyzed the paradigm in new ways.

An important contribution to the literature of work stealing was made by Blumofe and Leiserson [3], who gave the first provably good work-stealing scheduler for multithreaded computations with dependencies. Their scheduler executes a fully strict (i.e., well-structured) multithreaded computations on $P$ processors within an expected time of $T_{1}/P+O(T_{\infty})$, where $T_{1}$ is the minimum serial execution time of the multithreaded computation (the work of the computation) and $T_{\infty}$ is the minimum execution time with an infinite number of processors (the span of the computation.) Furthermore, the scheduler has provably good bounds on total space and total communication in any execution.

This paper analyzes upper bounds on the number of steals in multithreaded computations. While the existing literature has dealt extensively with probabilistic and average-case analysis, it has not covered worst-case analysis on work stealing. We obtain tight upper bounds on the number of steals when the computation can be modeled by rooted trees. In particular, we show that if the computation with $n$ processors starts with one processor having a complete $k$-ary tree of height $h$ (and the remaining $n-1$ processors having nothing), the maximum possible number of steals is $\sum_{i=1}^{n}(k-1)^{i}\binom{h}{i}$.

The remainder of this paper is organized as follows. Section 2 introduces the setting that we will analyze throughout the paper. Section 3 introduces some notation that we will use later in the paper. Section 4 analyzes the case where at the beginning all the work is owned by one processor, and the computation tree is a binary tree. Section 5 generalizes Section 4 to the case where the computation tree is an arbitrary rooted tree. Section 6 generalizes Section 5 one step further and analyzes the case where at the beginning all processors could possibly own work. Finally, Section 7 concludes and suggests directions for future work.

2 Setting

This section introduces the setting that we will analyze throughout the paper. We describe the setting while keeping the mathematical core as our focus. Suksompong [9] provides more detail on the connection between this setting and the work-stealing paradigm.

Suppose that there are $P$ processors. Each processor owns some work, which we model as a computation tree. Throughout this paper, we assume that computation trees are rooted trees with no “singleton nodes” (i.e., nodes that have exactly one child.) At any point in the execution of work stealing, a processor is allowed to perform the following two-step operation:

Finish its own work, i.e., destroy its computation tree. 2. 2.

Pick another processor that currently owns a computation tree with more than one node, and “steal” from that processor.

We now describe how a steal proceeds. Suppose that processor $P_{2}$ steals from processor $P_{1}$, and assume that the root node of $P_{1}$ has $m$ children. If $m>2$, then $P_{2}$ steals the rightmost subtree, leaving the root node and the other $m-1$ subtrees of $P_{1}$ intact. If $m=2$, on the other hand, then $P_{2}$ steals the right subtree, leaving $P_{1}$ with the left subtree, while the root node disappears.

An example of a steal is shown in Figure 1. In this example, the root node has four children, and therefore the steal takes away the rightmost subtree and leaves the remaining three subtrees intact. This definition of stealing in rooted trees is not arbitrary. It is, in fact, the one commonly used in parallel computing.

The question that we analyze in this paper is as follows: Given any starting configuration of computation trees corresponding to the processors, what is the maximum possible number of steals that can occur in an execution of work stealing?

Before we begin our analysis on the number of steals, we consider an example of a complete execution of work stealing in Figure 2. There are two processors in this example, $P_{1}$ and $P_{2}$, and the initial computation trees corresponding to the two processors are shown in Figure 2(a). Three steals are performed, yielding the trees in Figures 2(b), 2(c), and 2(d) respectively. In this example, one can check that the maximum number of steals that can be performed in the execution is also 3.

3 Notation

This section introduces some notation that we will use later in the paper.

Binomial Coefficients

For positive integers $n$ and $k$, the binomial coefficient $\binom{n}{k}$ is defined as

[TABLE]

The binomial coefficients satisfy Pascal’s identity [5]

[TABLE]

for all integers $n,k\geq 1$. One can verify the identity directly using the definition.

Trees

Let $\mathit{EMPT}$ denote the empty tree with no nodes, and let $\mathit{TRIVT}$ denote the trivial tree with only one node.

For $h\geq 0$, let $\mathit{CBT}(h)$ denote the complete binary tree with height $h$. For instance, the tree $\mathit{CBT}(4)$ is shown in Figure 3.

For $k\geq 2,h\geq 0$, and $1\leq b\leq k-1$, let $\mathit{ACT}(b,k,h)$ denote the “almost complete” $k$-ary tree with $b\cdot k^{h}$ leaves. In particular, the root has $b$ children if $b\neq 1$ and $k$ children if $b=1$, and every other node has [math] or $k$ children. For instance, the tree $\mathit{ACT}(2,3,2)$ is shown in Figure 4. By definition, we have $\mathit{CBT}(h)=\mathit{ACT}(1,2,h)$. Also, the tree $\mathit{ACT}(b,k,h)$ is complete exactly when $b=1$.

For any tree $T$, denote by $|T|$ the size of the tree $T$, i.e., the number of nodes in $T$.

4 Binary Tree and One Starting Processor

In this section, we establish the upper bound on the number of steals in the case where at the beginning, all the work is owned by one processor, and the computation tree is a binary tree. We define a potential function to help with establishing the upper bound, and we derive a recurrence relation for the potential function. The recurrence directly yields an algorithm that computes the upper bound in time $O(|T|n)$. Finally, we show that the maximum number of steals that can occur if our configuration starts with the tree $\mathit{CBT}(h)$ is $\sum_{i=1}^{n}\binom{h}{i}$.

Recurrence

Suppose that we are given a configuration in which all processors but one start with an empty tree, while the exceptional processor starts with a tree $T$. How might a sequence of steals proceed? The first steal is fixed—it must split the tree $T$ into its left and right subtrees, $T_{l}$ and $T_{r}$. From there, one way to proceed is, in some sense, to be greedy. We obtain as many steals out of $T_{l}$ as we can, while keeping $T_{r}$ intact. As such, we have $P-1$ processors that we can use to perform steals on $T_{l}$, since the last processor must maintain $T_{r}$. Then, after we are done with $T_{l}$, we can perform steals on $T_{r}$ using all of our $P$ processors. This motivates the following definition.

Definition 1

Let $n\geq 0$ be an integer and $T$ a binary tree. The $n$th potential of $T$ is defined as the maximum number of steals that can be obtained from a configuration of $n+1$ processors, one of which has the tree $T$ and the remaining $n$ of which have empty trees. The $n$th potential of $T$ is denoted by $\Phi(T,n)$.

If we only have one processor to work with, we cannot perform any steals, hence $\Phi(T,0)=0$ for any tree $T$. Moreover, the empty tree $\mathit{EMPT}$ and the trivial tree with a single node $\mathit{TRIVT}$ cannot generate any steals, hence $\Phi(\mathit{EMPT},n)=\Phi(\mathit{TRIVT},n)=0$ for all $n\geq 0$.

In addition, the discussion leading up to the definition shows that if a binary tree $T$ has left subtree $T_{l}$ and right subtree $T_{r}$, then for any $n\geq 1$, we have

[TABLE]

By symmetry, we also have

[TABLE]

Combining the two inequalities yields

[TABLE]

In the next theorem, we show that this inequality is in fact always an equality.

Theorem 4.1

Let $T$ be a binary tree with at least 2 nodes, and let $T_{l}$ and $T_{r}$ be its left and right subtrees. Then for any $n\geq 1$, we have

[TABLE]

Proof

Since we have already shown that the left-hand side is no less than the right-hand side, it only remains to show the reverse inequality.

Suppose that we are given any sequence of steals performed on $T$ using $n$ processors. As we have noted before, the first steal is fixed—it must split the tree $T$ into its two subtrees, $T_{l}$ and $T_{r}$. Each of the subsequent steals is performed either on a subtree of $T_{l}$ or a subtree of $T_{r}$ (not necessarily the left or right subtrees of $T_{l}$ or $T_{r}$.) Assume for now that the last steal is performed on a subtree of $T_{r}$. That means that at any particular point in the stealing sequence, subtrees of $T_{l}$ occupy at most $n-1$ processors. (Subtrees of $T_{l}$ may have occupied all $n$ processors at different points in the stealing sequence, but that does not matter.) We can canonicalize the sequence of steals in such a way that the steals on subtrees of $T_{l}$ are performed first using $n-1$ processors, and then the steals on subtrees of $T_{r}$ are performed using $n$ processors. Therefore, in this case the total number of steals is at most $1+\Phi(T_{l},n-1)+\Phi(T_{r},n)$.

Similarly, if the last steal is performed on a subtree of $T_{l}$, then the total number of steals is at most $1+\Phi(T_{r},n-1)+\Phi(T_{l},n)$. Combining the two cases, we have

[TABLE]

which gives us the desired equality.

Algorithm

When combined with the base cases previously discussed, Theorem 4.1 gives us a recurrence that we can use to compute $\Phi(T,n)$ for any binary tree $T$ and any value of $n$. But how fast can we compute the potential? The next corollary addresses that question. Recall from Section 3 that $|T|$ denotes the size of the tree $T$.

Corollary 1

Let $T$ be a binary tree. There exists an algorithm that computes the potential $\Phi(T,n)$ in time $O(|T|n)$ and space $O(hn)$, where $h$ denotes the height of $T$.

Proof

The algorithm uses dynamic programming to compute $\Phi(T,n)$. For each subtree $T^{\prime}$ of $T$ and each value $0\leq i\leq n$, the algorithm computes $\Phi(T^{\prime},i)$ using the recurrence given in Theorem 4.1. There are $O(|T|n)$ subproblems to solve, and each subproblem takes $O(1)$ time to compute. Hence the running time is $O(|T|n)$.

To optimize space, we can traverse the tree using post-order traversal. Whenever we have computed the values $\Phi(T^{\prime},i)$ for two siblings, we use those values to compute $\Phi(T^{\prime},i)$ for the parent and subsequently delete the values for the siblings. One can check that at any stage, if we do not consider the tree whose root node we are currently traversing, then the trees $T^{\prime}$ for which we store the values $\Phi(T^{\prime},i)$ have root nodes that are of pairwise different depth from the root node of $T$. Hence we store at most $hn$ values at any stage, and the algorithm takes space $O(hn)$.

Complete Binary Trees

An interesting special case is when the initial tree $T$ is a complete binary tree, i.e., a full binary tree in which all leaves have the same depth and every parent has two children. Recall from Section 3 that $\mathit{CBT}(h)$ denotes the complete binary tree with height $h$. The next corollary establishes the potential of $\mathit{CBT}(h)$. Recall also from Section 3 that $\binom{a}{b}=0$ if $a<b$.

Corollary 2

We have

[TABLE]

Proof

The case $h=0$ holds, since

[TABLE]

The case $n=0$ holds similarly. Now suppose that $h,n>0$. Since the two subtrees of $\mathit{CBT}(h)$ are symmetric, the recurrence in Theorem 4.1 yields

[TABLE]

We proceed by induction. Suppose that the formula for the potential values hold for $\mathit{CBT}(h-1)$. Using Pascal’s identity (Equation 1), we have

[TABLE]

as desired.

We can write the recurrence

[TABLE]

in the form

[TABLE]

where $F(h,n)=\Phi(\mathit{CBT}(h),n)+1$. The recurrence equation of $F$ is the same as that of the binomial coefficients. On the other hand, the initial conditions of the two recurrences differ slightly. The initial conditions of the binomial coefficients are $\binom{h}{0}=1$ for all $h\geq 0$ and $\binom{0}{n}=0$ for all $n\geq 1$, while the initial conditions of $F$ are $F(h,0)=F(0,n)=1$ for all $h,n\geq 0$.

For fixed $n$, $\Phi(\mathit{CBT}(h),n)$ grows as $O(h^{n})$. Indeed, one can obtain the (loose) bound

[TABLE]

for $h,n\geq 2$, for example using the simple bound

[TABLE]

and then computing a geometric sum.

When $n\geq h$, Corollary 2 implies that $\Phi(\mathit{CBT}(h),n)=\sum_{i=1}^{n}\binom{h}{i}=2^{h}-1$. The quantity $2^{h}-1$ is 1 less than the number of leaves in a complete binary tree of height $h$. Hence, the bound is equivalent to the trivial upper bound that the number of steals is at most the number of tasks in the tree. It is worth noting that the condition $n\geq h$ might hold in many practical applications, and we would be stuck with this upper bound in such situations. For instance, if we process less than 1 billion tasks using at least 30 processors, the condition $n\geq h$ is fulfilled.

We have established the upper bound on the number of steals in the case where at the beginning, all the work is owned by one processor, and the computation tree is a binary tree. In the next sections we will generalize to configurations where the work can be spread out at the beginning and take the form of arbitrary rooted trees as well.

5 Rooted Tree and One Starting Processor

In this section, we consider a generalization of Section 4 to the configuration in which the starting tree is an arbitrary rooted tree. The key observation is that we can transform an arbitrary rooted tree into a “left-child right-sibling” binary tree that is equivalent to the rooted tree with respect to steals. With this transformation, an algorithm that computes the upper bound in time $O(|T|n)$ follows. Finally, we show that the maximum number of steals that can occur if our configuration starts with the tree $\mathit{ACT}(b,k,h)$ is $\sum_{i=1}^{n}(k-1)^{i}\binom{h}{i}+(b-1)\sum_{i=0}^{n-1}(k-1)^{i}\binom{h}{i}$.

Algorithm

The key to establishing the upper bound in the case of arbitrary rooted trees is to observe that the problem can in fact be reduced to the case of binary trees, which we have already settled in Section 4. We transform any rooted tree into a binary tree by transforming each node with more than two children into a left-child right-sibling binary tree [5]. The transformation of one such node with four children is shown in Figure 5.

A node with $k$ children is equivalent with respect to steals to a left-child right-sibling binary tree of height $k-1$. We show this fact for the setting in Figure 5; the proof for the general setting is similar. For both trees in Figure 5, the first steal takes subtree $T_{4}$ and leaves the tree containing subtrees $T_{1},T_{2}$, and $T_{3}$. The second steal takes subtree $T_{3}$ and leaves the tree containing subtrees $T_{1}$ and $T_{2}$. Finally, the third steal takes subtree $T_{2}$ and leaves subtree $T_{1}$.

Consequently, we can use the same algorithm as in the case of binary trees to compute the maximum number of successful steals, as the next theorem shows. Recall from Section 3 that $|T|$ denotes the size of the tree $T$.

Theorem 5.1

Let $T$ be a rooted tree. There exists an algorithm that computes the potential $\Phi(T,n)$ in time $O(|T|n)$ and space $O(hkn)$, where $h$ denotes the height of $T$, and $k$ the maximum number of children of any node in $T$.

Proof

We transform $T$ into a binary tree according to the discussion leading up to this theorem, and apply the algorithm described in Corollary 1. Even though the transformed tree can be larger than the original one, it is no more than twice as large. Indeed, transforming a node with $k>2$ children introduces $k-2$ extra nodes in the resulting binary tree.

The transformation takes time of order $|T|$, and the algorithm takes time of order $|T|n$. Since the transformed tree has height no more than $kn$, the algorithm takes space $O(hkn)$.

Complete $k$-ary Trees

As in our analysis of binary trees, an interesting special case is the case of complete $k$-ary trees, i.e., full $k$-ary trees in which all leaves have the same depth and every parent has $k$ children. Moreover, we determine the answer for almost complete $k$-ary trees. Recall from Section 3 that for $k\geq 2,h\geq 0$, and $1\leq b\leq k-1$, $\mathit{ACT}(b,k,h)$ denotes the almost complete $k$-ary tree with $b\cdot k^{h}$ leaves.

Theorem 5.2

For $k\geq 2,h\geq 0$, and $1\leq b\leq k-1$, we have

[TABLE]

Proof

We first show that the formula is consistent even if we allow the tree $\mathit{ACT}(1,k,h+1)$ to be written as $\mathit{ACT}(k,k,h)$ for $h\geq 0$. Indeed, we have

[TABLE]

where we used Pascal’s identity (Equation 1).

We proceed to prove the formula by induction on $b\cdot k^{h}$. The case $b\cdot k^{h}=1$ holds, since both the left-hand side and the right-hand side are zero. The case $n=0$ holds similarly. Consider the tree $\mathit{ACT}(b,k,h)$, where $b\cdot k^{h}>1$ and $2\leq b\leq k$. Using the consistency of the formula that we proved above, it is safe to represent any nontrivial tree in such form. Now, the recurrence in Theorem 4.1 yields

[TABLE]

where $A=\Phi(\mathit{ACT}(b-1,k,h),n)+\Phi(\mathit{ACT}(1,k,h),n-1)$ and $B=\Phi(\mathit{ACT}(b-1,k,h),n-1)+\Phi(\mathit{ACT}(1,k,h),n)$.

Using the induction hypothesis, we have

[TABLE]

and

[TABLE]

Therefore, we have

[TABLE]

as desired.

It is worth noting that the exponential factor $(k-1)^{i}$ becomes huge when $k>2$. Instead, if we were to convert a node with $k>2$ children into binary nodes forming a balanced binary tree, we would only have to replace the height $h$ of the tree by $h\log k$. It should not be surprising that a balanced binary tree yields a much better upper bound than a node with multiple children. Indeed, as we have shown, a node with $k>2$ children is equivalent to a left-child right-sibling binary tree, which is highly unbalanced. When the tree is highly unbalanced, it is possible that a large number of steals are generated if the execution of smaller subtrees always finishes before that of larger ones. When the tree is balanced, on the other hand, the execution is more likely to reach a point where every processor owns a relatively large tree, and the execution of one such tree has to finish before the next steal can be performed.

We have established the upper bound on the number of steals in the configuration with one processor having an arbitrary rooted tree at the beginning. In the next section, we generalize one step further by allowing any number of processors to own work at the beginning.

6 Rooted Tree and Multiple Starting Processors

In this section, we consider a generalization of Section 5 where the work is not limited to one processor at the beginning, but rather can be spread out as well. We derive a formula for computing the potential function of a configuration based on the potential function of the individual trees. This leads to an algorithm that computes the upper bound for the configuration with trees $T_{1},T_{2},\ldots,T_{P}$ in time $O(P^{3}+P(|T_{1}|+|T_{2}|+\cdots+|T_{P}|))$. We then show that for complete $k$-ary trees, we only need to sort the trees in order to compute the maximum number of steals. Since we can convert any rooted tree into a binary tree as described in Section 5, it suffices throughout this section to analyze the case in which all trees are binary trees.

Formula

Suppose that in our configuration, the $P$ processors start with trees $T_{1},T_{2},\ldots,T_{P}$. How might a sequence of steals proceed? As in our previous analysis of the case with one starting processor, we have an option of being greedy. We pick one tree—say $T_{1}$—and obtain as many steals as possible out of it using one processor. After we are done with $T_{1}$, we pick another tree—say $T_{2}$—and obtain as many steals as possible out of it using two processors. We proceed in this way until we pick the last tree—say $T_{P}$—and obtain as many steals out of it using all $P$ processors.

We make the following definition.

Definition 2

Let $T_{1},T_{2},\ldots,T_{n}$ be binary trees. Then $\Phi(T_{1},T_{2},\ldots,T_{n})$ is the maximum number of steals that we can get from a configuration of $n$ processors that start with the trees $T_{1},T_{2},\ldots,T_{n}$.

Note that we are overloading the potential function operator $\Phi$. Unlike the previous definition of $\Phi$, this definition does not explicitly include the number of processors, because this number is simply the number of trees included in the argument of $\Phi$. It follows from the definition that $\Phi(T_{1},T_{2},\ldots,T_{n})=\Phi(T_{\sigma(1)},T_{\sigma(2)},\ldots,T_{\sigma(n)})$ for all permutations $\sigma$ of $1,2,\ldots,n$.

From the discussion leading up to the definition, we have

[TABLE]

for any permutation $\sigma$ of $1,2,\ldots,P$. It immediately follows that

[TABLE]

where $S_{P}$ denotes the symmetric group of order $P$, i.e., the set of all permutations of $1,2,\ldots,P$.

The next theorem shows that this inequality is in fact an equality.

Theorem 6.1

Let $T_{1},T_{2},\ldots,T_{P}$ be binary trees. We have

[TABLE]

Proof

We have already shown that the left-hand side is no less than the right-hand side, hence it only remains to show the reverse inequality.

Suppose that we are given any sequence of steals performed on $T_{1},T_{2},\ldots,T_{P}$ using the $P$ processors. Each steal is performed on a subtree of one of the trees $T_{1},T_{2},\ldots,T_{P}$.

Assume without loss of generality that the last steal performed on a subtree of $T_{1}$ occurs before the last steal performed on a subtree of $T_{2}$, which occurs before the last steal performed on a subtree of $T_{3}$, and so on. That means that at any particular point in the stealing sequence, subtrees of $T_{i}$ occupy at most $i$ processors, for all $1\leq i\leq P$. (Subtrees of $T_{i}$ may have occupied a total of more than $i$ processors at different points in the stealing sequence, but that does not matter.) We can canonicalize the sequence of steals in such a way that all steals on subtrees of $T_{1}$ are performed first using one processor, then all steals on subtrees of $T_{2}$ are performed using two processors, and so on, until all steals on subtrees of $T_{P}$ are performed using $P$ processors. Therefore, in this case the total number of steals is no more than $\Phi(T_{1},0)+\Phi(T_{2},1)+\cdots+\Phi(T_{P},P-1)$.

In general, let $\sigma$ be the permutation of $1,2,\ldots,P$ such that the last steal performed on a subtree of $T_{\sigma(1)}$ occurs before the last steal performed on a subtree of $T_{\sigma(2)}$, which occurs before the last steal performed on a subtree of $T_{\sigma(3)}$, and so on. Then we have

[TABLE]

Therefore,

[TABLE]

which gives us the desired equality.

Algorithm

Now that we have a formula to compute $\Phi(T_{1},T_{2},\ldots,T_{P})$, we again ask how fast we can compute it. Recall from Section 3 that $|T|$ denotes the size of the tree $T$.

Corollary 3

There exists an algorithm that computes the potential $\Phi(T_{1},T_{2},\ldots,T_{P})$ in time $O(P^{3}+P(|T_{1}|+|T_{2}|+\cdots+|T_{P}|))$.

Proof

The potentials $\Phi(T_{i},j)$ can be precomputed by using dynamic programming in time $O(P(|T_{1}|+|T_{2}|+\cdots+|T_{P}|))$ using the algorithm in Corollary 1. It then remains to determine the maximum value of $\Phi(T_{\sigma(1)},0)+\Phi(T_{\sigma(2)},1)+\cdots+\Phi(T_{\sigma(P)},P-1)$ over all permutations $\sigma$ of $1,2,\ldots,P$. A brute-force solution that tries all possible permutations $\sigma$ of $1,2,\ldots,n$ takes time $O(P!)$. Nevertheless, our maximization problem is an instance of the assignment problem, which can be solved using the classical “Hungarian method”. The algorithm by Tomizawa [11] solves the assignment problem in time $O(P^{3})$. Hence, the total running time is $O(P^{3}+P(|T_{1}|+|T_{2}|+\cdots+|T_{P}|))$.

Complete Trees

It is interesting to ask whether we can do better than the algorithm in Corollary 3 in certain special cases. Again, we consider the case of complete trees. In this subsection we assume that the $P$ processors start with almost complete $k$-ary trees (defined in Section 3) for the same value of $k$.

Suppose that at the beginning of the execution of work stealing, the processors start with the trees $\mathit{ACT}(b_{1},k,h_{1}),\mathit{ACT}(b_{2},k,h_{2}),\ldots,\mathit{ACT}(b_{P},k,h_{P})$, where $1\leq b_{1},b_{2},\ldots,b_{P}\leq k-1$. We may assume without loss of generality that $b_{1}\cdot k^{h_{1}}\leq b_{2}\cdot k^{h_{2}}\leq\cdots\leq b_{P}\cdot k^{h_{P}}$. Intuitively, in order to generate the maximum number of successful steals, one might want to allow larger trees more processors to work with, because larger trees can generate more steals than smaller trees. It turns out that in the case of complete trees, this intuition always works, as is shown in the following theorem.

Theorem 6.2

Let $b_{1}\cdot k^{h_{1}}\leq b_{2}\cdot k^{h_{2}}\leq\cdots\leq b_{P}\cdot k^{h_{P}}$. We have

[TABLE]

Proof

We use the exchange argument: if the trees are not already ordered in increasing size, then there exist two consecutive positions $j$ and $j+1$ such that $b_{j}\cdot k^{h_{j}}>b_{j+1}\cdot k^{h_{j+1}}$. We show that we may exchange the positions of the two trees and increase the total potential in the process. Since we can always perform a finite number of exchanges to obtain the increasing order, and we know that the total potential increases with each exchange, we conclude that the maximum potential is obtained exactly when the trees are ordered in increasing size.

It only remains to show that any exchange of two trees $b_{j}\cdot k^{h_{j}}$ and $b_{j+1}\cdot k^{h_{j+1}}$ such that $b_{j}\cdot k^{h_{j}}>b_{j+1}\cdot k^{h_{j+1}}$ increases the potential. Denote the new potential after the exchange by $N$ and the old potential before the exchange by $O$. We would like to show that $N>O$. We have

[TABLE]

We consider two cases.

Case 1: $h_{j}=h_{j+1}$ and $b_{j}>b_{j+1}$.

We have

[TABLE]

since $b_{j}>b_{j+1}$.

Case 2: $h_{j}>h_{j+1}$.

We have

[TABLE]

since $h_{j}\geq h_{j+1}+1$.

In both cases, we have $N-O>0$, and hence any exchange increases the potential, as desired.

It follows from Theorem 6.2 and Corollary 3 that in the case of complete $k$-ary trees, one only needs to sort the trees with respect to their size in order to compute the potential. It follows that the running time of the algorithm is bounded by the running time of sorting, which is $O(P\lg P)$.

7 Conclusion and Future Work

In this paper, we have established tight upper bounds on the number of steals when the computation can be modeled by rooted trees. Here we suggest two possible directions for future work:

• •

This paper restricts the attention to computation trees. In general, however, computations need not be trees. How do the upper bounds generalize to the case where the computation can be modeled by directed acyclic graphs (DAG)?

• •

Consider a model in which executing each task requires a constant amount of time independent of the size of the computation trees. In this model, if no processor steals from a particular processor for a long enough period, that processor will finish executing its own tasks and can no longer be stolen from. Can we achieve tighter bounds in this model?

8 Note

The final publication is available at Springer via

http://dx.doi.org/10.1007/s00224-015-9613-9.