3,563 research outputs found
The Lazy Bureaucrat Scheduling Problem
We introduce a new class of scheduling problems in which the optimization is
performed by the worker (single ``machine'') who performs the tasks. A typical
worker's objective is to minimize the amount of work he does (he is ``lazy''),
or more generally, to schedule as inefficiently (in some sense) as possible.
The worker is subject to the constraint that he must be busy when there is work
that he can do; we make this notion precise both in the preemptive and
nonpreemptive settings. The resulting class of ``perverse'' scheduling
problems, which we denote ``Lazy Bureaucrat Problems,'' gives rise to a rich
set of new questions that explore the distinction between maximization and
minimization in computing optimal schedules.Comment: 19 pages, 2 figures, Latex. To appear, Information and Computatio
Scheduling periodic jobs using imprecise results
One approach to avoid timing faults in hard, real-time systems is to make available intermediate, imprecise results produced by real-time processes. When a result of the desired quality cannot be produced in time, an imprecise result of acceptable quality produced before the deadline can be used. The problem of scheduling periodic jobs to meet deadlines on a system that provides the necessary programming language primitives and run-time support for processes to return imprecise results is discussed. Since the scheduler may choose to terminate a task before it is completed, causing it to produce an acceptable but imprecise result, the amount of processor time assigned to any task in a valid schedule can be less than the amount of time required to complete the task. A meaningful formulation of the scheduling problem must take into account the overall quality of the results. Depending on the different types of undesirable effects caused by errors, jobs are classified as type N or type C. For type N jobs, the effects of errors in results produced in different periods are not cumulative. A reasonable performance measure is the average error over all jobs. Three heuristic algorithms that lead to feasible schedules with small average errors are described. For type C jobs, the undesirable effects of errors produced in different periods are cumulative. Schedulability criteria of type C jobs are discussed
Single-machine scheduling with stepwise tardiness costs and release times
We study a scheduling problem that belongs to the yard operations component of the railroad planning problems, namely the hump sequencing problem. The scheduling problem is characterized as a single-machine problem with stepwise tardiness cost objectives. This is a new scheduling criterion which is also relevant in the context of traditional machine scheduling problems. We produce complexity results that characterize some cases of the problem as pseudo-polynomially solvable. For the difficult-to-solve cases of the problem, we develop mathematical programming formulations, and propose heuristic algorithms. We test the formulations and heuristic algorithms on randomly generated single-machine scheduling problems and real-life datasets for the hump sequencing problem. Our experiments show promising results for both sets of problems
SICStus MT - A Multithreaded Execution Environment for SICStus Prolog
The development of intelligent software agents and other
complex applications which continuously interact with their
environments has been one of the reasons why explicit concurrency has
become a necessity in a modern Prolog system today. Such applications
need to perform several tasks which may be very different with respect
to how they are implemented in Prolog. Performing these tasks
simultaneously is very tedious without language support.
This paper describes the design, implementation and evaluation of a
prototype multithreaded execution environment for SICStus Prolog. The
threads are dynamically managed using a small and compact set of
Prolog primitives implemented in a portable way, requiring almost no
support from the underlying operating system
A Fully Polynomial-Time Approximation Scheme for Speed Scaling with Sleep State
We study classical deadline-based preemptive scheduling of tasks in a
computing environment equipped with both dynamic speed scaling and sleep state
capabilities: Each task is specified by a release time, a deadline and a
processing volume, and has to be scheduled on a single, speed-scalable
processor that is supplied with a sleep state. In the sleep state, the
processor consumes no energy, but a constant wake-up cost is required to
transition back to the active state. In contrast to speed scaling alone, the
addition of a sleep state makes it sometimes beneficial to accelerate the
processing of tasks in order to transition the processor to the sleep state for
longer amounts of time and incur further energy savings. The goal is to output
a feasible schedule that minimizes the energy consumption. Since the
introduction of the problem by Irani et al. [16], its exact computational
complexity has been repeatedly posed as an open question (see e.g. [2,8,15]).
The currently best known upper and lower bounds are a 4/3-approximation
algorithm and NP-hardness due to [2] and [2,17], respectively. We close the
aforementioned gap between the upper and lower bound on the computational
complexity of speed scaling with sleep state by presenting a fully
polynomial-time approximation scheme for the problem. The scheme is based on a
transformation to a non-preemptive variant of the problem, and a discretization
that exploits a carefully defined lexicographical ordering among schedules
Non-Preemptive Scheduling on Machines with Setup Times
Consider the problem in which n jobs that are classified into k types are to
be scheduled on m identical machines without preemption. A machine requires a
proper setup taking s time units before processing jobs of a given type. The
objective is to minimize the makespan of the resulting schedule. We design and
analyze an approximation algorithm that runs in time polynomial in n, m and k
and computes a solution with an approximation factor that can be made
arbitrarily close to 3/2.Comment: A conference version of this paper has been accepted for publication
in the proceedings of the 14th Algorithms and Data Structures Symposium
(WADS
- …