Shared processor scheduling

TL;DR

This paper extends existing algorithms for shared processor scheduling by providing an efficient $O(n \,\log\, n)$ algorithm for a specific class of instances and a 50% approximation for the general weighted case.

Contribution

It introduces an $O(n \log n)$ optimization algorithm for a class of instances where job orderings relate to processing times and weights, generalizing the unweighted case.

Findings

The algorithm efficiently solves a specific class of scheduling problems.

A 50% approximation algorithm is proposed for the general weighted problem.

The complexity of the weighted problem remains unresolved.

Abstract

We study the shared processor scheduling problem with a single shared processor where a unit time saving (weight) obtained by processing a job on the shared processor depends on the job. A polynomial-time optimization algorithm has been given for the problem with equal weights in the literature. This paper extends that result by showing an $O(n \log n)$ optimization algorithm for a class of instances in which non-decreasing order of jobs with respect to processing times provides a non-increasing order with respect to weights --- this instance generalizes the unweighted case of the problem. This algorithm also leads to a $\frac{1}{2}$-approximation algorithm for the general weighted problem. The complexity of the weighted problem remains open.

Equations

$$C_{\mathcal{S}}^{\mathcal{P}}(j)+\bigcup _{I\in {\mathcal{I}}_j}|I|=p_j,$$

$$\Sigma (\mathcal{S})=\sum _{j\in \mathcal{J}}{t}_j{w}_j.$$

$$\left[0,\max\{C_{\mathcal{S}}^{\mathcal{M}}(j)\hskip 2.84544pt\bigl{|}\bigr{.}\hskip 2.84544ptj\in\mathcal{J}\}\right],$$

$$s_{\mathcal{S}}^{\mathcal{M}}(j_i)=C_{\mathcal{S}}^{\mathcal{M}}(j_{i-1})\text{and}{C}_{\mathcal{S}}^{\mathcal{M}}(j_i)=C_{\mathcal{S}}^{\mathcal{P}}(j_i)=\left(p_i+s_{\mathcal{S}}^{\mathcal{M}}(j_i)\right)/2,$$

$$p_{\pi (i)}>p_{\pi (i+1)}$$

$$\text{there exists }\bar{j}\in \mathcal{J}\setminus A\text{ such that }\bar{j}>\pi (i+1)$$

$$A=\mathcal{J}$$

$$p_{\pi (i)}\le p_{\pi (i+1)}\text{ for each }i\in \{1,\dots ,k-1\},$$

$$l=\left(C_{\mathcal{S}}^{\mathcal{M}}(j)-s_{\mathcal{S}}^{\mathcal{M}}(j)\right)+\left(C_{\mathcal{S}}^{\mathcal{M}}(j+1)-s_{\mathcal{S}}^{\mathcal{M}}(j+1)\right)=\frac{p_j-t}{2}+\frac{p_{j+1}-t}{4},$$

$$x=\left(C_{\mathcal{S}}^{\mathcal{M}}(j+1)-s_{\mathcal{S}}^{\mathcal{M}}(j+1)\right)w_{j+1}+\left(C_{\mathcal{S}}^{\mathcal{M}}(j)-s_{\mathcal{S}}^{\mathcal{M}}(j)\right)w_j=\frac{p_{j+1}-t}{2}\left(w_{j+1}-\frac{w_j}{2}\right)+\frac{p_j-t}{2}{w}_j.$$

$$\Sigma (\mathcal{S})=c+x\text{for some }c\in \mathbb{R}.$$

$$l^{\prime }=\frac{p_{j+1}-t}{2}+\frac{p_j-t}{4}$$

$$x^{\prime }=\frac{p_j-t}{2}\left(w_j-\frac{w_{j+1}}{2}\right)+\frac{p_{j+1}-t}{2}{w}_{j+1}.$$

$$l^{\prime }-l=\frac{p_{j+1}-p_j}{4}.$$

$$t^{\prime }=t+\frac{p_j-t}{2}<t+\frac{p_j-t}{2}+\frac{p_{j+1}-t}{4}=t+l$$

$$(t,t^{\prime })=(t,t+(p_j-t)/2)$$

$$(t^{\prime },t+l)=(t+(p_j-t)/2,t+l)$$

$$\begin{array}{rlr}\Sigma ({\mathcal{S}}^{\prime })& =& c+(t^{\prime }-t)w_j+(t+l-t^{\prime })w_{j+1},\\ & =& c+\frac{p_j-t}{2}{w}_j+\frac{p_{j+1}-t}{4}{w}_{j+1}\end{array}$$

$$\Sigma ({\mathcal{S}}^{\prime })-\Sigma (\mathcal{S})=\frac{p_{j+1}-t}{4}(w_j-w_{j+1}).$$

$$q=\sum _{i^{\prime }=i+2}^k\frac{w_{\pi (i^{\prime })}}{2^{i^{\prime }-i-1}}.$$

$$w_{j+1}\ge q.$$

$$\epsilon =C_{{\mathcal{S}}^{\prime }}^{\mathcal{M}}(j+1)-s_{{\mathcal{S}}^{\prime }}^{\mathcal{M}}(j+1).$$

