Data Races and the Discrete Resource-time Tradeoff Problem with Resource Reuse over Paths

TL;DR

This paper addresses optimizing resource allocation to eliminate data races in parallel programs by modeling the problem on DAGs, considering resource reuse, and providing approximation algorithms for NP-hard cases.

Contribution

It formulates a novel resource-time tradeoff problem with resource reuse on DAGs, proves its NP-hardness, and offers approximation algorithms and solutions for special cases.

Findings

The problem is strongly NP-hard for general DAGs.

Approximation algorithms are developed for the NP-hard problem.

A pseudo-polynomial time algorithm is provided for series-parallel DAGs.

Abstract

A determinacy race occurs if two or more logically parallel instructions access the same memory location and at least one of them tries to modify its content. Races often lead to nondeterministic and incorrect program behavior. A data race is a special case of a determinacy race which can be eliminated by associating a mutual-exclusion lock or allowing atomic accesses to the memory location. However, such solutions can reduce parallelism by serializing all accesses to that location. For associative and commutative updates, reducers allow parallel race-free updates at the expense of using some extra space. We ask the following question. Given a fixed budget of extra space to mitigate the cost of races in a parallel program, which memory locations should be assigned reducers and how should the space be distributed among the reducers in order to minimize the overall running time? We argue that the races can be captured by a directed acyclic graph (DAG), with nodes representing memory cells and arcs representing read-write dependencies between cells. We then formulate our optimization problem on DAGs. We concentrate on a variation of this problem where space reuse among reducers is allowed by routing extra space along a source to sink path of the DAG and using it in the construction of reducers along the path. We consider two reducers and the corresponding duration functions (i.e., reduction time as a function of space budget). We generalize our race-avoiding space-time tradeoff problem to a discrete resource-time tradeoff problem with general non-increasing duration functions and resource reuse over paths. For general DAGs, the offline problem is strongly NP-hard under all three duration functions, and we give approximation algorithms. We also prove hardness of approximation for the general resource-time tradeoff problem and give a pseudo-polynomial time algorithm for series-parallel DAGs.

Tables

Page Type	Page Numbers	#Pages
Title	1	1
Main Text	2, 4, 5, 7 – 10, 12, 15, 16	10
Figures	3, 6, 11, 13, 14, 17	6
Bibliography	18	1
Appendices	19 – 20	2

Table 2. Table 1. Our main results on resource-time tradeoff problems in which resources are routed along source to sink paths (i.e., related to Question 1.3 and its generalization).

Duration function	Hardness	Hardness of Approximation	Approximation Results
General non-increasing	strongly NP-hard	$\bullet$ makespan with resources fixed $\bullet$ resource with makespan fixed	$(\frac{1}{\alpha },\frac{1}{1-\alpha })$ bi-criteria (resource, makespan),
Recursive binary	strongly NP-hard	–	$\bullet$ makespan $\le 4\text{OPT}$ with resources fixed $\bullet$ $(\frac{4}{3},\frac{14}{5})$ bi-criteria (resource, makespan)
Multiway splitting	strongly NP-hard	–	makespan $\le 5\text{OPT}$ with resources fixed

Table 3. Table 2. Makespan at vertices C ( 5 ) superscript 𝐶 5 C^{(5)} , C ( 6 ) superscript 𝐶 6 C^{(6)} and C ( 7 ) superscript 𝐶 7 C^{(7)} for different truth value assignments to V i , V j subscript 𝑉 𝑖 subscript 𝑉 𝑗 V_{i},V_{j} and V k subscript 𝑉 𝑘 V_{k} in Figure 9 ( b ) 𝑏 (b) .

$V_i$	$V_j$	$V_k$	$C^{\left(5\right)}$	$C^{\left(6\right)}$	$C^{\left(7\right)}$
True	True	True	$max(1,1,0)=1$	$max(1,0,1)=1$	$max(0,1,1)=1$
False	True	True	$max(0,1,0)=1$	$max(0,0,1)=1$	$max(1,1,1)=1$
True	False	True	$max(1,0,0)=1$	$max(1,1,1)=1$	$max(0,0,1)=1$
True	True	False	$max(1,1,1)=1$	$max(1,0,0)=1$	$max(0,1,0)=1$
False	False	True	$max(0,0,0)=0$	$max(0,1,1)=1$	$max(1,0,1)=1$
False	True	False	$max(0,1,1)=1$	$max(0,0,0)=0$	$max(1,1,0)=1$
True	False	False	$max(1,0,1)=1$	$max(1,1,0)=1$	$max(0,0,0)=0$
False	False	False	$max(0,0,1)=1$	$max(0,1,0)=1$	$max(1,0,0)=1$

Table 4. Table 3. Earliest start time at vertices C ( 5 ) , C ( 6 ) superscript 𝐶 5 superscript 𝐶 6 C^{(5)},C^{(6)} and C ( 7 ) superscript 𝐶 7 C^{(7)} for different assignment of truth values of variable V i , V j subscript 𝑉 𝑖 subscript 𝑉 𝑗 V_{i},V_{j} and V k subscript 𝑉 𝑘 V_{k} in Figure  14 , where a = ( 6 ​ x + 4 ) 𝑎 6 𝑥 4 a=(6x+4) and b = ( 5 ​ x + 6 ) 𝑏 5 𝑥 6 b=(5x+6) .

$V_i$	$V_j$	$V_k$	$C^{\left(5\right)}$	$C^{\left(6\right)}$	$C^{\left(7\right)}$
T	T	T	$max(a,a+1,b)=a+1$	$max(a,b,a+1)=a+1$	$max(b,a,a+1)=a+1$
F	T	T	$max(b,a,b+1)=a$	$max(b,b+1,a)=a$	$max(a,a+1,a+2)=a+2$
T	F	T	$max(a,b,b+1)=a$	$max(a,a+1,a+2)=a+2$	$max(b,b+1,a)=a$
T	T	F	$max(a,a+1,a+2)=a+2$	$max(a,b,b+1)=a$	$max(b,a,b+1)=a$
F	F	T	$max(b,b+1,b+2)=b+2$	$max(b,a,a+1)=a+1$	$max(a,b,a+1)=a+1$
F	T	F	$max(b,a,a+1)=a+1$	$max(b,b+1,b+2)=b+2$	$max(a,a+1,b)=a+1$
T	F	F	$max(a,b,a+1)=a+1$	$max(a,a+1,b)=a+1$	$max(b,b+1,b+2)=b+2$
F	F	F	$max(b,b+1,a)=a$	$max(b,a,b+1)=a$	$max(a,b,b+1)=a$

Equations

