19,572 research outputs found
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
Reallocation Problems in Scheduling
In traditional on-line problems, such as scheduling, requests arrive over
time, demanding available resources. As each request arrives, some resources
may have to be irrevocably committed to servicing that request. In many
situations, however, it may be possible or even necessary to reallocate
previously allocated resources in order to satisfy a new request. This
reallocation has a cost. This paper shows how to service the requests while
minimizing the reallocation cost. We focus on the classic problem of scheduling
jobs on a multiprocessor system. Each unit-size job has a time window in which
it can be executed. Jobs are dynamically added and removed from the system. We
provide an algorithm that maintains a valid schedule, as long as a sufficiently
feasible schedule exists. The algorithm reschedules only a total number of
O(min{log^* n, log^* Delta}) jobs for each job that is inserted or deleted from
the system, where n is the number of active jobs and Delta is the size of the
largest window.Comment: 9 oages, 1 table; extended abstract version to appear in SPAA 201
Non-preemptive Scheduling in a Smart Grid Model and its Implications on Machine Minimization
We study a scheduling problem arising in demand response management in smart
grid. Consumers send in power requests with a flexible feasible time interval
during which their requests can be served. The grid controller, upon receiving
power requests, schedules each request within the specified interval. The
electricity cost is measured by a convex function of the load in each timeslot.
The objective is to schedule all requests with the minimum total electricity
cost. Previous work has studied cases where jobs have unit power requirement
and unit duration. We extend the study to arbitrary power requirement and
duration, which has been shown to be NP-hard. We give the first online
algorithm for the general problem, and prove that the problem is fixed
parameter tractable. We also show that the online algorithm is asymptotically
optimal when the objective is to minimize the peak load. In addition, we
observe that the classical non-preemptive machine minimization problem is a
special case of the smart grid problem with min-peak objective, and show that
we can solve the non-preemptive machine minimization problem asymptotically
optimally
On the periodic behavior of real-time schedulers on identical multiprocessor platforms
This paper is proposing a general periodicity result concerning any
deterministic and memoryless scheduling algorithm (including
non-work-conserving algorithms), for any context, on identical multiprocessor
platforms. By context we mean the hardware architecture (uniprocessor,
multicore), as well as task constraints like critical sections, precedence
constraints, self-suspension, etc. Since the result is based only on the
releases and deadlines, it is independent from any other parameter. Note that
we do not claim that the given interval is minimal, but it is an upper bound
for any cycle of any feasible schedule provided by any deterministic and
memoryless scheduler
Scheduling Bidirectional Traffic on a Path
We study the fundamental problem of scheduling bidirectional traffic along a
path composed of multiple segments. The main feature of the problem is that
jobs traveling in the same direction can be scheduled in quick succession on a
segment, while jobs in opposing directions cannot cross a segment at the same
time. We show that this tradeoff makes the problem significantly harder than
the related flow shop problem, by proving that it is NP-hard even for identical
jobs. We complement this result with a PTAS for a single segment and
non-identical jobs. If we allow some pairs of jobs traveling in different
directions to cross a segment concurrently, the problem becomes APX-hard even
on a single segment and with identical jobs. We give polynomial algorithms for
the setting with restricted compatibilities between jobs on a single and any
constant number of segments, respectively
Restart-Based Fault-Tolerance: System Design and Schedulability Analysis
Embedded systems in safety-critical environments are continuously required to
deliver more performance and functionality, while expected to provide verified
safety guarantees. Nonetheless, platform-wide software verification (required
for safety) is often expensive. Therefore, design methods that enable
utilization of components such as real-time operating systems (RTOS), without
requiring their correctness to guarantee safety, is necessary.
In this paper, we propose a design approach to deploy safe-by-design embedded
systems. To attain this goal, we rely on a small core of verified software to
handle faults in applications and RTOS and recover from them while ensuring
that timing constraints of safety-critical tasks are always satisfied. Faults
are detected by monitoring the application timing and fault-recovery is
achieved via full platform restart and software reload, enabled by the short
restart time of embedded systems. Schedulability analysis is used to ensure
that the timing constraints of critical plant control tasks are always
satisfied in spite of faults and consequent restarts. We derive schedulability
results for four restart-tolerant task models. We use a simulator to evaluate
and compare the performance of the considered scheduling models
- …