$$C_{{\mathcal{S}}^{\prime }}^{\mathcal{M}}(i^{\prime })=C_{\mathcal{S}}^{\mathcal{M}}(i^{\prime })=C_{\mathcal{S}}^{\mathcal{P}}(i^{\prime })=C_{{\mathcal{S}}^{\prime }}^{\mathcal{P}}(i^{\prime })$$

$$\left[0,C_{{\mathcal{S}}^{\prime }}^{\mathcal{M}}(j+1)-\epsilon \right)=\left[0,s_{{\mathcal{S}}^{\prime }}^{\mathcal{M}}(j+1)\right).$$

$$s_{{\mathcal{S}}^{\prime \prime }}^{\mathcal{M}}(\pi (i^{\prime }))=s_{{\mathcal{S}}^{\prime }}^{\mathcal{M}}(\pi (i^{\prime }))-\frac{\epsilon }{2^{i^{\prime }-i-2}},$$

$$C_{{\mathcal{S}}^{\prime \prime }}^{\mathcal{M}}(\pi (i^{\prime }))=C_{{\mathcal{S}}^{\prime }}^{\mathcal{M}}(\pi (i^{\prime }))-\frac{\epsilon }{2^{i^{\prime }-i-1}},$$

$$C_{{\mathcal{S}}^{\prime \prime }}^{\mathcal{P}}(\pi (i^{\prime }))=C_{{\mathcal{S}}^{\prime }}^{\mathcal{P}}(\pi (i^{\prime }))-\frac{\epsilon }{2^{i^{\prime }-i-1}}.$$

$$\Sigma ({\mathcal{S}}^{\prime \prime })=\Sigma ({\mathcal{S}}^{\prime })-\epsilon w_j+\epsilon \sum _{i^{\prime }=i+2}^k\frac{w_{i^{\prime }}}{2^{i^{\prime }-i-1}}=\Sigma ({\mathcal{S}}^{\prime })+\epsilon (q-w_j)>0$$

$$C_{{\mathcal{S}}^{\prime }}^{\mathcal{P}}(j+1)>C_{{\mathcal{S}}^{\prime }}^{\mathcal{M}}(j+1).$$

$$\epsilon =\frac{1}{2}\left(C_{{\mathcal{S}}^{\prime }}^{\mathcal{P}}(j+1)-s_{{\mathcal{S}}^{\prime }}^{\mathcal{M}}(\pi (i+2))\right).$$

Full text

Keywords: divisible jobs, scheduling, shared processor

1 Introduction

Consider a subcontracting system in which each agent $j$ has a job of duration $p_{j}$ to be executed. Such an agent can perform the work by itself, in which case the job ends after $p_{j}$ units of time, or it can send (subcontract) a part of length $s_{j}\leq p_{j}/2$ of this job to a subcontractor for processing. The subcontractor needs to complete this piece of agent’s $j$ job by $p_{j}-s_{j}$, i.e., the speedup in terms of the completion time that the agent achieves in this scenario is exactly $s_{j}$, or in other words, the work of agent $j$ is completed at time moment $p_{j}-s_{j}$. Whenever $s_{j}>0$, the subcontractor is rewarded by agent $j$: the payoff of executing $s_{j}$ units of $j$-th agent’s job is $s_{j}w_{j}$. The goal of the subcontractor is to maximize its total payoff under the condition that the parts of jobs received from different agents cannot be executed simultaneously by the subcontractor. Thus, in this subcontracting system all agents try to minimize completion times of their jobs (the parameters $p_{j}$ and $w_{j}$ are fixed for each agent $j$), i.e. they are willing to commission the biggest possible part of their jobs to the subcontractor. The subcontractor is the party that decides what amount, if any, of each job to process in order to maximize its total payoff.

The shared processor scheduling problem can be placed in a wider context of scheduling with presence of private (local) processors (machines), available only to a particular job or a set of jobs, and shared (global) processors that are available to all jobs. Then, some additional rules are given in order to specify the conditions under which a job can gain access to a shared processor in such systems. These systems can be run as either centralized or decentralized. The former typically has a single optimization criterion forcing all parties to achieve the same goal. The latter emphasizes that each party is trying to optimize its own goal, which may (and often does) lead to problems having no solutions which are optimal for each agent (job) individually. These problems can be seen as multi-criteria optimization or coordination problems. The latter and can be further subdivided into problems in which agents have complete knowledge about resources of other agents (complete information games) and problems without such a full knowledge (distributed systems) in the search for coordinating mechanisms. This work falls into the category of centralized problems as the subcontractor is deciding on the schedule that reflects its best interest.

The outline of this paper is as follows. In the next section we briefly survey the related work to provide a state of the art overview. Section 3 gives a formal statement of the scheduling problem we study and it introduces the necessary notation. Then, in Section 4, we recall some facts related to the problem, mainly the fact that when computing optimal schedules one may restrict attention to schedules that are called synchronized. This generally greatly reduces the formal arguments and algorithmic approach. Section 5 considers a restricted version of the problem in which it is assumed that for any pair of jobs, neither of the jobs can have weight and processing time to be strictly smaller than the other. We give an $O(n\log n)$-time optimization algorithm for this case, and we use it subsequently as a building block to obtain an $O(n\log n)$-time $1/2$-approximation algorithm for the general case in Section 6.

2 Related work

