48,562 research outputs found
Cardinality Constrained Scheduling in Online Models
Makespan minimization on parallel identical machines is a classical and
intensively studied problem in scheduling, and a classic example for online
algorithm analysis with Graham's famous list scheduling algorithm dating back
to the 1960s. In this problem, jobs arrive over a list and upon an arrival, the
algorithm needs to assign the job to a machine. The goal is to minimize the
makespan, that is, the maximum machine load. In this paper, we consider the
variant with an additional cardinality constraint: The algorithm may assign at
most jobs to each machine where is part of the input. While the offline
(strongly NP-hard) variant of cardinality constrained scheduling is well
understood and an EPTAS exists here, no non-trivial results are known for the
online variant. We fill this gap by making a comprehensive study of various
different online models. First, we show that there is a constant competitive
algorithm for the problem and further, present a lower bound of on the
competitive ratio of any online algorithm. Motivated by the lower bound, we
consider a semi-online variant where upon arrival of a job of size , we are
allowed to migrate jobs of total size at most a constant times . This
constant is called the migration factor of the algorithm. Algorithms with small
migration factors are a common approach to bridge the performance of online
algorithms and offline algorithms. One can obtain algorithms with a constant
migration factor by rounding the size of each incoming job and then applying an
ordinal algorithm to the resulting rounded instance. With this in mind, we also
consider the framework of ordinal algorithms and characterize the competitive
ratio that can be achieved using the aforementioned approaches.Comment: An extended abstract will appear in the proceedings of STACS'2
Truthful Online Scheduling with Commitments
We study online mechanisms for preemptive scheduling with deadlines, with the
goal of maximizing the total value of completed jobs. This problem is
fundamental to deadline-aware cloud scheduling, but there are strong lower
bounds even for the algorithmic problem without incentive constraints. However,
these lower bounds can be circumvented under the natural assumption of deadline
slackness, i.e., that there is a guaranteed lower bound on the ratio
between a job's size and the time window in which it can be executed.
In this paper, we construct a truthful scheduling mechanism with a constant
competitive ratio, given slackness . Furthermore, we show that if is
large enough then we can construct a mechanism that also satisfies a commitment
property: it can be determined whether or not a job will finish, and the
requisite payment if so, well in advance of each job's deadline. This is
notable because, in practice, users with strict deadlines may find it
unacceptable to discover only very close to their deadline that their job has
been rejected
SELFISHMIGRATE: A Scalable Algorithm for Non-clairvoyantly Scheduling Heterogeneous Processors
We consider the classical problem of minimizing the total weighted flow-time
for unrelated machines in the online \emph{non-clairvoyant} setting. In this
problem, a set of jobs arrive over time to be scheduled on a set of
machines. Each job has processing length , weight , and is
processed at a rate of when scheduled on machine . The online
scheduler knows the values of and upon arrival of the job,
but is not aware of the quantity . We present the {\em first} online
algorithm that is {\em scalable} ((1+\eps)-speed
-competitive for any constant \eps > 0) for the
total weighted flow-time objective. No non-trivial results were known for this
setting, except for the most basic case of identical machines. Our result
resolves a major open problem in online scheduling theory. Moreover, we also
show that no job needs more than a logarithmic number of migrations. We further
extend our result and give a scalable algorithm for the objective of minimizing
total weighted flow-time plus energy cost for the case of unrelated machines
and obtain a scalable algorithm. The key algorithmic idea is to let jobs
migrate selfishly until they converge to an equilibrium. Towards this end, we
define a game where each job's utility which is closely tied to the
instantaneous increase in the objective the job is responsible for, and each
machine declares a policy that assigns priorities to jobs based on when they
migrate to it, and the execution speeds. This has a spirit similar to
coordination mechanisms that attempt to achieve near optimum welfare in the
presence of selfish agents (jobs). To the best our knowledge, this is the first
work that demonstrates the usefulness of ideas from coordination mechanisms and
Nash equilibria for designing and analyzing online algorithms
Online Scheduling on Identical Machines using SRPT
Due to its optimality on a single machine for the problem of minimizing
average flow time, Shortest-Remaining-Processing-Time (\srpt) appears to be the
most natural algorithm to consider for the problem of minimizing average flow
time on multiple identical machines. It is known that \srpt achieves the best
possible competitive ratio on multiple machines up to a constant factor. Using
resource augmentation, \srpt is known to achieve total flow time at most that
of the optimal solution when given machines of speed . Further,
it is known that \srpt's competitive ratio improves as the speed increases;
\srpt is -speed -competitive when .
However, a gap has persisted in our understanding of \srpt. Before this
work, the performance of \srpt was not known when \srpt is given
(1+\eps)-speed when 0 < \eps < 1-\frac{1}{m}, even though it has been
thought that \srpt is (1+\eps)-speed -competitive for over a decade.
Resolving this question was suggested in Open Problem 2.9 from the survey
"Online Scheduling" by Pruhs, Sgall, and Torng \cite{PruhsST}, and we answer
the question in this paper. We show that \srpt is \emph{scalable} on
identical machines. That is, we show \srpt is (1+\eps)-speed
O(\frac{1}{\eps})-competitive for \eps >0. We complement this by showing
that \srpt is (1+\eps)-speed O(\frac{1}{\eps^2})-competitive for the
objective of minimizing the -norms of flow time on identical
machines. Both of our results rely on new potential functions that capture the
structure of \srpt. Our results, combined with previous work, show that \srpt
is the best possible online algorithm in essentially every aspect when
migration is permissible.Comment: Accepted for publication at SODA. This version fixes an error in a
preliminary versio
- β¦