41 research outputs found
Performance Analysis of Modified SRPT in Multiple-Processor Multitask Scheduling
In this paper we study the multiple-processor multitask scheduling problem in
both deterministic and stochastic models. We consider and analyze Modified
Shortest Remaining Processing Time (M-SRPT) scheduling algorithm, a simple
modification of SRPT, which always schedules jobs according to SRPT whenever
possible, while processes tasks in an arbitrary order. The M-SRPT algorithm is
proved to achieve a competitive ratio of for
minimizing response time, where denotes the ratio between maximum job
workload and minimum job workload, represents the ratio between maximum
non-preemptive task workload and minimum job workload. In addition, the
competitive ratio achieved is shown to be optimal (up to a constant factor),
when there are constant number of machines. We further consider the problem
under Poisson arrival and general workload distribution (\ie, system),
and show that M-SRPT achieves asymptotic optimal mean response time when the
traffic intensity approaches , if job size distribution has finite
support. Beyond finite job workload, the asymptotic optimality of M-SRPT also
holds for infinite job size distributions with certain probabilistic
assumptions, for example, system with finite task workload
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
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, we did not know the performance of SRPT when given machines of speed 1+\eps for any 0 < \eps < 1 - 1/m.
We answer the question in this thesis. We show that SRPT is scalable on identical machines. That is, we show SRPT is (1+\eps)-speed O(1/\eps)-competitive for any \eps > 0. We also show that SRPT is (1+\eps)-speed O(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
Age-Optimal Updates of Multiple Information Flows
In this paper, we study an age of information minimization problem, where
multiple flows of update packets are sent over multiple servers to their
destinations. Two online scheduling policies are proposed. When the packet
generation and arrival times are synchronized across the flows, the proposed
policies are shown to be (near) optimal for minimizing any time-dependent,
symmetric, and non-decreasing penalty function of the ages of the flows over
time in a stochastic ordering sense
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
Improved Online Algorithm for Weighted Flow Time
We discuss one of the most fundamental scheduling problem of processing jobs
on a single machine to minimize the weighted flow time (weighted response
time). Our main result is a -competitive algorithm, where is the
maximum-to-minimum processing time ratio, improving upon the
-competitive algorithm of Chekuri, Khanna and Zhu (STOC 2001). We
also design a -competitive algorithm, where is the
maximum-to-minimum density ratio of jobs. Finally, we show how to combine these
results with the result of Bansal and Dhamdhere (SODA 2003) to achieve a
-competitive algorithm (where is the
maximum-to-minimum weight ratio), without knowing in advance. As shown
by Bansal and Chan (SODA 2009), no constant-competitive algorithm is achievable
for this problem.Comment: 20 pages, 4 figure
Minimizing Flow-Time on Unrelated Machines
We consider some flow-time minimization problems in the unrelated machines
setting. In this setting, there is a set of machines and a set of jobs,
and each job has a machine dependent processing time of on machine
. The flow-time of a job is the total time the job spends in the system
(completion time minus its arrival time), and is one of the most natural
quality of service measure. We show the following two results: an
approximation algorithm for minimizing the
total-flow time, and an approximation for minimizing the maximum
flow-time. Here is the ratio of maximum to minimum job size. These are the
first known poly-logarithmic guarantees for both the problems.Comment: The new version fixes some typos in the previous version. The paper
is accepted for publication in STOC 201