The shared processor scheduling problem has recently been studied by Vairaktarakis and Aydinliyim [10], Hezarkhani and Kubiak [7], and Dereniowski and Kubiak [6]. Vairaktarakis and Aydinliyim [10] consider the (unweighted) problem with a single shared processor and with each job allowed to use at most one time interval on the shared processor. This case is sometimes referred to as non-preemptive since jobs are not allowed preemption on the shared processor. [10] proves that there are optimal schedules that complete job execution on private and shared processor at the same time, we call such schedules synchronized, for the non-preemptive case with equal weights. It further shows that this guarantees that sequencing jobs in ascending order of their processing times leads to an optimal solution for the case. [7] observes that this algorithm also gives optimal solutions to the preemptive problem, where more than one interval can be used by a job on the shared processor, provided that all weights are equal. [6] consider shared multi-processor problem proving its strong NP-hardness and giving an efficient, polynomial-time algorithm for the shared multi-processor problem with equal weights. Also, it is shown in [6] that synchronized optimal schedules always exist for weighted multi-processor instances. Vairaktarakis and Aydinliyim [10] , Vairaktarakis [9], and Hezarkhani and Kubiak [7] also study decentralized subcontracting systems focusing on coordinating mechanisms to ensure their efficiency.

The motivation to study the shared processor scheduling problem comes from diverse applications. Vairaktarakis and Aydinliyim [10] consider it in the context of supply chains were subcontracting allows jobs to reduce their completion times by using a shared subcontractor’s processor. Bharadwaj et. al. [3] use the divisible load scheduling to reduce a job completion time in parallel and distributed computer systems, and Anderson [2] argues for using batches of potentially infinitely small items that can be processed independently of other items of the batch in scheduling job-shops. We refer the reader to Dereniowski and Kubiak [6] for more details on these applications.

We also remark multi-agent scheduling models in which each agent has its own optimality criterion and performs actions aimed at optimizing it. In these models, being examples of decentralized systems, agents usually have a number of non-divisible jobs to execute (depending on the optimization criterion this may be seen as having one divisible job, but restricted by allowing preemptions only at certain specified points). For minimization of weighted total completion time in such models see Lee et. al. [8] and weighted number of tardy jobs see Cheng, Ng and Yuan [5]. Bukchin and Hanany [4] give an example of a game-theoretic analysis to a problem of this type. For overviews and further references on the multi-agent scheduling we refer to the book by Agnetis et. al. [1].

3 Problem formulation

We are given a set $\mathcal{J}$ of $n$ preemptive jobs. Each job $j\in\mathcal{J}$ has its processing time $p_{j}$ and weight $w_{j}$. With each job $j\in\mathcal{J}$ we associate its private processor denoted by $\mathcal{P}_{j}$. Moreover, there exists a single shared processor, denoted by $\mathcal{M}$, that is available for all jobs. We follow the convention and notation from [6] to formulate the problem in this paper.

A schedule $\mathcal{S}$ is feasible if satisfies the following conditions:

• •

each job $j\in\mathcal{J}$ executes non-preemptively in a single time interval $(0,C_{\mathcal{S}}^{\mathcal{P}}(j))$ on its private processor and there is a (possibly empty) collection of open intervals $\mathcal{I}_{j}$ such that $j$ executes non-preemptively in each time interval $I\in\mathcal{I}_{j}$ on the shared processor,

• •

for each job $j\in\mathcal{J}$,

[TABLE]

• •

the time intervals in $\bigcup_{j\in\mathcal{J}}\mathcal{I}_{j}$ are pairwise disjoint.

Given a feasible schedule $\mathcal{S}$, for each job $j\in\mathcal{J}$ we call any maximal time interval in which $j$ executes on both private $\mathcal{P}_{j}$ and shared $\mathcal{M}$ simultaneously an overlap. The total overlap $t_{j}$ of job $j$ equals the sum of lengths of all overlaps for $j$. The total weighted overlap of $\mathcal{S}$ equals

[TABLE]

A feasible schedule that maximizes the total weighted overlap is called optimal.

The formulation our Weighted Single-Processor Scheduling problem (WSPS), is as follows.

• Instance:

A set of weighted jobs $\mathcal{J}$ with arbitrary given processing times.

• Goal:

Find an optimal schedule for $\mathcal{J}$.

4 Preliminaries

Let $\mathcal{S}$ be a feasible schedule. We denote by $s_{\mathcal{S}}^{\mathcal{M}}(j)$ and $C_{\mathcal{S}}^{\mathcal{M}}(j)$ the start time and the completion times of a job $j$ on the shared processor, respectively. For brevity we take $s_{\mathcal{S}}^{\mathcal{M}}(j)=C_{\mathcal{S}}^{\mathcal{M}}(j)=0$ if a job $j$ executes on its private processor only. Whenever $s_{\mathcal{S}}^{\mathcal{M}}(j)<C_{\mathcal{S}}^{\mathcal{M}}(j)$, i.e., some non-empty part of a job $j$ executes on $\mathcal{M}$, then we say that the job $j$ appears on $\mathcal{M}$ in schedule $\mathcal{S}$. If, in a schedule $\mathcal{S}$, there is no idle time on the shared processor in time interval

[TABLE]

then we say that $\mathcal{S}$ has no gaps. We have the following results form the literature.

Observation 4.1** **([6])

There exists an optimal schedule that has no gaps.