$$t_v(r)=\{\begin{array}{ll}{t}_v(r_{v,i}),& \text{if}{r}_{v,i}\le r<r_{v,i+1},1\le i<l_v,\\ t_v(r_{v,l_v}).& \text{if}{r}_{v,l_v}\le r,\end{array}$$

$$t_v(r)=\{\begin{array}{ll}{t}_v(0),& \text{if}k\in \{0,1\}\\ \lceil t_v(0)/k\rceil +k,& \text{if}2\le k\le \lfloor \sqrt{t_v(0)}\rfloor \\ t_v(\lfloor \sqrt{t_v(0)}\rfloor ).& \text{if}\lfloor \sqrt{t_v(0)}\rfloor <k.\end{array}$$

$$t_v(r)=\{\begin{array}{ll}{t}_v(0),& \text{if}r=0,1\\ \lceil t_v(0)/2^i\rceil +i+1,& \text{if}r=2^i,2\le i\le k\\ t_v(2^i),& \text{if}{2}^i\le r<2^{i+1},2\le i\le k\\ t_v(2^k),& \text{if}i>k\end{array}$$

$$t_{(u,v)}(r)=\frac{t_{(u,v)}(0)}{r_{(u,v)}}r\text{ for }r\in [0,r_{(u,v)}]$$

$$t_{(u,v)}(r)=t_{(u,v)}(0)\text{ for all}r\ge 0$$

$$f_{(u,v)}\le r_{(u,v)}\text{ , }\forall (u,v)\text{ with two resource-time tuples.}$$

$$T_u+t_{u,v}(f_{(u,v)})\le T_v\text{ , }\forall (u,v)\in E$$

$$\sum _w{f}_{(v,w)}+\sum _u{f}_{(u,v)}=0\text{ , }\forall v\notin \{s,t\}$$

$$\sum _k{f}_{(s,k)}\le B$$

$$\min T_t$$

$$f_{(u,v)}\ge f_{(u,v)}^{{}^{\prime }}\text{ , }\forall (u,v)\in E$$

$$\sum _w{f}_{(v,w)}+\sum _u{f}_{(u,v)}=0\text{ , }\forall v\notin \{s,t\}$$

$$\min \sum _k{f}_{(s,k)}$$

$$\overline{r}=\{\begin{array}{ll}0,& \text{if}r<1\\ 2^i& \text{if}{2}^i\le r<(2^i+2^{i+1})/2,0\le i\le k\\ 2^{i+1},& \text{if}(2^i+2^{i+1})/2\le r<2^{i+1},0\le i\le k\end{array}$$

$$r$$

$$\frac{t_i}{\rho }\left(2/x+\sum _{j=1}^{i+1}\frac{2^j}{t_j}\right)\le 5\cdot (2^{i-1})\Rightarrow$$

$$\frac{t_i}{2^{i-2}x}+\sum _{j=1}^{i+1}\frac{t_i}{2^{i-j-1}{t}_j}=\frac{\lceil \frac{x}{2^i}\rceil +i+1}{x(2^{i-2})}+\sum _{j=1}^{i+1}\frac{\lceil \frac{x}{2^i}\rceil +i+1}{(\lceil \frac{x}{2^j}\rceil +j+1)2^{i-j-1}}$$

$$<\frac{\frac{x}{2^i}+i+2}{x(2^{i-2})}+\sum _{j=1}^{i+1}\frac{\frac{x}{2^i}+i+2}{(\frac{x}{2^j}+j+1)2^{i-j-1}}$$

$$=\frac{1}{2^i}\frac{1}{2^{i-2}}+\frac{i+2}{x(2^{i-2})}+\sum _{j=1}^{i+1}\frac{\frac{1}{2^{i-j}}(\frac{x}{2^j}+j+1)+i+2-\frac{j}{2^{i-j}}-\frac{1}{2^{i-j}}}{(\frac{x}{2^j}+j+1)2^{i-j-1}}$$

$$\le \left(\frac{i+2}{x}\frac{1}{2^{i-2}}+\sum _{j=1}^{i+1}\frac{i+2}{(\frac{x}{2^j}+j+1)2^{i-j-1}}\right)+\left(\frac{1}{2^i}\frac{1}{2^{i-2}}+\sum _{j=1}^{i+1}\frac{1}{2^{i-j}}\frac{1}{2^{i-j-1}}\right)$$

$$=\left(\frac{i+2}{x}\frac{1}{2^{i-2}}\right)+\left(\sum _{j=1}^{i+1}\frac{i+2}{(\frac{x}{2^j}+j+1)2^{i-j-1}}\right)+\left(\frac{32}{3}+\frac{1}{3}\frac{1}{4^{i-1}}\right)$$

$$A$$

$$B$$

$$<\sum _{j=1}^{i+1}\frac{1}{2^{i-j-1}}=2-\frac{1}{2^{i-2}}.$$

$$T(v,\lambda)=\begin{cases}\begin{tabular}[]{p{1.6in}l}$t_{j}(\lambda)$&if $v$ is a leaf\end{tabular}\\ \begin{tabular}[]{p{1.6in}l}$T(v_{1},\lambda)+T(v_{2},\lambda)$&\begin{tabular}[]{@{}l@{}}if $v$ is an internal\\ node with label ``$s$''\end{tabular}\end{tabular}\\ \begin{tabular}[]{p{1.6in}l}$min_{0\leq i\leq\lambda}\left\{max\left\{\begin{tabular}[]{@{}c@{}}$T(v_{1},i)$,\\ $T(v_{2},\lambda-i)$\end{tabular}\right\}\right\}$&\begin{tabular}[]{@{}l@{}}if $v$ is an internal\\ node with label ``$p$''\end{tabular}\end{tabular}\\ \end{cases}$$

Full text

We start by asking the following question. Given a fixed budget of extra space for mitigating the cost of races in a parallel program, which memory locations should be assigned reducers and how should the space be distributed among those reducers in order to minimize the overall running time? We argue that under reasonable conditions the races of a program can be captured by a directed acyclic graph (DAG), with nodes representing memory cells and arcs representing read-write dependencies between cells. We then formulate our original question as an optimization problem on this DAG. We concentrate on a variation of this problem where space reuse among reducers is allowed by routing every unit of extra space along a (possibly different) source to sink path of the DAG and using it in the construction of multiple (possibly zero) reducers along the path. We consider two different ways of constructing a reducer and the corresponding duration functions (i.e., reduction time as a function of space budget).

We generalize our race-avoiding space-time tradeoff problem to a discrete resource-time tradeoff problem with general non-increasing duration functions and resource reuse over paths of the given DAG.

For general DAGs, we show that even if the entire DAG is available to us offline the problem is strongly NP-hard under all three duration functions, and we give approximation algorithms for solving the corresponding optimization problems. We also prove hardness of approximation for the general resource-time tradeoff problem and give a pseudo-polynomial time algorithm for series-parallel DAGs.

Parallel and Distributed Algorithms, Multi-Core Architectures, Resource Management and Awareness, Scheduling Problems

††journalyear: 2019††copyright: acmcopyright††conference: 31st ACM Symposium on Parallelism in Algorithms and Architectures; June 22–24, 2019; Phoenix, AZ, USA††booktitle: 31st ACM Symposium on Parallelism in Algorithms and Architectures (SPAA ’19), June 22–24, 2019, Phoenix, AZ, USA††price: 15.00††doi: 10.1145/3323165.3323209††isbn: 978-1-4503-6184-2/19/06††ccs: Parallel and Distributed Algorithms††ccs: Multi-Core Architectures††ccs: Resource Management and Awareness††ccs: Scheduling Problems

1. Introduction

A determinacy race (or a general race) (Netzer and Miller, 1992; Feng and Leiserson, 1999) occurs if two or more logically parallel instructions access the same memory location and at least one of them modifies its content. Races are often undesirable as they can lead to nondeterministic and incorrect program behavior. A data race is a special case of a determinacy race which can be eliminated by associating a mutual-exclusion lock with the memory location in question or allowing only atomic accesses to it. Such a solution, however, makes all accesses to that location serial and thus destroys all parallelism. Figure 1 shows an example.

One can use a reducer (Frigo et al., 2009; Board, 1997; Reinders, 2007) to eliminate data races on a shared variable without destroying parallelism, provided the update operation is associative and commutative. Figure 3 shows the construction of a simple recursive binary reducer. For any integer $h>0$ such a reducer is a full binary tree of height $h$ and size $2^{h+1}-1$ with the shared variable at the root. Each nonroot node is associated with a unit of extra space initialized to zero. All updates to the shared variable are equally distributed among the leaves of the tree. Each node has a lock and a waiting queue to avoid races by serializing the updates it receives, but updates to different nodes can be applied in parallel. As soon as a node undergoes its last update, it updates its parent using its final value. In fact, such a reducer can be constructed using only $2^{h}$ units of extra space because if a node completes before its sibling it can become its own parent (with ties broken arbitrarily) and the sibling then updates the new parent. Assume that the time needed to apply an update significantly dominates the execution time of every other operation the reducer performs and each update takes one unit of time to apply. Then a reducer of height $h$ can correctly apply $n$ parallel updates on a shared variable in $\lceil{\frac{n}{2^{h}}}\rceil+h+1$ time provided at least $2^{h}$ processors are available. Hence, for large $n$, the speedup achieved by a reducer (w.r.t. serially and directly updating the shared variable) is almost linear in the amount of extra space used.

To see how extra space can speed up real parallel programs consider the iterative matrix multiplication code Parallel-MM shown in Figure 3 which multiplies two $n\times n$ matrices $X[1..n][1..n]$ and $Y[1..n][1..n]$ and puts the results in another $n\times n$ matrix $Z[1..n][1..n]$; that is, it sets $Z[i][j]=\sum_{1\leq k\leq n}{X[i][k]\times Y[k][j]}$ for $1\leq i,j\leq n$. Since every $Z[i][j]$ value can be computed independently of others, all iterations of the loops in Lines 1 and 2 can be executed in parallel without compromising correctness of the computation. However, the same is not true for the loop in Line 4 because if parallelized, for fixed values of $i$ and $j$, all iterations of that loop will update the same memory location $Z[i][j]$ giving rise to data races and thus producing potentially incorrect results. Use of a mutual-exclusion lock or atomic updates for each $Z[i][j]$ will ensure correctness but in that case even with an unbounded number of processors, the code will take ${\Theta}\left({n}\right)$ time to multiply the two $n\times n$ matrices. Now if we put a reducer of height $h$ (integer $h\in[1,\log_{2}{n}]$) at the top of each $Z[i][j]$ the time to fully update each $Z[i][j]$ and thus the overall running time of the code will drop to ${\Theta}\left({\frac{n}{2^{h}}+h}\right)$ at the cost of using $n^{2}\times 2^{h}$ units of extra space. Observe that when $h=1$, the running time of the code almost halves using $2n^{2}$ units of extra space, and when $h=\left\lfloor\log_{2}{n}\right\rfloor$, the running time drops to ${\Theta}\left({\log{n}}\right)$ using ${\Theta}\left({n^{3}}\right)$ extra space.

In order to analyze a program $P$ with data races, we capture those races in a directed acyclic graph (DAG) $D(P)$, assuming that there are no cyclic read-write dependencies among the memory locations accessed by $P$. Figure 5 shows an example. We restrict $P$ to the set of programs that perform ${\mathcal{O}}\left({1}\right)$ other operations between two successive writes to the memory, e.g., Parallel-MM in Figure 3. We assume that an update operation is significantly more expensive than any other single operation performed by $P$ and hence the costs of those operations can be safely ignored. Each node $x$ of $D(P)$ represents a memory location, and a directed edge from node $x$ to node $y$ means that $y$ is updated using the value stored at $x$. The in-degree $d^{(in)}_{x}$ of node $x$ gives the number of times $x$ is updated. With $x$ we also associate a work value $w_{x}$ and set $w_{x}=d^{(in)}_{x}$. Assuming that each update operation requires unit time to execute and each node has a lock and a wait queue to serialize the updates, the $w_{x}$ value represents the time spent updating $x$ (excluding all idle times). The $w_{x}$ value also represents an upper bound on the time elapsed between the trigger time of any incoming edge of $x$ and the time the edge completes updating $x$. We assume that updates along all outgoing edges of $x$ trigger as soon as all incoming edges complete updating $x$. One can then make the following observation.

Observation 1.1.

The running time of $P$ with an unbounded number of processors is upper bounded by the makespan of $D(P)$111To see why this is true start from the sink node and move backward toward the source by always moving to that predecessor $y$ of the current node $x$ that performed the last update on $x$ and noting that after edge $(y,x)$ was triggered it did not have to wait for more than $d^{(in)}_{x}$ time units to complete applying $y$’s update to $x$..

Then one natural question to ask is the following.

Question 1.1.

Given a fixed budget of units of extra space to mitigate the cost of data races in $P$, which memory locations should be assigned reducers and how should the space be distributed among those reducers in order to minimize the makespan of $D(P)$?

Figure 5 shows how to minimize the makespan of the DAG in Figure 5 using two units of extra space.

The question above ignores the possibility that space can be reused among reducers in $D(P)$. Indeed, after node $x$ reaches its final value (i.e., updated $w_{x}=d^{(in)}_{x}$ times) it can release all (if any) space it used for its reducer which can then be reused by some other node $y$. A global memory manager can be used by the nodes to allocate/deallocate space for reducers. The following modified version of Question 1.1 now allows space reuse.

Question 1.2.

Repeat Question 1.1 but allow for space reuse among nodes of $D(P)$ by putting all extra space under the control of a global memory manager that each node calls to allocate space for its reducer right before its first update and to deallocate that space right after its last update.

The problem with a single global memory manager is that it can easily become a performance bottleneck for highly parallel programs. Though better memory allocators have been developed for multi-core or multi-threaded systems (Aigner et al., 2015; Berger et al., 2000; lla, lloc; Schneider et al., 2006; TCM, ools), we can instead use an approach often used by recursive fork-join programs which avoids repeated calls to an external memory manager altogether along with the overhead of repeated memory allocations/deallocations.

A single large segment of memory is allocated before the initial recursive call is made and a pointer to that segment is passed to the recursive call. Each recursive call splits and distributes its segment among its child recursive calls and reclaims the space when the children complete execution. So, we will assume that all the given extra space initially reside at the source node (i.e., node with in-degree zero). Then they flow along the edges toward the sink node (i.e., node with outdegree zero) possibly splitting along outgoing edges and merging at the tip of incoming edges as they flow. Each unit of space reaching node $x$ moves out of $x$ along some outgoing edge as soon as $x$ becomes fully updated and those edges trigger. Every unit of space may participate in the construction of multiple reducers (possibly zero) along the path it takes.

Question 1.3.

Repeat Question 1.1 but now allow for space reuse among nodes of $D(P)$ by flowing each unit of space along a source to sink path and using it in the construction of zero or more reducers along that path.

While several existing results (De et al., 1997; Du and Leung, 1989; Skutella, 1998; Jansen and Zhang, 2006) can be extended to answer Questions 1.1 and 1.2, to the best of our knowledge, Question 1.3 had not been raised before. In this paper we investigate answers to Question 1.3 by extending it to a more general resource-time tradeoff question posed on a DAG in which nodes represent jobs (not necessarily of updating memory locations), resources (not necessarily space) flow along source to sink paths, and an general duration function (i.e., time needed to complete a job as a function of the amount of resources used) is specified for each node. We consider the following three duration functions: general non-increasing function for the general resource-time question, and recursive binary reduction and multiway ($k$-way) splitting for the space-time case.

For general DAGs, we show that even if the entire DAG is available to us offline the problem is strongly NP-hard under all three duration functions, and we give approximation algorithms for solving the corresponding optimization problems. We also prove hardness of approximation for the general resource-time tradeoff problem and give a pseudo-polynomial time algorithm for series-parallel DAGs. Our main results are summarized in Table 1.

Related Work

While several prior works either directly or indirectly address Questions 1.1 (nonreusable resources) and 1.2 (globally reusable resources), to the best of our knowledge, Question 1.3 (reusable along flow paths) has not been considered before.

The well-known time-cost tradeoff problem (TCTP) is closely related to our nonreusable resources question. In TCTP, some activities are expediated at additional cost so that the makespan can be shortened. Deadline and budget problems are two TCTP variants with different objectives. While the deadline problem seeks to minimize the total cost to satisfy a given deadline, the budget problem aims to minimize the project duration to meet the given budget constraint (Akkan et al., 2005). Most researchers consider the tradeoff functions to be either linear continuous or discrete giving rise to linear TCTP and discrete TCTP, respectively.

Linear TCTP was formulated by Kelley and Walker in 1959 (Kelley Jr and Walker, 1959). They assumed affine linear and decreasing tradeoff functions. In 1961, linear TCTP was solved in polynomial time using network flow approaches independently by Fulkerson (Fulkerson, 1961) and Kelley (Kelley Jr, 1961). Phillips and Dessouky (Phillips Jr and Dessouky, 1977) later improved that result.

In 1997, De et al. (De et al., 1997) proved that discrete TCTP is NP-hard. For this problem, Skutella (Skutella, 1998) proposed the first approximation algorithm under budget constraints which achieves an approximation ratio of ${\mathcal{O}}\left({\log{r}}\right)$, where $r$ is the ratio of the maximum duration of any activity to the minimum one. Discrete TCTP can also be used to approximate the TCTP with general time-cost tradeoff functions, see, e.g., Panagiotakopoulos (Panagiotakopoulos, 1977) and Robinson (Robinson, 1975). For details on discrete TCTP see De et al. (De et al., 1995).

Our problem with globally reusable resources (Question 1.2) is very similar to the problem of scheduling precedence-constrained malleable tasks (Turek et al., 1992). In 1978, Lenstra and Rinnooy Kan (Lenstra and Rinnooy Kan, 1978) showed that no polynomial time algorithm exists with approximation ratio less than $\frac{4}{3}$ unless $\textrm{P}=\textrm{NP}$. About 20 years later, Du and Leung (Du and Leung, 1989) showed that the problem is strongly NP-hard even for two units of resources. In 2002, under the monotonous penalty assumptions of Blayo et al (Blayo et al., 1999), Lepère et al. (Lepère et al., 2002) first proposed the idea of two-step algorithms – computing an allocation first, and then scheduling tasks, and used this idea (Lepere et al., 2002) to design a algorithm that achieve an approximation ratio of $\approx 5.236$. In the first phase, they approximate an allocation using Skutella’s algorithm (Skutella, 1998). Similarly, based on Skutella’s approximation algorithm, Jansen and Zhang (Jansen and Zhang, 2006) devised a two-phase approximation algorithm with the best-known ratio of $\approx 4.730598$ and showed that the ratio is tight when the problem size is large. For more details on the problems of scheduling malleable tasks with precedence constraints, please check Dutot et al. (Dutot et al., 2004).

There are memory allocators based on global memory manager for multi-core or multi-threaded systems such as scalloc (Aigner et al., 2015), Hoard (Berger et al., 2000), llalloc (lla, lloc), Streamflow (Schneider et al., 2006), and TCMalloc (TCM, ools). They use thread-local space for memory allocation and a global manager for memory deallocation/reuse. For the global manager, they use concurrent data structures. However, these data structures can not completely avoid the need for synchronization (Aigner et al., 2015; Henzinger et al., 2013; Shavit, 2011) without compromising correctness.

2. Preliminaries, Problem Formulation

In general, the option to use reducers to trade off between extra space and the time to complete race-free writing operations leads to a discrete resource-time tradeoff problem, where, here, the valuable “resource” is the space that is added, in order to reduce the time necessary for the write operations. By investing in additional space, we can reduce the time it takes to do conflict-free write operations.

We formalize the discrete resource-time tradeoff problem. Consider a DAG, $D=(V,E)$, whose vertices $V$ correspond to jobs, and whose edges represent precedence relations among jobs. Without loss of generality, we assume that the DAG has a single source and a single sink vertex. The duration of a job depends on how much resource it receives. For each job $v\in V$, there is a non-increasing duration function $t_{v}(r)$ that denotes the time required to complete job $v$ using $r$ units of resources. We call $\langle r,t_{v}(r)\rangle$ a resource-time tuple associated with job (vertex) $v$. We consider three classes of duration functions – general non-increasing step functions, $k$-way splitting functions, and recursive binary splitting functions.

General non-increasing step function. Let $l_{v}$ be the number of resource-time tuples associated with job $v$. The $i$-th resource-time tuple is $\langle r_{v,i},t_{v}(r_{v,i})\rangle$ where $1\leq i\leq l_{v}$. Then, the duration function $t_{v}(r)$ is a step function with $l_{v}$ steps described as follows:

[TABLE]

where $r_{v,1}=0,r_{v,j}<r_{v,j+1}$ and $t_{v}(r_{v,j})\geq t_{v}(r_{v,j+1})$ for $1\leq j<l_{v}$.

$k$-way splitting. A $k$-way split reducer utilizes $k$ units of extra space, $S_{v}=\{s_{1},s_{2},..,s_{k}\}$, associated with a vertex $v$, with $2\leq k\leq d^{(in)}_{v}$, such that the write operations associated with incoming edges at $v$ are distributed among the vertices $S_{v}$, which then have edges linking each $s_{i}$ to $v$.

The duration function that results from $k$-way split reducers is given by

[TABLE]

Recursive binary splitting. The duration function that results from a recursive binary split reducer is given by a step function, as follows. The resource-time tuples are defined for $r=0$ and $2^{i}$ where $0\leq i\leq k$ and $k=\lfloor\log_{2}t_{v}(0)-\log_{2}\log_{2}e\rfloor$. The duration function $t_{v}(2^{k})=\lceil{t_{v}(0)/2^{k}}\rceil+k+1$ is minimized when $k=\lfloor\log_{2}t_{v}(0)-\log_{2}\log_{2}e\rfloor$ (by differentiating $t_{v}(2^{k})$ w.r.t. $k$).

[TABLE]

When utilizing a reducer, extra space serves as the limited resource and the time taken for race-free writing at a vertex $v$ is the duration of the job corresponding to $v$. Both the $k$-way splitting duration function and the recursive binary splitting duration function are special cases of general non-increasing function.

We consider jobs whose duration functions are of the types described above, and we distinguish between two optimization problems, depending on the objective function:

Minimum-Makespan Problem. Given a resource budget of $B$, assign the resources to the vertices $V$ such that the makespan of the project is minimized. Resources can be reused over a path.

Minimum-Resource Problem. Given a makespan target of $T$, minimize the amount of resources to achieve target makespan. Resources can be reused over a path.

Finally, we remark that instead of jobs corresponding to vertices of the DAG, we can transform the DAG $D$ into another DAG $D^{\prime}$ in which jobs correspond to edges of $D^{\prime}$, and the precedence relations among jobs are enforced by introducing dummy edges, as follows: For each node $v$ in $D$, we introduce an edge $e_{v}=(a_{v},b_{v})$ in $D^{\prime}$ (which then has the corresponding duration function, specified, e.g., by resource-time tuples). For each edge $(u,v)$ of $D$, we introduce a dummy edge, $e=(b_{u},a_{v})$ in $D^{\prime}$, from the endpoint $b_{u}$ of edge $e_{u}=(a_{u},b_{u})$ to the origin $a_{v}$ of edge $e_{v}=(a_{v},b_{v})$, with resource-time function $t_{e}(r)=0$ for all valid resource levels $r$.

3. Approximation Algorithms

3.1. Bi-criteria Approximation for Non-increasing Duration Functions

We use linear programming in our approximation algorithms. First, we relax the discrete duration function to a linear one. We transform the DAG so that a relaxed linear non-increasing duration function can be used. The transformation happens in two steps.

Activity on arc reduction. We reduce the input DAG $D$ into an equivalent DAG $D^{{}^{\prime}}$ with activities on arcs instead of nodes. This is a simple transformation described earlier in Section 2.

Activity with two tuples. Following (Skutella, 1998), we create a DAG $D^{{}^{\prime\prime}}$ from $D^{{}^{\prime}}$ such that all activities in $D^{{}^{\prime\prime}}$ are still on arcs and each such activity has at most $2$ resource-time tuples as shown in Figure 7(b). Let $j$ be a job with $l_{j}\geq 2$ resource-time tuples $\langle r_{j,i},t_{j}(r_{j,i})\rangle,1\leq i\leq l_{j}$ with $0=r_{j,1}<r_{j,2}<\cdots<r_{j,l_{j}}$ and $t_{j}(r_{j,1})\geq t_{j}(r_{j,2})\geq\cdots\geq t_{j}(r_{j,l_{j}})$ (following Equation 1). Let edge $(u,v)$ of $D^{{}^{\prime}}$ represent job $j$. We add $l_{j}$ parallel chains, each consisting of two edges in $D^{{}^{\prime\prime}}$ (Figure 7). For $1\leq i\leq l_{j}$, we create a chain of two edges $(u,u_{i})$ and $(u_{i},v)$. We create a job $j_{i}$ for arc $(u,u_{i})$ and associate two resource-time tuples with it. For $1\leq i<l_{j}$, job $j_{i}$ can be finished either using [math] resource in $t_{j}(r_{j,i})$ units of time or using $(r_{j,i+1}-r_{j,i})$ units of resource in [math] unit of time. The logic is that job $j$’s duration can be reduced from $t_{j}(r_{j,i})$ to $t_{j}(r_{j,i+1})$ provided the resource difference $(r_{j,i+1}-r_{j,i})$ is allocated to $j_{i}$. Thus the duration function is $t_{j_{i}}(0)=t_{j}(r_{j,i})$ and $t_{j_{i}}(r_{j,i+1}-r_{j,i})=0$. Job $j_{l_{j}}$’s (bottom most edge in the $l_{j}$ parallel edges for job $j$) duration cannot be further improved from $t_{j}(r_{j,l_{j}})$ units of time by using extra resources. The resource-time tuple at edge $(u_{i},v)$ is $\langle 0,0\rangle$ where $1\leq i\leq l_{j}$.

There is a canonical mapping of resource usages and durations for jobs $j_{i}$ to that of job $j$. Let $x_{i}$ be the units of resource used for job $j_{i}$, then for job $j$, $\sum_{i=1}^{l_{j}}x_{i}$ units of resource are used. The time taken to finish job $j$ is $\max\{t_{j_{i}}(x_{i})|1\leq i\leq l_{j}\}$. Without loss of generality, if we use [math] unit of resource for job $j_{i}$ if $t_{j,i}(0)\leq\max\{t_{j,1}(x_{1}),t_{j,2}(x_{2}),\cdots,t_{j,i-1}(x_{i-1})\}$, then this mapping is bijective. Thus we get the following lemma.

Lemma 3.1.

Any approximation algorithm $\mathcal{A}$ on DAG $D^{{}^{\prime\prime}}$ (activity on edge and each edge has at most two resource-time tuples) with an approximation ratio $\alpha$ implies an approximation algorithm with the same approximation ratio $\alpha$ on general DAG $D$ (activity on vertex and each job can have more than two resource-time tuples).

From now on, we will only consider DAGs whose edges represent jobs, with each edge having at most two resource-time tuples.

Linear relaxation. In $D^{{}^{\prime\prime}}$, any edge $(u,v)$ can have either two resource-time tuples $\{\langle 0,t_{(u,v)}(0)\rangle,\langle r_{(u,v)},0\rangle\}$ or a single resource-time tuple $\{\langle 0,t_{(u,v)}(0)\rangle\}$. With linear relaxation, $r\in[0,r_{(u,v)}]$ units of resource can be used to reduce the completion time of the job corresponding to edge $(u,v)$ that has two resource-time tuples. The corresponding duration function $t_{(u,v)}(r)$ is as follows:

[TABLE]

The linear duration function $t_{(u,v)}(r)$ for the job $(u,v)$ with single resource-time tuple is as follows:

[TABLE]

Linear programming formulation. Since we are allowed to reuse resources over a path we can model the problem as a network flow problem where resources are allowed to flow from the source to the sink in the DAG $D^{{}^{\prime\prime}}$. Let $E$ be the set of edges in $D^{{}^{\prime\prime}}$. Let $f_{(u,v)}$ denote the amount of resources that flow through the edge $(u,v)$. Using linear relaxation on edge $(u,v)$, the time taken to finish the activity is $t_{(u,v)}(f_{(u,v)})$. Let the vertices in $D^{{}^{\prime\prime}}$ denote events. From now onwards, we use a vertex and its corresponding event synonymously. Let $E_{v}=\{(x,v)\}$ be the set of edges that are incident on vertex $v$. Event $v$ occurs if and only if all the jobs corresponding to the edges in set $E_{v}$ are finished. Let $T_{v}$ denote the time when event $v$ occurs. Let $s$ and $t$ denote the source vertex and the sink vertex, respectively. For source vertex $s$, we assume $T_{s}=0$. All variables are non-negative.

Constraints:

[TABLE]

[TABLE]

[TABLE]

[TABLE]

Objective function:

[TABLE]

Inequality 6 upper bounds the resource flow variable $f_{(u,v)}$ for edges with two tuples. This ensures that these variables remain in the range $[0,r_{(u,v)}]$ and the duration function is linear in this range. Note that there is no such upper bound on the edges with single resource-time tuple (except the trivial total resource budget $B$ upper bound). This allows the flow of more resources over an edge that can be used later on a path. Equation 8 is a flow conservation constraint for all the vertices $v\notin\{s,t\}$. Inequality 9 constrains the flow of resources from source $s$ to be upper bounded by the resource budget.

Solving the LP and rounding. We first solve the LP described above. This might give solution as fractional flow $f^{*}_{e}$ and duration $t_{e}(f^{*}_{e})$ at edge $e=(u,v)$. Let the resource-time tuples at edge $e$ be $\{\langle 0,t_{e}(0)\rangle,\langle r_{e},0\rangle\}$. The range of feasible duration of activity $e$ is $[0,t_{e}(0)]$. We divide this range into two parts $[0,\alpha t_{e}(0)),[\alpha t_{e}(0),t_{e}(0)]$ where $0<\alpha<1$. If $t_{e}(f^{*}_{e})\in[0,\alpha t_{e}(0))$ we round it down to [math], otherwise, we round it up to $t_{e}(0)$. Observe that in the first case, the resource requirement at $e$ can be increased by at most a factor of $1/(1-\alpha)$. In the second case, the completion time can be increased at most by a factor of $1/\alpha$. Let $f^{{}^{\prime}}_{e}$ denote the rounded integer resource requirement at edge $e$.

Computing min-flow. After rounding the LP solution, we get an integral resource requirement $f^{{}^{\prime}}_{e}\in\{0,r_{e}\}$ for every edge $e$. We now compute a min-flow through this DAG where $f^{{}^{\prime}}_{e}$ serves as the lower bound on the flow through (or resource requirement at) edge $e$.

Constraints:

[TABLE]

[TABLE]

Objective function:

[TABLE]

Let, $f$ and $f^{*}$ be the optimal solutions of LP 11–13 and LP 6–10, respectively.

Lemma 3.2.

$f^{*}/(1-\alpha)$* is a feasible solution of min-flow LP 11–13.*

Proof.

Let $f^{*}_{e}$ be the optimal solution of LP 6–10. We know that $f^{{}^{\prime}}_{e}\leq f^{*}_{e}/(1-\alpha)$. Hence, $f^{*}/(1-\alpha)$ is a feasible solution of that LP as it meets the resource requirement $f^{{}^{\prime}}_{e}$ at every edge $e$. ∎

Lemma 3.3.

$f$* is an integral flow and $f\leq f^{*}/(1-\alpha)$, where $0<\alpha<1$.*

Proof.

The minflow problem has integral optimality. If $f$ is the optimal solution then it is an integral flow. From lemma 3.2 we know that $f^{*}/(1-\alpha)$ is a feasible solution of LP 11–13. Since $f$ is optimal and $f^{*}/(1-\alpha)$ is a feasible flow, we have, $f\leq f^{*}/(1-\alpha)$. ∎

Bi-criteria approximation. We now summarize our bi-criteria approximation result for general non-increasing duration functions:

Theorem 3.4.

For any $\alpha\in(0,1)$, there is a $(1/\alpha,1/(1-\alpha))$ bi-criteria approximation algorithm for the discrete resource-time tradeoff problem with an general non-increasing duration function which allows resource reuse over paths.

Proof.

First, we know from lemma 3.3 that $f$ is an integral flow and $f\leq f^{*}/(1-\alpha)$, where $0<\alpha<1$.

Second, we claim that the makespan of the DAG used in the minflow LP 11–13 is at most a factor of $1/\alpha$ away from that of the LP 6–10 solution. Let us consider any $s-t$ path $\mathscr{P}$. The makespan is at least the sum of completion times of the edges in $\mathscr{P}$. Now, after rounding the LP 6–10 solution, the completion time of an edge may increase at most by a factor of $\alpha$. Hence, the sum of duration of edges along any path is increased at most by a factor of $\alpha$, thus the makespan will be increased by at most a factor of $\alpha$. ∎

3.2. Single-criteria Approximation for $k$-Way and Recursive Binary Splitting

First, observe the prior section gives us a bi-criterian approximation for both $k$-way and recursive binary splitting. Setting $\alpha=1/2$ in Theorem 3.4, we obtain a $(2,2)$ bi-criteria approximation. Now, after LP rounding, say a job $j$ uses $\overline{r_{j}}$ units of resource and takes $\overline{t_{j}}$ units of time. Then the optimal solution uses $r_{j}^{*}\geq\overline{r_{j}}/2$ units of resource and takes $t_{j}^{*}\geq\overline{t_{j}}/2$ units of time for job $j$. Recall that job $j$ consists of $l_{j}$ parallel jobs $j_{i}$ where $1\leq i\leq l_{j}$. Hence, $\overline{r_{j}}$ is the sum of the resource (after rounding) used by $l_{j}$ parallel jobs and $\overline{t_{j}}$ is the maximum time (after rounding) taken by $l_{j}$ parallel jobs.

Approximation algorithm for $k$-way splitting. To obtain a single-criteria approximation, in the case of $k$-way splitting, we use at most $r_{j}^{*}$ units of resource for job $j$. If $\overline{r_{j}}>r_{j}^{*}$, we reduce $\overline{r_{j}}$ to $k$ (a nonnegative integer) units of resource such that $k\leq r_{j}^{*}$. Using $k$ units of resource, job $j$ takes $t_{j}(k)$ units of time to complete.

Lemma 3.5.

$\lceil{d/k}\rceil+k\leq 2.5\overline{t_{j}}$* for $\overline{r_{j}}>3$ where $d=t_{j}(0)$ and $k=\lfloor\overline{r_{j}}/2\rfloor$.*

Proof.

Since $k=\lfloor\overline{r_{j}}/2\rfloor\geq\overline{r_{j}}/2.5$ for $\overline{r_{j}}>3$, we have $\lceil{d/k}\rceil\leq d/k+1\leq 2.5d/\overline{r_{j}}+1\leq 2.5\lceil{d/\overline{r_{j}}}\rceil+1$. Also since $k=\lfloor\overline{r_{j}}/2\rfloor\leq\overline{r_{j}}+1$ and $2.5\overline{r_{j}}\geq\overline{r_{j}}+2$ for $\overline{r_{j}}>3$, we have $\lceil{d/k}\rceil+k\leq 2.5\lceil{d/\overline{r_{j}}}\rceil+1+\overline{r_{j}}+1\leq 2.5\left(\lceil{d/\overline{r_{j}}}\rceil+\overline{r_{j}}\right)$. Hence, $t_{j}(k)\leq 2.5\overline{t_{j}}$. ∎

Lemma 3.6.

If $\overline{r_{j}}>3$ then $t_{j}(k)\leq 5t_{j}^{*}$.

Proof.

We know $t_{j}(k)=\lceil{d/k}\rceil+k$ as $k\geq 4$. Also in lemma 3.5, we prove $t_{j}(k)\leq 2.5\overline{t_{j}}$. However, we show that $\overline{t_{j}}\leq 2t_{j}^{*}$. Hence, combining these two results we get $t_{j}(k)\leq 5t_{j}^{*}$. ∎

Lemma 3.7.

If $t_{j}^{*}=d/4$ then $r_{j}^{*}\geq 2$.

Proof.

Recall that in $D^{{}^{\prime\prime}}$, job $j$ is represented as $l_{j}$ parallel jobs $j_{i}$ where $1\leq i\leq l_{j}$. The resource-time tuples of jobs $j_{1}$ and $j_{2}$ are $\{\langle 0,d\rangle,\langle 2,0\rangle\}$ and $\{\langle 0,\lceil{d/2}\rceil+2\rangle,\langle 1,0\rangle\}$, respectively. To attain $d/4$ duration, $j_{1}$ requires at least $3/2$ units of resource and job $j_{2}$ requires $1/2$ unit of resource (applying linear relaxation). Hence, $r_{j}^{*}\geq(3/2+1/2)=2$ units of resource to achieve $t_{j}^{*}=d/4$. ∎

Lemma 3.8.

If $\overline{r_{j}}\leq 3$ then $t_{j}(k)\leq 4t_{j}^{*}$.

Proof.

If $\overline{r_{j}}\leq 3$ and $r_{j}^{*}<2$, then we round down $\overline{r_{j}}$ to $k=0$. So, from Lemma 3.7 it follows that after rounding down to [math] unit of resource, job $j$ takes $d\leq 4t^{*}$ units of time.

If $\overline{r_{j}}\leq 3$ and $r_{j}^{*}\geq 2$, then we round $\overline{r_{j}}$ to $k=2$. It is true that $t_{j}(2)\leq 2t_{j}(3)$ because $(\lceil{d/2}\rceil+2)\leq 2(\lceil{d/3}\rceil+3)$. Also, $t_{j}(3)\leq t_{j}(\overline{r_{j}})\leq 2t_{j}^{*}$. Combining this two results we get $t_{j}(2)\leq 4t^{*}$. ∎

So, now we have the following result.

Theorem 3.9.

There is a $5$-approximation algorithm for the minimum-makespan problem with $k$-way splitting duration function.

Proof.

Combining Lemmas 3.8 and 3.6 we get $t_{j}(k)\leq 5t_{j}^{*}$ for all valid $\overline{r_{j}}$. This proves that the makespan is at most 5 times the optimal solution. We now calculate the total amount of resource required to flow from the source of $D^{{}^{\prime}}$. We compute a min-flow in $D^{{}^{\prime}}$ where $k$ is the resource requirement for job $j$. Note that we are now working on $D^{{}^{\prime}}$ that does not have $l_{j}$ parallel chains for job $j$. Let $f$ be the min flow from the source of $D^{{}^{\prime}}$ such that all the resource requirements are met. The flow $f^{*}$ from the LP solution before rounding is also a valid flow for the resource requirement $k$ for job $j$ as $k\leq r_{j}^{*}$. We know that min-flow gives an optimal integral solution. Hence, $f\leq f^{*}$. ∎

Approximation algorithm for recursive binary splitting. We have the following result.

Theorem 3.10.

There is a $4$-approximation algorithm for the minimum-makespan problem with recursive binary splitting function.

Proof.

As in the case of k-way splitter, to get a single-criteria approximation, we use no more than $r_{j}^{*}$ units of resource for job $j$. If $\overline{r_{j}}>r_{j}^{*}$, we reduce $\overline{r_{j}}$ to $\overline{r_{j}}/2$. We know that $t_{j}(\overline{r_{j}}/2)\leq 2t_{j}(\overline{r_{j}})$ from the properties of the recursive binary splitting function. Thus, $t_{j}(\overline{r_{j}}/2)\leq 2t_{j}(\overline{r_{j}})\leq 4t_{j}(r_{j}^{*})=4t_{j}^{*}$. ∎

3.3. Improved Bi-criteria Approximation for Recursive Binary Splitting Functions

Putting $\alpha=3/4$ in Theorem 3.4 we obtain a $(4/3,4)$ bi-criteria approximation algorithm for general non-increasing duration functions. Hence, if we use $4/3$ times more resources than OPT (i.e., the optimal solution), we are guaranteed to get a makespan within factor of 4 of OPT. In this section we show that the bound can be improved to $(4/3,14/5)$ for recursive binary splitting functions.

For a node with in-degree $x$, the resource-time tuples based on the recursive binary splitting function are as follows: $\{\langle 0,x\rangle,\langle 1,x\rangle,\langle 2,t_{1}\rangle,$ $...,\langle 2^{i},t_{i}\rangle,\langle 2^{i+1},t_{i+1}\rangle\,...,\langle 2^{k},t_{k}\rangle\}$ where $t_{j}=\lceil{x/2^{j}}\rceil+j+1$ for $j\geq 2$ and $k=\lfloor\log_{2}x-\log_{2}\log_{2}e\rfloor$ is the largest value of $j$ for which $t_{j}$ decreases with the increase of $j$. See Figure 7.

After solving LP 6–10 from Section 3.1, we sum up the (possibly fractional) resources allocated to all the $l_{j}$ parallel edges corresponding to job $j$. Let $r$ be that sum. Let $t$ be the maximum among the time values given by the LP solution for the $l_{j}$ parallel edges. Thus, the LP takes $t$ units of time for job $j$.

We round $r$ to an integer $\overline{r}$ based on the following criteria.

[TABLE]

We want to find a constant $\rho$, such that if $t=t_{i}/\rho$, then the LP must use at least $(2^{i}+2^{i+1})/2=3(2^{i-1})$ units of resources. We compute $r$ as follows. In Figure 7$(b)$, each of the top two edges $(u,u_{1})$ and $(u,u_{2})$ requires $(1-(1/x)t)$ units of resource to finish in time $t$. Each edge $(u,u_{j+2})$ for $1\leq j\leq i+1$ requires \Big{(}2^{j}-(2^{j}/t_{j})t\Big{)} units of resource to finish in time $t$. Summing over all these edges, we get the expression of $r$

[TABLE]

Since we want to have $r\geq 3(2^{i-1})$, we want to find the smallest value of $\rho$ such that

[TABLE]

Now,

[TABLE]

Let, $A=\frac{i+2}{x}\frac{1}{2^{i-2}}$ , $B=\sum_{j=1}^{i+1}\frac{i+2}{(\frac{x}{2^{j}}+j+1)2^{i-j-1}}$ and $C=32/3+\frac{1}{3}\frac{1}{4^{i-1}}$.

Note that $i+2=(i+1)+1\leq(\log_{2}x-\log_{2}\log_{2}e)+1$, since $i+1\leq k$. Hence,

[TABLE]

Now, $x/2^{j}+j+1\geq(\log_{2}x-\log_{2}\log_{2}e+\frac{1}{\ln{2}})$ and hence,

[TABLE]

Thus, $A+B+C<\frac{2}{e}\frac{1}{2^{i-2}}+2-\frac{1}{2^{i-2}}+32/3+\frac{1}{3}\frac{1}{4^{i-1}}\leq 14$.

Therefore, $(t_{i}/x)\frac{1}{2^{i-2}}+\sum_{j=1}^{i+1}\frac{t_{i}}{t_{j}}\frac{1}{2^{i-j-1}}<14$.

So, by setting $\rho=14/5$, we get $\rho>1/5\left((t_{i}/x)\frac{1}{2^{i-2}}+\sum_{j=1}^{i+1}\frac{t_{i}}{t_{j}}\frac{1}{2^{i-j-1}}\right)$.

Summarizing, we get the following lemmas from the computation above.

Lemma 3.11.

To achieve a duration of $t=t_{i}/(14/5)$ for any job $j$, the LP solution uses at least $3(2^{i-1})$ units of resources for $0\leq i\leq k$.

Lemma 3.11 implies the following.

Lemma 3.12.

If the LP uses $2^{i}\leq r<3(2^{i-1})$ units of resources and we round $r$ down to $\overline{r}=2^{i}$ where $0\leq i\leq k$, then $t_{i}\leq(14/5)t$ where $t$ is the duration from the LP solution.

Lemma 3.13.

With $r<1$ units of resource, the LP cannot achieve a duration of $t<x/2$ for job $j$.

Proof.

The first edge has resource-time tuples $\{\langle 0,x\rangle,\langle 1,0\rangle\}$. To achieve a duration of $x/2$, the LP has to use $1/2$ unit of resource on the first edge. The second edge also has the same resource-time tuples $\{\langle 0,x\rangle,\langle 1,0\rangle\}$, and it also takes $1/2$ unit of resource. Thus, the first two edges alone need $1$ unit of resource to achieve a duration of $x/2$ for all $l_{j}$ parallel edges of job $j$. ∎

Lemma 3.13 implies the following.

Lemma 3.14.

If the LP uses $r<1$ unit of resource and we round $r$ down to [math], then $t_{i}\leq 2t$, where $t$ is the duration from the LP solution.

Lemma 3.15.

If $r$ rounded to $\overline{r}$ then $\overline{r}\leq(4/3)r$

Proof.

When we use $\overline{r}=2^{i+1}$ units of resource after rounding, the LP uses at least $3(2^{i-1})\leq r\leq 2^{i+1}$ units. Thus, $\overline{r}\leq(4/3)r$. ∎

From Lemma 3.12 and Lemma 3.15, we get the following theorem.

Theorem 3.16.

There is a $(4/3,14/5)$ bi-criteria approximation algorithm for the discrete resource-time tradeoff problem with resource reuse along paths when the recursive binary duration function is used.

3.4. Exact Algorithm for Series-Parallel Graphs

We consider now the special case in which the underlying DAG $D$ is a series-parallel graph. A series-parallel graph $G$ can be transformed into (and represented as) a rooted binary tree $T_{G}$ in polynomial time by decomposing it into its atomic parts according to its series and parallel compositions (see, e.g., (Möhring, 1989)). In $T_{G}$, the leaves correspond to the vertices of $G$. Internal nodes of $T_{G}$ are labeled as “$s$” or “$p$” based on series or parallel composition. We associate each internal node $v$ of $T_{G}$ with the series-parallel graph $G_{v}$, induced by the leaves of the subtree rooted at $v$.

Let $T(v,\lambda)$ denote the makespan of $G_{v}$ using $0\leq\lambda\leq B$ units of resources where $B$ is the resource budget. We want to solve for $T(s,B)$, where $s$ is the root of $T_{G}$. This can be done using dynamic programming, solving for the leaves first, and then progressing upward to the root of $T_{G}$. We compute $T(v,\lambda)$ as follows which assumes that node $v$ corresponds to job $j$ if it is a leaf, otherwise it has two children $v_{1}$ and $v_{2}$.

[TABLE]

There are ${\mathcal{O}}\left({m}\right)$ nodes in $T_{G}$ if $G$ has $m$ edges. For each node $v$ we compute $T(v,\lambda)$ for $0\leq\lambda\leq B$. Computing $T(v,\lambda)$ for any particular value of $\lambda$ takes ${\mathcal{O}}\left({\lambda}\right)$ time, since, if the node is a “$p$” node, then for $0\leq i\leq\lambda$ we need to look up values $T(v_{1},i)$. Thus, for any internal node $v$, it takes $\sum_{\lambda=0}^{B}{{\mathcal{O}}\left({\lambda}\right)}={\mathcal{O}}\left({B^{2}}\right)$ time. As there are ${\mathcal{O}}\left({m}\right)$ nodes in $T_{G}$, the (pseudo-polynomial) time complexity of the algorithm is ${\mathcal{O}}\left({mB^{2}}\right)$.

4. NP-Hardness

In this section we give a variety of NP-hardness and inapproximability results related to the discrete time-resource tradeoff problem in the offline setting (i.e., when the entire DAG is available offline). All problems consider the version where there is resource reuse over paths, but they vary the cost-function, graph structure, and minimization goal. Section 4.1 gives several reductions from 1-in-3SAT. Theorem 4.1 gives a base reduction for the problem with general non-increasing duration function which will provide the ideas and structure for later more complex proofs. Theorems 4.3 and 4.4 adapt this proof to give constant factor inapproximability for the minimum-resource and minimum-makespan problems. Section 4.2 adapts the NP-hardness proof to apply when the cost function is restricted to be the recursive binary splitting and the $k$-way splitting.

Section 4.3 considers the problem in bounded treewidth graphs. We show weak NP-hardness by a reduction from Partition.

4.1. Reuse Over a Path with General Non-increasing Duration Function

Theorem 4.1.

It is (strongly) NP-hard to decide if there exists a solution to the (offline) discrete resource-time tradeoff problem, with resource reuse over paths and a non-increasing duration function, satisfying a resource bound $B$ and a makespan bound $T$.

Our proof is based on a polynomial-time reduction from the strongly NP-hard problem 1-in-3SAT (Schaefer, 1978): Given $n$ variables ($V_{i},1\leq i\leq n$) and $m$ clauses ($C_{j},1\leq j\leq m$),with each clause a disjunction of three literals, is there a truth assignment to the variables such that each clause has exactly one true literal?

Variable gadget. The gadget for variable $V$ consists of nodes $V^{(1)}$, $V^{(2)}$, $V^{(3)}$, $V^{(4)}$, $V^{(5)}$, and $V^{(6)}$ as shown in Figure 9$(a)$. We show in the hardness proof that a variable gadget will get exactly one unit of extra resource, otherwise the makespan will be greater than the target makespan of $1$. Sending one unit of resource to node $V^{(2)}$ (Figure 9$(a)$) corresponds to setting the variable $V$ to TRUE and sending the unit of resource to $V^{(3)}$ corresponds to setting $V$ to FALSE. The remaining vertices ensure the extra resource is used in the variable and not transferred into one of the clauses.

Clause gadget. The gadget corresponding to clause $C$ has $10$ vertices $C^{(i)}$ ($1\leq i\leq 10$) as shown in Figure 9$(b)$. Arcs $(C^{(1)},C^{(2)})$, $(C^{(2)},C^{(4)})$, $(C^{(1)},C^{(3)})$ and $(C^{(3)},C^{(4)})$ have resource-time pairs as $\{\langle 0,1\rangle,\langle 1,0\rangle\}$. If clause $C$ has three literals $V_{i},V_{j}$ and $V_{k}$, then vertex $C^{(5)}$ is connected to the vertices $V_{i}^{(3)},V_{j}^{(3)}$ and $V_{k}^{(2)}$. These vertices correspond to $\neg V_{i},\neg V_{j}$ and $V_{k}$ respectively. Vertex $C^{(6)}$ is connected to $V_{i}^{(3)},V_{j}^{(2)}$ and $V_{k}^{(3)}$ . These vertices correspond to $\neg V_{i},V_{j}$ and $\neg V_{k}$. Vertex $C^{(7)}$ is connected to $V_{i}^{(2)},V_{j}^{(3)}$ and $V_{k}^{(3)}$. These vertices correspond to $V_{i},\neg V_{j}$ and $\neg V_{k}$. Arcs $(C^{(5)},C^{(8)})$, $(C^{(6)},C^{(9)})$, and $(C^{(7)},C^{(10)})$ have resource-time pairs as $\{\langle 0,1\rangle,\langle 1,0\rangle\}$. The part of the clause gadget consisting of $C^{(1)},C^{(2)},C^{(3)}$ and $C^{(4)}$ demand at least two units of memory be allocated there and then these units of resource go to satisfy two of $C^{(5)},C^{(6)}$ and $C^{(7)}$. There is still one of these lines that has no allocated resource so it’s cost is 1. Thus the corresponding variable must have had it’s path length reduced (by setting it true).

Figure 9 shows the complete construction of $(V_{1}\lor\neg V_{2}\lor V_{3})\land(\neg V_{1}\lor V_{2}\lor V_{3})$ as an example.

Lemma 4.2.

There exists a solution to the input instance of 1-in-3SAT iff there exists a valid flow of resources through the DAG achieving a makespan of $1$ under a resource bound of $B=n+2m$.

Proof.

Forward direction. We prove that if there is a solution to the 1-in-3SAT instance with $n$ variables and $m$ clauses, then the reduced DAG has a solution of makespan $1$ with $(n+2m)$ units of resource. If a variable $V$’s truth assignment is TRUE, then we allow one unit of resource to flow through vertex $V^{(2)}$ along the path $\langle S,V^{(1)},V^{(2)},V^{(4)},V^{(5)},V^{(6)},T\rangle$, otherwise we allow one unit of resource to flow through vertex $V^{(3)}$ along the path $\langle S,V^{(1)},V^{(3)},V^{(4)},V^{(5)},V^{(6)},T\rangle$. For every clause $C$, we allow one unit of resource to flow through the path $\langle S,C^{(1)},C^{(2)},C^{(4)}\rangle$ and another unit of resource through the path $\langle S,C^{(1)},C^{(3)},C^{(4)}\rangle$. Thus, $2$ units of resource can be flowed from vertex $C^{4}$. In a valid assignment of 1-in-3SAT, for each clause $C$, exactly $2$ vertices of $C^{(5)},C^{(6)}$ and $C^{(7)}$ will have the earliest start time of $1$ and the other one will have [math] (Table 2).

Also, if only one literal is true in a clause, exactly two vertices among $C^{(5)},C^{(6)}$ and $C^{(7)}$ need one unit of extra resource each to meet the makespan requirement (from Table 2). We are allowed to flow $2$ units of resource from vertex $C^{(4)}$. Thus the project makespan is $1$ using $(n+2m)$ units of resource.

Backward direction. Now, we prove that if there exists a solution of makespan $1$ using $(n+2m)$ units of resource in the reduced DAG, then there also exists a solution to the 1-in-3SAT instance. To achieve a makespan of $1$, every variable gadget needs $1$ unit of resource and each clause gadget needs $2$ units of resource, otherwise the makespan would be greater than $1$. Also, any resource that is used in a variable gadget cannot be used further in any other variable or clause gadget because the resource can be reused over a path only. Similarly, any resource that is used in any clause gadget, cannot be reused in any other gadget. Only one vertex that is either $V^{(2)}$ or $V^{(3)}$, will have the earliest start time [math]. Both cannot be [math], as there is only $1$ unit of resource per variable gadget. Both cannot be $1$ as in a clause $C$ where the literal $V$ or $\neg V$ is present, each of $C^{(5)},C^{(6)}$ and $C^{(7)}$ would have earliest starting time of $1$. This requires use of $3$ units of resource in the clause gadget $C$ to achieve a makespan of $1$. However, each clause gadget can have exactly $2$ units of resource. Thus, for every variable, it has to be a valid assignment ($V$ is set to either TRUE or FALSE). From Table 2, if a clause has exactly one TRUE literal, then the clause gadget requires $2$ units of resource to achieve a makespan of $1$. Otherwise, the clause gadget would have a makespan of $2$ with the same amount of resource or would require more resource to achieve the target makespan of $1$. Thus, each clause has exactly one TRUE literal. This satisfies the 1-in-3SAT instance. ∎

We also prove hardness of approximation, both for the minimum-makespan problem and for the minimum-resource problem. We begin with the minimum-makespan problem.

Theorem 4.3.

The minimum-makespan discrete resource-time tradeoff problem that allows resources to be reused only over paths cannot have a polynomial-time approximation algorithm with approximation factor less than $2$ unless $P=NP$.

Proof.

We prove the theorem by contradiction. Let’s assume that there is a polynomial time approximation algorithm with factor less than $2$. Given a formula with $n$ variables and $m$ clauses, we construct the reduced DAG as described in the proof of Lemma 4.2. If the formula is a valid 1-in-3SAT instance, then OPT (i.e., the optimal solution) has a makespan of $1$ using $(n+2m)$ units of resource in the reduced DAG. The approximation algorithm will return a schedule with makespan less than $2$ using $(n+2m)$ units of resource. If the formula is not a valid 1-in-3SAT instance, then OPT’s makespan is greater than or equal to $2$. So, the approximation algorithm will have a schedule with makespan greater than or equal to $2$. Thus, using a polynomial time algorithm one can solve a strongly NP-hard problem. This is a contradiction. Hence, there exists no polynomial time approximation algorithm for resource-time-reuse-path problem with factor less than $2$ unless $P=NP$. ∎

Now, we turn attention to the minimum-resource problem:

Theorem 4.4.

The minimum-resource discrete resource-time tradeoff problem that allows resources to be reused only over paths cannot have a polynomial-time approximation algorithm with approximation factor less than $3/2$ unless $P=NP$.

Proof.

(Sketch) The proof uses a reduction from 1-in-3SAT; the construction is similar to that in the proof of Theorem 4.1, but has several key differences that make it considerably more intricate.

First, for each variable $x_{i}$ we have a gadget similar to before (Figure 9$(a)$), with the option to send one unit of resource on one of two two-edge paths via a vertex, with the choice of which path indicating whether the variable is set to true or to false. Unlike the previous construction, we chain the variable gadgets together into a path of gadgets, from a source $s$ to a sink $t$. Refer to Figure 11. A single unit of resource will be moved along the path, using one of each pair of two-edge paths, according to the truth assignments of the variables. A single directed edge, with options $\langle 1,0\rangle$ and $\langle 0,M\rangle$, links variable $x_{i}$ gadget to variable $x_{i+1}$ gadget. Node $s$ is connected to the variable $x_{1}$ gadget with an edge with $\langle 0,0\rangle$. A property of this construction is that the entry node of the $x_{i}$ gadget is reached by the unit of resource at exactly time $i-1$, and the exit node of this gadget is reached at time exactly $i$. At time $n$ the one unit of resource that traverses the path of variable gadgets emerges at time $n$. Finally, there is also an edge directly from $s$ to $t$ with options $\langle 1,n\rangle$ and $\langle 0,M\rangle$. In total, two units of resource will be moved through this part of the DAG: one will follow a path through the variable gadgets, according to the truth assignments of the variables, and the other will go directly along the edge $(s,t)$. Both units of resource will arrive at $t$ at time $n$.

The clause gadget consists of three vertices, each representing a literal. Each clause has an entry vertex and an exit vertex, and they are chained into a path of gadgets, with clauses ordered in a specific way, as described below. Refer to Figure 11. The exit vertex of one clause has an edge connecting it to the next clause in the order; these edges have specially chosen duration values in order to serve as “buffers”, as described below. The variable portion of the DAG feeds into the path of clause gadgets, with the 2 units of resource that arrive at $t$ at time $n$ moving along an edge that feeds into the first of the sequence of clause gadgets. Each of the three vertices of a clause gadget corresponds to a literal; each has an input edge coming from one of the two vertices of the variable gadget corresponding to the literal, according to whether the variable appears positively or negatively in the clause. These incoming edges have durations that are carefully chosen, so that the timing is as follows: For a clause with variables $x_{i}$, $x_{j}$, and $x_{k}$, the two units of resource (which came through the variable portion of the DAG before entering the path of clause gadgets) will arrive at the entry to the clause at exactly time $n+i+j+k$. The incoming edges from variables to the clause literals have durations chosen just so that the precedence constraints are satisfied “just in time”, for the two units of resource to pass through the clause gadget literals that are not true (using edges with duration 0, based on the resource of 1), while the one true literal vertex (who was reached within the clause gadget via an edge of duration 1, instead of 0, since there was no resource associated with it) is reached 1 unit of time sooner (from the variable gadget), to compensate. The net result is that both units of resource emerge out of a clause at time $n+1+i+j+k$, ready to pass into the buffer and the next clause gadget. The buffers are selected carefully.

Then, we claim that we can achieve makespan $A$ using just the 2 units of resource if and only if the variables are assigned to satisfy the 1-in-3SAT. If the variables are assigned in a way that does not yield all clauses to be true, then we will need at least 3 units of resource to achieve the target makespan. Thus, it is NP-hard to distinguish between needing 2 units and needing 3 units of resource. This implies that it is NP-hard to achieve an approximation ratio better than factor 3/2. ∎

4.2. Reuse Over a Path with Recursive Binary Splitting and $k$-Way Splitting

We have seen a (strong) NP-hardness proof (Theorem 4.1) for the discrete resource-time tradeoff problem with general non-increasing duration functions. In this subsection we strengthen this result by showing that the problem remains hard even when the duration functions arise from recursive binary split reducers and $k$-way split reducers. The proof uses the same general technique as in Section 4.1, but requires more complex gadgets to deal with the restricted duration functions.

Composite node. A composite node $v$ of order $k$ is a gadget of $(k+2)$ nodes as shown in Figure 14. A composite node can have only one incoming edge and only one outgoing edge. Without using any extra resource, a composite node of order $k$ takes $(k+2)$ units of time to finish its activities. This is because there is one write operation on vertex $v_{1}$, one write operation on vertex $v_{i}$ $(2\leq i\leq k+1)$ and $k$ write operations on vertex $v_{k+2}$. Using $2$ units of resource with the $k$-way splitting function, all activities can be completed in $(2+k/2+2)=(k/2+4)$ time. Similarly using $2$ units of resource with recursive binary splitting function, all activities will be completed in $(2+k/2+\log 2+1)=(k/2+4)$ time. Thus using $2$ units of resource, composite node $v$ takes $(k/2+4)$ units of time using either function.

Variable gadget. The gadget for variable $V$ consists of $3$ composite nodes and other nodes as shown in Figure 14. Composite nodes $V^{(2)}$ and $V^{(2)}$ are of order $2x$. Composite node $V^{(4)}$ is of order $8x$. There is a chain of $4x$ nodes from $V^{(2)}$ to $V^{(5)}$ inclusive. Similarly there is a chain of $4x$ nodes from $V^{(3)}$ to $V^{(6)}$ inclusive. We will see that unless a variable gadget gets exactly $2$ units of resource, its makespan will be greater than $(7x+2y+12)$ which we will use as the target makespan later in our hardness proof. The values of $x$ and $y$ will be described shortly. Sending $2$ units of resource to node $V^{(2)}$ (Figure 14) corresponds to setting the variable $V$ to TRUE and sending $2$ units of resources to $V^{(3)}$ corresponds to setting $V$ to FALSE. We will see that sending one unit of resource to $V^{(2)}$ and one unit of resource to $V^{(3)}$ will make the makespan greater than the target makespan.

Clause gadget. The gadget corresponding to clause $C$ has $13$ vertices $C^{(i)}$ ($1\leq i\leq 13$) as shown in Figure 14. Vertices $C^{(2)}$ and $C^{(3)}$ are composite nodes each of order $8x$. If clause $C$ has three literals $V_{i},V_{j}$ and $V_{k}$, then vertex $C^{(5)}$ is connected to the vertices $V_{i}^{(6)},V_{j}^{(6)}$ and $V_{k}^{(5)}$. These vertices correspond to $\neg V_{i},\neg V_{j}$ and $V_{k}$ respectively. Vertex $C^{(6)}$ is connected to $V_{i}^{(6)},V_{j}^{(5)}$ and $V_{k}^{(6)}$ . These vertices correspond to $\neg V_{i},V_{j}$ and $\neg V_{k}$. Vertex $C^{(7)}$ is connected to $V_{i}^{(5)},V_{j}^{(6)}$ and $V_{k}^{(6)}$. These vertices correspond to $V_{i},\neg V_{j}$ and $\neg V_{k}$. There are $3$ composite nodes $C^{(8)},C^{(9)}$ and $C^{(10)}$ each of order $2x$. There is a chain of $7x+11$ vertices from $s$ to each vertex in $\left\{C^{(11)},C^{(12)},C^{(13)}\right\}$. We define the “earliest finish time” of a node $v$ as the time when all the write operations at $v$ are finished.

In a valid assignment of 1-in-3SAT, we show that for each clause $C$, exactly $2$ vertices of $C^{(5)},C^{(6)}$ and $C^{(7)}$ will have earliest finish time of $(6x+5)$ and the other one will have earliest finish time of $(5x+8)$. (Table 3)

Value of $x$. There is only one vertex ($V^{(7)}$) with out-degree zero in every variable gadget $V$. Also, in every clause gadget $C$, there are three vertices $C^{(11)},C^{(12)}$ and $C^{(13)}$, each with zero out-degree. So, if we connect all such vertices to the sink vertex $t$, then in-degree at $t$ will be $(n+3m)$. Let $k$ be the smallest power of $2$ such that $k\geq(n+3m)$. We perform a recursive binary splitting at vertex $t$. Let $y$ be the height of the binary splitting at $t$ where $y=\log k$. To make $8x>(7x+2y+12)$, we define x=max\big{(}(2y+13),8\big{)}. Hence, the path from any vertex from $\left\{V^{(7)},C^{(11)},C^{(12)},C^{(13)}\right\}$ to sink $t$ will take time $2y$.

Truth value assignment. Setting variable $V$ to TRUE implies sending $2$ units of resource through composite vertex $V^{(2)}$. The corresponding earliest finish time at vertex $V^{(5)}$ is $1+(x+4)+4x=5x+5$ and at vertex $V^{(6)}$ is $1+(2x+2)+4x=6x+3$. Similarly, setting variable $V$ to FALSE implies sending $2$ units of resource through vertex $V^{(3)}$. The corresponding earliest finish time at vertex $V^{(5)}$ is $1+(2x+2)+4x=6x+3$ and at vertex $V^{(6)}$ is $1+(x+4)+4x=5x+5$.

Lemma 4.5.

There exists a solution to the input instance of 1-in-3SAT iff there exists a valid flow of resource through the reduced DAG achieving a makespan of at most $7x+2y+12$ using at most $2n+4m$ units of resource.

Proof.

Forward direction. We now prove that if there is a solution to the 1-in-3SAT instance with $n$ variables and $m$ clauses, then the reduced DAG has a makespan of $7x+2y+12$ with $2n+4m$ units of resource.

If a variable $V$ is set to TRUE, then we allow $2$ units of resource to flow through vertex $V^{(2)}$ along the path $\langle S,V^{(1)},V^{(2)},V^{(4)}\rangle$, otherwise, we allow $2$ units of resource to flow through vertex $V^{3}$ along the path $\langle S,V^{(1)},V^{(3)},V^{(4)}\rangle$. Assigning TRUE to variable $V$ implies that the earliest finish times at vertex $V^{(5)}$ and $V^{(6)}$ are $5x+5$ and $6x+3$, respectively. Also, the earliest finish time at vertex $V^{(7)}$ is $1+(2+2x)+1+2+(4x+4)+x+2=7x+12$. In Figure 14, there are $3$ writers from variable gadgets that write on each of the nodes in $\left\{C^{(5)},C^{(6)},C^{(7)}\right\}$. If there are multiple writers ready to write to the same vertex at the same time, we serialize the write operations. For example, if $V_{i}=TRUE,C_{j}=FALSE$ and $V_{k}=FALSE$, then the writer from variable gadget $V_{i}$ is ready to write at time $5x+5$. The writers from $V_{j}$ and $V_{k}$ are ready to write at time $6x+3$. Hence, all three write operations can be completed at time $\max{\left\{5x+6,6x+4,6x+5\right\}}=6x+5$. From Table 3, it is evident that in clause $C$, if only one literal is TRUE and the other two are FALSE, then among $C^{(5)},C^{(6)}$ and $C^{(7)}$ only one vertex has an earliest finish time of $5x+8$ and the other two have $6x+5$. The vertex with starting time $5x+8$, can finish the activity corresponding to composite node (one of $C^{(8)},C^{(9)}$ and $C^{(10)}$) of order $2x$, in another $2x+2$ units of time without using any resource. Hence, it will finish at time $5x+8+2x+2=7x+10$. Each of the other two vertices with earliest finish time of $6x+5$ takes $2$ units of resource flowing from vertex $C^{(4)}$ and finishes the composite node’s activity at time $(6x+5)+(x+4)=7x+9$. There is a chain of $7x+11$ nodes from the source vertex to each of the vertices in $\left\{C^{(11)},C^{(12)},C^{(13)}\right\}$. Thus, the earliest finish time at each of those three vertices is $7x+12$. Together, with $2y$ units of time to sink vertex $t$, the total makespan is $7x+2y+12$.

Backward direction. To achieve a makespan of $7x+2y+12$, every variable gadget requires $2$ units of resource and each clause gadget requires $4$, otherwise the makespan will be $8x$ which is larger than $7x+2y+12$ because $x>2y+12$. Also, any resource used in a variable gadget cannot be used further in any other variable or clause gadget because the resource can be reused over a path only. Similarly, any resource used in any clause gadget cannot be reused in any other gadget. Only one vertex that is either $V^{(5)}$ or $V^{(6)}$, will have the earliest finish time of $5x+5$. Both cannot be $5x+5$, as there is only $2$ units of resource per variable gadget. Both cannot be $6x+3$ as in a clause $C$ where the literal $V$ or $\neg V$ is present, there is an edge from either $V^{(5)}$ or $V^{(6)}$ to each of $C^{(5)},C^{(6)}$ and $C^{(7)}$. This requires clause gadget $C$ to get $6$ units of resource to achieve a makespan $\leq 7x+2y+12$. But each clause gadget can have exactly $4$ units of resource. Thus, for every variable $V$, for it to be a valid assignment, $V$ is set to either TRUE or FALSE. From Table 3, if a clause has exactly one TRUE literal, then one of the vertices from $C^{(5)},C^{(6)}$ and $C^{(7)}$ has the earliest finish time of $5x+8$ and the other two have $6x+5$. This requires to have $4$ units of resource to achieve the earliest finish time $\leq 7x+10$ at each of the vertices from $\left\{C^{(8)},C^{(9)},C^{(10)}\right\}$. This can be achieved by assigning $2$ units of resource to those two composite nodes (from $C^{(8)},C^{(9)}$ and $C^{(10)}$) that start executing at time $6x+5$. The composite node that can start at time $5x+8$ does not use any extra resource. If the clause does not have exactly one TRUE literal, then the clause gadget would require $6$ units of resource to achieve the target makespan. However, we just argued that each clause gadget can have exactly $4$ units of resource. Thus, each clause has exactly one TRUE literal and the 1-in-3SAT instance is also satisfied. ∎

4.3. Underlying Bounded Treewidth Graph

Let $G(D)$ be the undirected graph obtained by ignoring the directedness of the edges of a given DAG $D$. In the case that $G(D)$ is a graph of bounded treewidth,222Recall that a tree decomposition of a graph $G=(V,E)$ is a tree $T$ with nodes $X_{1},X_{2},\ldots,X_{n}$, $X_{i}\subseteq V$, satisfying: (1) $\bigcup_{i}X_{i}=V$; (2) For edge $(u,v)\in E$ there exists a $X_{i}$ with $u,v\in X_{i}$; (3) For any two nodes, $X_{i}$ and $X_{j}$, in $T$, if node $X_{k}$ is in the (unique) path between $X_{i}$ and $X_{j}$ in $T$, then $X_{i}\cap X_{j}\subseteq X_{k}$. The width of the tree decomposition is $\max_{i}|X_{i}|-1$, and the treewidth of $G$ is the minimum width over all tree decompositions of $G$. we show that the offline minimum-makespan and minimum-resource problems on $D$ are (weakly) NP-hard. (Note that Theorem 4.1 proving the strong NP-hardness of the problems does not assume that the underlying undirected graph is of bounded treewidth.)

Theorem 4.6.

*It is weakly NP-hard to decide if there exists a solution to the (offline) discrete resource-time tradeoff problem, with resource reuse over paths and a non-increasing duration function, satisfying a resource bound $B$ and a makespan bound $T$, provided the undirected graph obtained by ignoring the directedness of the edges of the input DAG is of bounded treewidth. *

The proof of this theorem is based on a reduction from Partition(Garey and Johnson, 1979). The construction is shown in Figure 16. The input instance is a set $S=\{s_{1},s_{2},\ldots,s_{n}\}$ of $n$ positive integers; let $B=\sum_{i=1}^{n}s_{i}$. The Partition problem asks if there is a partition of $S$ into subsets $S_{1}$ and $S_{2}$ such that the sums of the values in the two subsets are the same (i.e., exactly $B/2$). In this construction we have a total of $B$ resources to allocate in our program. The value $M$ is chosen to be greater than $B/2$, the target makespan, ensuring that memory resources must be allocated to these nodes. This ensures that at least $s_{i}$ units of resource pass through each $v_{i}^{(1)}$, constructing our numbers. From each $v_{i}^{(1)}$ there are two choices of nodes, $v_{i}^{(2)}$ and $v_{i}^{(3)}$, to pass the resources onto each of which will either utilize $s_{i}$ resources or increase the makespan on that path by $s_{i}$. The pair also funnel the resources into a sink vertex $\overline{v_{0}}$ with a potential makespan cost of $M$ which ensures that their resources cannot be passed along to nodes $v_{j}^{(2)}$ and $v_{j}^{(3)}$ to the right (i.e., $j>i$). Thus the top and bottom paths represent our two sets and for each $v_{i}$ we must allocate $s_{i}$ makespan to either the top or the bottom path. Thus a total makespan of $B/2$ can only be achieved iff there is a partition of the $s_{i}$’s into two sets such that each set sums to $B/2$.

To see that the constructed graph has bounded treewidth, let $V_{i}=\{v_{i}^{(j)}\}$, where $1\leq j\leq 7$. Vertices $v_{i}^{(7)}$ for $1\leq i\leq n$ are connected to the sink vertex $\overline{v_{0}}$. Then $G$ has a tree decomposition $T$ with nodes $S_{i}$, $1\leq i\leq n$, as shown in Figure 16, with $S_{i}$ defined as follows: $S_{1}=\{v_{0},\overline{v_{0}}\}\cup V_{1}$; $S_{i}=\{v_{0},\overline{v_{0}}\}\cup V_{i-1}\cup V_{i}$, for $2\leq i\leq n$. We claim that $T$ is a valid tree decomposition. It is evident that $\cup_{1\leq i\leq n}S_{i}=V$.

From the construction of $S_{j}$ $(1\leq j\leq n)$, it is clear that, for each edge $(u,v)$ of the graph $G$, there exists a node $S_{j}$ with $u,v\in S_{j}$. For any $S_{i}$ and $S_{j}$, with $j>i+1$ and $1\leq i\leq(n-2)$, we have $S_{i}\cap S_{j}=\{v_{0},\overline{v_{0}}\}$, and, for any node $S_{k}$ ($i<k<j$), on the path between $S_{i}$ and $S_{j}$, we have $v_{0}\in S_{k}$ and $\overline{v_{0}}\in S_{k}$, so that $S_{i}\cap S_{j}\subseteq S_{k}$. Thus, $T$ is a valid tree decomposition, and it has width 15 ($\max_{i}|S_{i}|-1=15$), so the treewidth of $G$ is at most $15$.

5. Conclusion

In this paper we introduce the discrete resource-time tradeoff problem with resource reuse in which each unit of resource is routed along a source to sink path and is possibly used and reused to expedite activities encountered along that path. We consider two different objective functions: (1) optimize makespan given a limited resource budget and (2) optimize resource requirement given a target makespan.

Our original motivation came from a desire to mitigate the cost of data races in shared-memory parallel programs by using extra space to reduce the time it takes to perform conflict-free write operations to shared memory locations. We consider three duration functions: general non-increasing function for the general resource-time question, and recursive binary reduction and multiway (k-way) splitting for the space-time case.

We present the first hardness and approximation hardness results as well as the first approximation algorithms for our problems. We show that the makespan optimization problem is strongly NP-hard under all three duration functions. When the duration function is general non-increasing we also show that it is strongly NP-hard to achieve an approximation ratio less than $2$ for the makespan optimization problem and less than $\frac{3}{2}$ for the resource optimization problem. We give a $\left(\frac{1}{\alpha},\frac{1}{1-\alpha}\right)$ bi-criteria (resource, makespan) approximation algorithm for that same duration function, where $0<\alpha<1$. We present improved approximation ratios for the recursive binary reduction function and the multiway ($k$-way) splitting functions.

Acknowledgements.

This work is supported in part by NSF grants CCF-1439084, CCF-1526406, CNS-1553510, IIS-1546113 and US-Israel Binational Science Foundation grant number 2016116.

Appendix A Alternate hardness proof from numerical 3D matching

We give a polynomial-time reduction from the numerical 3-dimensional matching problem to the discrete resource-time tradeoff problem (with resource reuse over paths and a non-increasing duration function).

Numerical 3-dimensional matching problem: Given $A=$

$\{a_{1},a_{2},\cdots a_{n}\},B=\{b_{1},b_{2},\cdots b_{n}\},$ and $C=\{c_{1},c_{2},\cdots c_{n}\}$, partition $A\cup B\cup C$ into $n$ triples $S_{i}\in A\times B\times C$ of equal sum $T=(\sum A+\sum B+\sum C)/n$.

Given an instance of the numerical 3D matching problem, we create a DAG $D$ with source $s$ and sink $t$ as shown in Figure 18. For each $a_{i}\in A$, there is an edge $(s,a_{i})$ in $D$. The space-time tradeoff function at edge $(s,a_{i})$ is $\{\langle 0,\infty\rangle,\langle n,a_{i}\rangle\}$. Recall that, this means that with zero resource, it takes infinite time to finish the activity $(s,a_{i})$ and with $n$ units of resource it finishes in time $a_{i}$. We create a gadget that has $n$ incoming edges and $n$ outgoing edges. We call the gadget a bipartite matcher (Figure 18) as it matches (a $1:1$ mapping) the incoming edges to the outgoing edges. We describe the bipartite matcher in the next paragraph. For each $b_{i}\in B$, there is an edge $(b_{i},b_{i}^{{}^{\prime}})$ in $D$. The tradeoff function at edge $(b_{i},b_{i}^{{}^{\prime}})$ is $\{\langle 0,\infty\rangle,\langle n,b_{i}\rangle\}$. We put all the $n$ edges $(b_{i},b_{i}^{{}^{\prime}})$ to a bipartite matcher as its incoming edges. For each $c_{i}\in C$, there is an edge $(c_{i},t)$ in $D$. The tradeoff function at edge $(c_{i},t)$ is $\{\langle 0,\infty\rangle,\langle n,c_{i}\rangle\}$.

The bipartite matcher gadget. The gadget has $n$ incoming edges at vertices $\{x_{1},x_{2},\cdots x_{n}\}$ and $n$ outgoing edges from $\{z_{1},z_{2},\cdots z_{n}\}$. It maps the vertices from $\{x_{1},x_{2},\cdots x_{n}\}$ to those in $\{z_{1},z_{2},\cdots z_{n}\}$. The mapping is one to one. This works as follows. There are $n$ units of incoming resource at each vertices $x_{i}$. Every outgoing edge $(x_{i},y_{i}^{j})$ from $x_{i}$ ($1\leq j\leq n$) has a tradeoff function $\{\langle 0,\infty\rangle,\langle 1,0\rangle\}$. Hence, each of the outgoing edges $(x_{i},y_{i}^{j})$ from $x_{i}$ gets one unit of resource. The tradeoff function at edge $(y_{i},z_{i})$ is $\{\langle 0,\infty\rangle,\langle 1,0\rangle\}$ which forces $y_{i}^{j}$ to send one unit of resource to $y_{i}$. The tradeoff function at edge $(y_{i}^{j},z_{j}^{{}^{\prime}})$ is $\{\langle 0,M\rangle,\langle 1,0\rangle\}$. Thus, if $y_{i}^{j}$ sends one unit of resource to $y_{i}$, it cannot send any resource to $z_{j}^{{}^{\prime}}$ forcing the activity $(y_{i}^{j},z_{j}^{{}^{\prime}})$ to take $M$ units of time to finish. Here, $M>\max_{1\leq i\leq n}(a_{i})+\max_{1\leq i\leq n}(b_{i})+\max_{1\leq i\leq n}(c_{i})$. The tradeoff function at edge $(z_{j}^{{}^{\prime}},z_{j})$ is $\{\langle 0,\infty\rangle,\langle n-1,0\rangle\}$. There are $n$ incoming edges $(y_{i}^{j},z_{j}^{{}^{\prime}})$ to $z_{j}^{{}^{\prime}}$. Out of these $n$ incoming edges, $(n-1)$ edges flow $n-1$ units of resource to $z_{j}^{{}^{\prime}}$ which are then used for the activity at $(z_{j}^{{}^{\prime}},z_{j})$.

We now show the mapping through an example. Suppose $x_{1}$ is mapped to $z_{3}$. Then the corresponding flow is as follows: one unit of resource flows from $y_{1}^{3}$ to $y_{1}$. As the total incoming flow of resource at vertex $y_{1}^{3}$ is one, no resource flows from $y_{1}^{3}$ to $z_{3}^{{}^{\prime}}$. However, one unit of resource flows from each $y_{i}^{3}$ except $y_{1}^{3}$ to $z_{3}^{{}^{\prime}}$. The earliest start time $(EST)$ along path $\langle x_{1},y_{1}^{3},z_{3}^{{}^{\prime}}\rangle$ is $EST(x_{1})+M$ while that along path $\langle x_{i},y_{i}^{3},z_{3}^{{}^{\prime}}\rangle$ for $i\neq 1$ is $EST(x_{i})$. This makes the earliest start time at $z_{3}^{{}^{\prime}}$, $EST(z_{3}^{{}^{\prime}})=\max\{EST(x_{1})+M,EST(x_{i})\}=EST(x_{1})+M$. This holds true because $M>\max_{1\leq i\leq n}(a_{i})+\max_{1\leq i\leq n}(b_{i})+\max_{1\leq i\leq n}(c_{i})$. Also, $n-1$ units of resource flow to $z_{3}^{{}^{\prime}}$ and they are used for the activity $(z_{3}^{{}^{\prime}},z_{3})$ to finish in time [math]. Observe that no $y_{1}^{i}$ except $y_{1}^{3}$ can send resource to $y_{1}$. The gadget has a total resource-inflow of $n^{2}$. Each of $(z_{i}^{{}^{\prime}},z_{i})$ requires $n-1$ units of resource that sums up to $n^{2}-n$ units of resource. Each of $(y_{i},z_{i})$ requires one unit of resource, that sum up to $n$ units of resource. If two of $y_{1}^{i}$ sends a unit of resource each to $y_{1}$, then the total resource left to be used by all $(z_{i}^{{}^{\prime}},z_{i})$ is at most $n^{2}-n-1$. Thus at least one of $(z_{i}^{{}^{\prime}},z_{i})$ won’t get $n-1$ units of resource and will take infinite time. Hence, mapping $x_{i}$ to $y_{j}$ corresponds to flowing one unit of resource from $y_{i}^{j}$ to $y_{i}$ and vice-versa; this makes a one-to-one mapping from $\{x_{1},x_{2},\cdots x_{n}\}$ to $\{z_{1},z_{2},\cdots z_{n}\}$.

Lemma A.1.

There exists a solution to a input instance of numerical 3D matching if and only if there exists a valid flow of resource in the DAG such that the makespan is $2M+T$ with resource bound $B=n^{2}$.

Proof.

If there is a solution in the input instance of numerical 3D matching, then there are $n$ sets, each of type $\{a_{i},b_{j},c_{k}\}$ such that $a_{i}+b_{j}+c_{k}=T$. We use first bipartite matcher gadgets to map $a_{i}$ to $b_{j}$ and the second bipartite matcher to map $b_{j}^{{}^{\prime}}$ to $c_{k}$. Each bipartite matcher contributes $M$ in the makespan. $(s,a_{i}),(b_{j},b_{j}^{{}^{\prime}})$ and $(c_{k},t)$ adds $T$ to the makespan. Thus the makespan is eaxctly $2M+T$.

If the reduced DAG admits a makespan of $2M+T$ using $n^{2}$ units of resource, then there is also a solution to the input instance of numerical 3D matching. From the construction of bipartite 3D matching, there is a one-to-one mapping from $a_{i}$ to $b_{j}$ and from $b_{j}^{{}^{\prime}}$ to $c_{k}$. As the makespan is $2M+T$ and each bipartite matcher contributes $M$ to the makespan, this gives a solution to numerical 3D matching. ∎