A schedule $\mathcal{S}$ is called non-preemptive if each job $j$ executes in $\mathcal{S}$ in time interval $[s_{\mathcal{S}}^{\mathcal{M}}(j),C_{\mathcal{S}}^{\mathcal{M}}(j)]$ on the shared processor. We say that a schedule is synchronized if it satisfies the following conditions:

1. (i)

it is non-preemptive and has no gaps, 2. (ii)

for each job $j$ that appears on the shared processor it holds $C_{\mathcal{S}}^{\mathcal{M}}(j)=C_{\mathcal{S}}^{\mathcal{P}}(j)$.

Theorem 1** **([6])

There exists an optimal synchronized schedule.

Consider a synchronized schedule $\mathcal{S}$. Let $A=\{j_{1},\ldots,j_{k}\}\subseteq\mathcal{J}$ be the set of all jobs that appear on $\mathcal{M}$ in $\mathcal{S}$, where the jobs are ordered according to their completion times in $\mathcal{S}$, i.e. $C_{\mathcal{S}}^{\mathcal{M}}(j_{1})<\cdots<C_{\mathcal{S}}^{\mathcal{M}}(j_{k})$. Note that the set $A$ and the order are enough to determine the schedule $\mathcal{S}$. Indeed, given the order $(j_{1},\ldots,j_{k})$ we obtain that for each $i\in\{1,\ldots,k\}$ (by proceeding with increasing values of $i$),

[TABLE]

where $C_{\mathcal{S}}^{\mathcal{M}}(j_{0})=0$. This formula implies that the start times and completion times can be iteratively computed for all jobs. Thus for synchronized schedules we write for brevity $\mathcal{S}=(j_{1},\ldots,j_{k})$ to refer to the schedule computed above.

5 A $O(nlogn)$-time optimal algorithm for antithetical instances

We call an instance $\mathcal{J}$ of the problem antithetical if for any two jobs $i$ and $j$ it holds: $p_{i}\leq p_{j}$ implies $w_{i}\geq w_{j}$. We call a schedule $\mathcal{S}$ processing time ordered if $\mathcal{S}=(j_{1},\ldots,j_{n})$, where $p_{j_{i}}\leq p_{j_{i+1}}$ for each $i\in\{1,\ldots,n-1\}$. Observe that by construction, $\mathcal{S}$ is synchronized and all jobs from $\mathcal{J}$ appear on the shared processor, see [10] and [7]. We now prove that any processing time ordered schedule is an optimal solution for an antithetical instance. This gives an $O(n\log n)$-time optimization algorithm for antithetical instances. We remark that this algorithm generalizes the previously known solutions for the unweighted case ($w_{1}=\cdots=w_{n}$) from [7, 10].

Lemma 5.1

A processing time ordered schedule is optimal for any antithetical instance of the problem WSPS.

Proof.

Let $\mathcal{S}$ be an optimal schedule for an antithetical instance $\mathcal{J}$. By Theorem 1 we can assume that $\mathcal{S}$ is synchronized. We assume without loss of generality that the jobs in $\mathcal{J}=\{1,\ldots,n\}$ are ordered in non-decreasing order of their processing times, i.e. $p_{1}\leq p_{2}\leq\cdots\leq p_{n}$. Let $A\subseteq\mathcal{J}$ be the set of jobs that appear on the shared processor in $\mathcal{S}$. Let $\pi(1),\pi(2),\ldots,\pi(k)$, $k=|A|$, be the order of jobs on the shared processor in $\mathcal{S}$, i.e., $\mathcal{S}=(\pi(1),\pi(2),\ldots,\pi(k))$.

The largest index $i\in\{1,\ldots,k-1\}$ such that either

[TABLE]

or

[TABLE]

is called the violation point of $\mathcal{S}$; set the violation point to be zero if no such index $i$ exists. Note that violation point equals zero only for processing time ordered schedules.

Among all optimal and synchronized schedules we take $\mathcal{S}$ to satisfy the following:

1. (a)

the number of jobs that appear on $\mathcal{M}$ in $\mathcal{S}$ is maximum, and 2. (b)

with respect to (a): the violation point of $\mathcal{S}$ is minimum.

We aim at proving that the violation point of $\mathcal{S}$ is zero, that is:

[TABLE]

and

[TABLE]

which immediately implies the lemma.

We prove these claims by contradiction. Let $i>0$ be the violation point of $\mathcal{S}$. By definition, we have that one of the cases (1) or (2) holds. We should arrive at a contradiction in both cases and we start by analyzing the case of (1), that is, we assume that (1) holds for the violation point $i$. For antithetical instances we have $w_{\pi(i)}\leq w_{\pi(i+1)}$. Also, for convenience let without loss of generality we denote $j=\pi(i+1)$ and $j+1=\pi(i)$. Thus $p_{j+1}>p_{j}$ by (1). In the next two paragraphs we describe a transition from $\mathcal{S}$ to a new schedule $\mathcal{S}^{\prime}$. This transition is depicted in Figure 1.

Consider the intervals in which the two jobs $j$ and $j+1$ execute on $\mathcal{M}$ in $\mathcal{S}$ and suppose that $j+1$ starts at $t$ on $\mathcal{M}$, $s_{\mathcal{S}}^{\mathcal{M}}(j+1)=t$. Since $\mathcal{S}$ is synchronized, the length $l=C_{\mathcal{S}}^{\mathcal{M}}(j)-s_{\mathcal{S}}^{\mathcal{M}}(j+1)$ of this sequence on the shared processor equals

[TABLE]

and its contribution $x$ to the value of objective function (total weighted overlap) equals

[TABLE]

Thus, we can express the total weighted overlap of $\mathcal{S}$ as follows:

[TABLE]

Before we formally define $\mathcal{S}^{\prime}$, we analyze the impact the reversed order of the two jobs $j$ and $j+1$ in the interval $(t,t+l)$ has on $\mathcal{S}$ and its objective function. Suppose for the time being that $j$ starts at $t$ on $\mathcal{M}$ and is followed by the job $j+1$ and that either job is executed in such a way that it completes on both $\mathcal{M}$ and its private processors at the same time. Then the length $l^{\prime}$ of the interval $(t,t+l^{\prime})$ occupied by these two jobs on the shared processor equals

[TABLE]

and its contribution $x^{\prime}$ to the value of objective function equals

[TABLE]

Clearly, $l^{\prime}>l$ for $p_{j+1}>p_{j}$ by

[TABLE]

The job $j$ completes at

[TABLE]

after the exchange. We construct the schedule $\mathcal{S}^{\prime}$ as follows: $\mathcal{S}$ and $\mathcal{S}^{\prime}$ are identical in time intervals $[0,t)$ and $(t+l,+\infty)$, the job $j$ executes in time interval

[TABLE]

in $\mathcal{S}^{\prime}$ and the job $j+1$ executes in time interval

[TABLE]

on processor $\mathcal{M}$ in $\mathcal{S}^{\prime}$. Note that $j$ finishes at the same time on its private and shared processor in $\mathcal{S}^{\prime}$ while the job $j+1$ does not have this property. Since $p_{j+1}>p_{j}$, $j+1$ completes $(p_{j+1}-p_{j})/4$ units later on its private processor. Thus $\mathcal{S}^{\prime}$ is not synchronized; see also Figure 1. The total weighted overlap of $\mathcal{S}^{\prime}$ is then by (5), (10) and (11):

[TABLE]

where $c$ is defined in (7). By (7) and (12) we obtain that the difference (in total weighted overlaps) between $\mathcal{S}^{\prime}$ and $\mathcal{S}$ is

[TABLE]

Since $p_{j+1}-t>0$ (this holds since the job $j+1$ appears on the shared processor in $\mathcal{S}$) and $w_{j}\geq w_{j+1}$, we have that $\varSigma(\mathcal{S}^{\prime})-\varSigma(\mathcal{S})\geq 0$. Note that if $w_{j}$ is strictly greater than $w_{j+1}$, then we obtain the desired contradiction with the optimality of $\mathcal{S}$. However, if $w_{j}=w_{j+1}$, or in other words $\varSigma(\mathcal{S})=\varSigma(\mathcal{S}^{\prime})$, then we need to use different arguments to arrive at a contradiction.

To that end denote

[TABLE]

We show that

[TABLE]

Suppose for a contradiction that $w_{j+1}<q$. To obtain a contradiction with this assumption we will convert $\mathcal{S}^{\prime}$ into a schedule $\mathcal{S}^{\prime\prime}$ with strictly greater total weighted overlap, which will contradict the optimality of the original schedule $\mathcal{S}$. This conversion is described in the next two paragraphs and depicted in Figure 2.

Let

[TABLE]

Observe that $\varepsilon>0$ by (9). By assumption $\mathcal{S}$ is synchronized and $\mathcal{S}$ and $\mathcal{S}^{\prime}$ are identical on $\mathcal{M}$ in time intervals $[C_{\mathcal{S}^{\prime}}^{\mathcal{M}}(j+1),+\infty)$. Thus

[TABLE]

for each job $i^{\prime}$ that appears on $\mathcal{M}$ and completes in $\mathcal{S}^{\prime}$ later than the job $j+1$. The schedule $\mathcal{S}^{\prime\prime}$ is defined as follows. Let, $\mathcal{S}^{\prime\prime}$ and $\mathcal{S}^{\prime}$ be identical on $\mathcal{M}$ in time interval

[TABLE]

Then, the job $j+1$ is not present on $\mathcal{M}$ in $\mathcal{S}^{\prime}$. It executes only on $\mathcal{P}_{j+1}$ in $\mathcal{S}^{\prime\prime}$. Finally, for each job $\pi(i^{\prime})$, $i^{\prime}\in\{i+2,\ldots,k\}$, we set:

[TABLE]

[TABLE]

[TABLE]

Both $\mathcal{S}^{\prime\prime}$ and $\mathcal{S}^{\prime}$ are the same on $\mathcal{P}_{i^{\prime}}$ for each $i^{\prime}\in\mathcal{J}\setminus\{j+1,\pi(i+2),\ldots,\pi(k)\}$, i.e., on each processor not specified by the formulas above.

Clearly, $\mathcal{S}^{\prime\prime}$ is feasible and synchronized. To compare its total weighted overlap to that of $\mathcal{S}^{\prime}$, note that on the one hand the value of $\mathcal{S}^{\prime\prime}$ decreases by $\varepsilon w_{j+1}$ in comparison to $\mathcal{S}^{\prime}$ since the job $j+1$ does not appear on $\mathcal{M}$ in $\mathcal{S}^{\prime\prime}$, on the other hand it increases since the subintervals with the jobs that follow $j+1$ on $\mathcal{M}$ get longer due to $j+1$ disappearance from $\mathcal{M}$. Hence

[TABLE]

because $\varepsilon>0$ and $w_{j}<q$ by assumption. Thus, we obtain a contradiction with the optimality of $\mathcal{S}$ (recall that $\varSigma(\mathcal{S})\leq\varSigma(\mathcal{S}^{\prime})$).

Having proved (14), we complete the proof of case (1) by performing another transformation of the schedule $\mathcal{S}^{\prime}$ to a new schedule $\mathcal{S}^{\prime\prime}$. We intend this transformation to also apply to the case of (2). Hence we will conduct the remaining part of the proof in such a way that we complete the proof of case (1) and carry out a complete proof of case (2) all at one time. Since, we will obtain a contradiction in both cases, the proof of both (3) and (4) will be completed. Thus, what we need is to define the $\mathcal{S}^{\prime}$ and the job $j+1$ in order to include the case (2) into our proof: for (2) we take $\mathcal{S}^{\prime}:=\mathcal{S}$, $j=\pi(i+1)$ and $j+1=\bar{j}$. (Recall that $\bar{j}$ is defined in (2) to be a job that does not appear on $\mathcal{M}$ and has processing time that is greater or equal to that of $\pi(i+1)$.) It will follow from the construction below that the transformation works for both $\mathcal{S}^{\prime}$, $j$ and $j+1$ used in the earlier part of the proof of case (1) and for the new $\mathcal{S}$, $\pi(i)$ and $\bar{j}$ in (2). Observe that, informally speaking, the only difference in both cases is that in case (1) the job $j+1$ is present on $\mathcal{M}$ and completes on $\mathcal{P}$ later than on $\mathcal{M}$ while in case (2) the job $j+1$ is not present on $\mathcal{M}$.

We have in particular

[TABLE]

Let

[TABLE]

We now obtain a schedule $\mathcal{S}^{\prime\prime}$ as follows. First, $\mathcal{S}^{\prime\prime}$ and $\mathcal{S}^{\prime}$ are identical on $\mathcal{M}$ in time interval $[0,C_{\mathcal{S}^{\prime}}^{\mathcal{M}}(j))$,

[TABLE]

and

[TABLE]

for each $i^{\prime}\in\{i+2,\ldots,k\}$. Informally, the start of the $\pi(i^{\prime})$-th job is postponed on $\mathcal{M}$ by $\varepsilon/2^{i^{\prime}-i-2}$ and its completion time is set up in such a way that this job completes on both $\mathcal{M}$ and $\mathcal{P}$ at the same time. Then, $s_{\mathcal{S}^{\prime\prime}}^{\mathcal{M}}(j+1)=C_{\mathcal{S}^{\prime\prime}}^{\mathcal{M}}(j)$, $C_{\mathcal{S}^{\prime\prime}}^{\mathcal{M}}(j+1)=s_{\mathcal{S}^{\prime\prime}}^{\mathcal{M}}(\pi(i+2))$ and the remaining part of $j+1$ executes on $\mathcal{P}_{j+1}$. Finally, the execution of the remaining jobs (those for which completion times on their private processors have not been defined above) on their private processors remains the same in $\mathcal{S}^{\prime\prime}$ as in $\mathcal{S}^{\prime}$.

We argue that the schedule $\mathcal{S}^{\prime\prime}$ is feasible. Clearly, the new time intervals in which job $j+1$ executes on $\mathcal{M}$ and $\mathcal{P}_{j+1}$ are correct. Moreover, $j+1$ completes on both processors at the same time. For the jobs that follow $j+1$ on $\mathcal{M}$, each of them also completes at the same time on $\mathcal{M}$ and its private processor. Therefore these jobs are executed correctly because by the choice of $i$, they are ordered on $\mathcal{M}$ (in $\mathcal{S}^{\prime}$ and also on $\mathcal{S}^{\prime\prime}$) with non-decreasing values of their processing times:

[TABLE]

This implies that $\mathcal{S}^{\prime\prime}$ is feasible and synchronized.

From the construction we obtain that

[TABLE]

Therefore, in case (1), we obtain by (14) that $\varSigma(\mathcal{S}^{\prime\prime})\geq\varSigma(\mathcal{S}^{\prime})$. In particular, if $\varSigma(\mathcal{S}^{\prime\prime})>\varSigma(\mathcal{S}^{\prime})$, then we have immediately a contradiction with the optimality of $\mathcal{S}$ since $\varSigma(\mathcal{S}^{\prime})\geq\varSigma(\mathcal{S})$. On the other hand, if $\varSigma(\mathcal{S}^{\prime\prime})=\varSigma(\mathcal{S}^{\prime})$, then the contradiction comes from the selection of $\mathcal{S}$ to be a schedule that minimizes the violation point $i$ (both $\mathcal{S}^{\prime\prime}$ and $\mathcal{S}$ have the same number of jobs present on the shared processor).

To consider case (2), observe that since $i$ is the violation point of $\mathcal{S}$, $w_{\pi(i+2)}\geq w_{\pi(i^{\prime})}$ for each $i^{\prime}\in\{i+2,\ldots,k\}$. Therefore,

[TABLE]

Hence by (16), $\varSigma(\mathcal{S}^{\prime\prime})>\varSigma(\mathcal{S}^{\prime})$ because $w_{j+1}\geq w_{\pi(i+2)}$. The latter inequality comes from the fact that the instance is antithetical and $p_{j+1}\leq p_{\pi(i+2)}$, which comes from the maximality of $i$ with respect to the conditions (1) and (2). Thus, we again have a contradiction with the choice of $\mathcal{S}$, which completes the proof of the lemma. ∎

6 A 1/2-approximation Algorithm

Let $0=q_{0}<q_{1}<\cdots<q_{\ell}$ and $u_{1},\ldots,u_{\ell}\geq 0$ for some $\ell\geq 1$. An envelope  for $q_{1},\ldots,q_{\ell}$ and $u_{1},\ldots,u_{\ell}$ is a step-function of non-negative $x$ defined as follows

[TABLE]

The area of the envelope $e$ is

[TABLE]

Let $\mathcal{J}$ be a set of jobs. Without loss of generality we assume $p_{1}\leq\cdots\leq p_{n}$, for any tie we assume the jobs that are tied are ordered in ascending order of their weights, i.e. the heaviest tied job comes last in the tie. A sequence of jobs $i_{1},\ldots,i_{\ell}$ for some $\ell\geq 1$, where $1\leq i_{1}<\cdots<i_{\ell}\leq n$, is called a key sequence for $\mathcal{J}$ if it satisfies the following conditions:

1. (i)

$i_{\ell}=n$, 2. (ii)

$w_{i_{1}}>\cdots>w_{i_{\ell}}$, 3. (iii)

$w_{k}\leq w_{i_{j}}$ for each $k\in I_{i_{j}}=\{i_{j-1}+1,\ldots,i_{j}\}$ and $j\in\{1,\ldots,\ell\}$, where $i_{0}=0$.

Clearly $p_{i_{1}}<\cdots<p_{i_{\ell}}$, thus $u(p_{i_{1}},\ldots,p_{i_{\ell}},w_{i_{1}},\ldots,w_{i_{\ell}},x)$ is an envelope; we refer to it as the upper envelope for $\mathcal{J}$. Let $u^{\ast}$ be the area of the upper envelope for $\mathcal{J}$.

Note that the key sequence always exists. This follows from the fact that it can be constructed ‘greedily’ by starting with picking the last job of the sequence (see (i)) and then iteratively selecting the predecessor of the previously selected job so that the predecessor has strictly bigger weight (see (ii)) and satisfies the condition (iii). Also, the key sequence is unique by the same argument.

We have the following simple observation.

Claim 6.1

For each $k\in\{1,\ldots,\ell\}$, w_{i_{k}}=\max\{w_{j}\hskip 2.84544pt\bigl{|}\bigr{.}\hskip 2.84544pti_{k}\leq j\leq n\}. ∎

The key sequence for $\mathcal{J}$ defines a synchronized schedule $\mathcal{S}_{\textup{key}}$ for $\mathcal{J}$ with the set of jobs executed on the shared processor being $\mathcal{J}_{\textup{key}}=\{i_{1},\ldots,i_{\ell}\}$ and the permutation of the jobs on the processor being $\pi(j)=i_{j}$ for $j\in\{1,\ldots,\ell\}$. The jobs in $\mathcal{J}\setminus\mathcal{J}_{\textup{key}}$ are executed on their private processors only. Following our notation introduced in Section 4, we get $\mathcal{S}_{\textup{key}}=(i_{1},\ldots,i_{\ell})$. We have the following lemma.

Lemma 6.2

For the schedule $\mathcal{S}_{\textup{key}}$ it holds $2\varSigma(\mathcal{S}_{\textup{key}})\geq u^{\ast}$.

Proof.

We argue that for each $k\in\{1,\ldots,\ell\}$,

[TABLE]

where $p_{i_{0}}=0$. Note that $s_{\mathcal{S}_{\textup{key}}}^{\mathcal{M}}(i_{k})\leq p_{i_{k-1}}$ for each $k\in\{1,\ldots,\ell\}$. Thus,

[TABLE]

for each $k\in\{1,\ldots,\ell\}$, which proves (17).

By (17),

[TABLE]

∎

We now prove that the area $u^{\ast}$ of the upper envelope for $\mathcal{J}$ is an upper bound on the value of optimal solution for $\mathcal{J}$. By Theorem 1, there exists an optimal synchronized schedule $\mathcal{S}_{\textup{opt}}$ for $\mathcal{J}$. Let $\mathcal{J}_{\textup{opt}}\subseteq\mathcal{J}$ be the set of jobs that appear on the shared processor in $\mathcal{S}_{\textup{opt}}$ and let $\pi$ be a permutation of jobs in $\mathcal{J}_{\textup{opt}}$ in $\mathcal{S}_{\textup{opt}}$. Thus, we have $\mathcal{S}_{\textup{opt}}=(\pi(1),\ldots,\pi(|\mathcal{J}_{\textup{opt}}|))$. It holds $0<C_{\mathcal{S}_{\textup{opt}}}^{\mathcal{M}}(\pi(1))<\cdots<C_{\mathcal{S}_{\textup{opt}}}^{\mathcal{M}}(\pi(|\mathcal{J}_{\textup{opt}}|))<p_{n}$ and therefore

[TABLE]

is an envelope for $C_{\mathcal{S}_{\textup{opt}}}^{\mathcal{M}}(\pi(1)),\ldots,C_{\mathcal{S}_{\textup{opt}}}^{\mathcal{M}}(\pi(|\mathcal{J}_{\textup{opt}}|))$ and $w_{\pi(1)},\ldots,w_{\pi(|\mathcal{J}_{\textup{opt}}|)}$. Let the area of this envelope be $e^{\ast}$. We have the following key result.

Lemma 6.3

It holds $e^{\ast}\leq u^{\ast}$.

Proof.

Observe that for each index $j\in\{1,\ldots,|\mathcal{J}_{\textup{opt}}|\}$ there exists $\tau(j)\in\{1,\ldots,n\}$ such that

[TABLE]

This follows from condition (i) in definition of key sequence. If, for a given $j$, there are several jobs $\tau(j)$ that satisfy the above, then take $\tau(j)$ to be the minimum one.

We argue that

[TABLE]

for each $j\in\{1,\ldots,|\mathcal{J}_{\textup{opt}}|\}$. Suppose for a contradiction that (19) does not hold. We consider two cases. In the first case let

[TABLE]

By condition (iii) in definition of the key sequence and the minimality of $\tau(j)$, $\pi(j)$ does not belong to the key sequence. But then, $w_{\pi(j)}>w_{i_{\tau(j)}}$ implies that there is $t$ such that $p_{\pi(j)}<p_{i_{t}}<p_{i_{\tau(j)}}$, which contradicts the choice of $\tau(j)$. In the second case let

[TABLE]

Take the minimum index $t$ such that $p_{i_{t}}\geq p_{\pi(j)}$. By condition (iii) in definition of the key sequence, $w_{i_{t}}\geq w_{\pi(j)}$. Since $w_{\pi(j)}>w_{i_{\tau(j)}}$, condition (ii) in definition of the key sequence implies that $i_{\tau(j)}$ does not belong to the key sequence — a contradiction. This completes the proof of (19).

Since the upper envelope for $\mathcal{J}$ is non-increasing function in $x$, we obtain by (18) and (19) that

[TABLE]

for each $x\geq 0$, which completes the proof. ∎

Since $\varSigma(\mathcal{S}_{\textup{opt}})=e^{\ast}$ and $\varSigma(\mathcal{S}_{\textup{key}})\leq\varSigma(\mathcal{S}_{\textup{opt}})$, Lemmas 6.2 and 6.3 give the following.

Corollary 2

It holds $e^{\ast}/2\leq\varSigma(\mathcal{S}_{\textup{key}})\leq e^{\ast}$. ∎

Theorem 3

The key sequence for $\mathcal{J}$ provides a $1/2$-approximation solution to the problem WSPS. This sequence can be found in time $O(n\log n)$ for any set of jobs $\mathcal{J}$, where $n=|\mathcal{J}|$. Moreover, the bound of $1/2$ is tight, i.e., for each $\varepsilon>0$ there exists a problem instance such that $\varSigma(\mathcal{S}_{\textup{key}})<\left(\frac{1}{2}+\varepsilon\right)\varSigma(\mathcal{S}_{\textup{opt}})$.

Proof.

The fact that the key sequence is a $1/2$-approximation of the optimal solution follows from Corollary 2. The key sequence can be constructed directly from the definition and sorting the jobs in $\mathcal{J}$ according to their processing times determines the $O(n\log n)$ running time.

To close we show that the 1/2 bound for the key sequences is tight. Take $\mathcal{J}$ to contain $n$ jobs, each of the same weight $w>0$ and the same length $p>0$. The key sequence consists of one job and therefore the value of the corresponding schedule $\mathcal{S}_{\textup{key}}$ is $\varSigma(\mathcal{S}_{\textup{key}})=wp/2$. Take a schedule $\mathcal{S}$ that places all jobs in $\mathcal{J}$ on the shared processor. We have $\varSigma(\mathcal{S})=wp(1-1/2^{n})$. For $\varepsilon>0$ take $n=\lceil\log(1/\varepsilon)\rceil$. If $\mathcal{S}_{\textup{opt}}$ is an optimal schedule, then

[TABLE]

∎

7 Open problems and further research

The complexity status of WSPS remains open. The generalized problem with multiple shared processors is strongly NP-hard [6] when the number of shared processors is a part of the input. However, it remains open whether the generalized problem with fixed number of processors is NP-hard (i.e., whether the multi-processor problem is FPT with respect to the number of processors). This complexity result and the open complexity questions clearly underline the difficulty in finding efficient optimization algorithms for the shared processor scheduling problem. The development of an efficient branch-and-bound algorithm for the problem remains unexplored so far. The 1/2-approximation algorithm along with the structural properties of optimal schedules presented in this paper and in [6] may prove useful building blocks of such an algorithm.

Acknowledgements

This research has been supported by the Natural Sciences and Engineering Research Council of Canada (NSERC) Grant OPG0105675 and by Polish National Science Center under contract DEC-2011/02/A/ST6/00201.