1,353 research outputs found
The energy scheduling problem: Industrial case-study and constraint propagation techniques
This paper deals with production scheduling involving energy constraints, typically electrical energy.
We start by an industrial case-study for which we propose a two-step integer/constraint programming method. From the industrial problem we derive a generic problem,the Energy Scheduling Problem (EnSP). We propose an extension of specific resource constraint propagation techniques to efficiently prune the search space for EnSP solving. We also present a branching scheme to solve the problem via
tree search.Finally,computational results are provided
Gang FTP scheduling of periodic and parallel rigid real-time tasks
In this paper we consider the scheduling of periodic and parallel rigid
tasks. We provide (and prove correct) an exact schedulability test for Fixed
Task Priority (FTP) Gang scheduler sub-classes: Parallelism Monotonic, Idling,
Limited Gang, and Limited Slack Reclaiming. Additionally, we study the
predictability of our schedulers: we show that Gang FJP schedulers are not
predictable and we identify several sub-classes which are actually predictable.
Moreover, we extend the definition of rigid, moldable and malleable jobs to
recurrent tasks
Efficient Algorithms for Scheduling Moldable Tasks
We study the problem of scheduling independent moldable tasks on
processors that arises in large-scale parallel computations. When tasks are
monotonic, the best known result is a -approximation
algorithm for makespan minimization with a complexity linear in and
polynomial in and where is
arbitrarily small. We propose a new perspective of the existing speedup models:
the speedup of a task is linear when the number of assigned
processors is small (up to a threshold ) while it presents
monotonicity when ranges in ; the bound
indicates an unacceptable overhead when parallelizing on too many processors.
For a given integer , let . In this paper, we propose a -approximation algorithm for makespan minimization with a
complexity where
(). As
a by-product, we also propose a -approximation algorithm for
throughput maximization with a common deadline with a complexity
Scheduling Parallel Jobs with Linear Speedup
We consider a scheduling problem where a set of jobs is distributed over parallel machines. The processing time of any job is dependent on the usage of a scarce renewable resource, e.g., personnel. An amount of k units of that resource can be allocated to the jobs at any time, and the more of that resource is allocated to a job, the smaller its processing time. The dependence of processing times on the amount of resources is linear for any job. The objective is to find a resource allocation and a schedule that minimizes the makespan. Utilizing an integer quadratic programming relaxation, we show how to obtain a (3+e)-approximation algorithm for that problem, for any e>0. This generalizes and improves previous results, respectively. Our approach relies on a fully polynomial time approximation scheme to solve the quadratic programming relaxation. This result is interesting in itself, because the underlying quadratic program is NP-hard to solve in general. We also briefly discuss variants of the problem and derive lower bounds.operations research and management science;
Solving a multiprocessor problem by column generation and branch-and-price
This work presents an algorithm for solving exactly a scheduling problem with identical
parallel machines and malleable tasks, subject to arbitrary release dates and due dates. The objective is to
minimize a function of late work and setup costs. A task is malleable if we can freely change the set of
machines assigned to its processing over the time horizon. We present an integer programming model, a
Dantzig-Wolfe decomposition reformulation and its solution by column generation. We also developed
an equivalent network flow model, used for the branching phase. Finally, we carried out extensive
computational tests to verify the algorithm’s efficiency and to determine the model’s sensitivity to
instance size parameters: the number of machines, the number of tasks and the size of the planning
horizon
05101 Abstracts Collection -- Scheduling for Parallel Architectures: Theory, Applications, Challenges
From 06.03.05 to 11.03.05, the Dagstuhl Seminar 05101 ``Scheduling for Parallel Architectures: Theory, Applications, Challenges\u27\u27 was held
in the International Conference and Research Center (IBFI), Schloss Dagstuhl.
During the seminar, several participants presented their current
research, and ongoing work and open problems were discussed. Abstracts of
the presentations given during the seminar as well as abstracts of
seminar results and ideas are put together in this paper. The first section
describes the seminar topics and goals in general
Holistic Slowdown Driven Scheduling and Resource Management for Malleable Jobs
In job scheduling, the concept of malleability has been explored since many
years ago. Research shows that malleability improves system performance, but
its utilization in HPC never became widespread. The causes are the difficulty
in developing malleable applications, and the lack of support and integration
of the different layers of the HPC software stack. However, in the last years,
malleability in job scheduling is becoming more critical because of the
increasing complexity of hardware and workloads. In this context, using nodes
in an exclusive mode is not always the most efficient solution as in
traditional HPC jobs, where applications were highly tuned for static
allocations, but offering zero flexibility to dynamic executions. This paper
proposes a new holistic, dynamic job scheduling policy, Slowdown Driven
(SD-Policy), which exploits the malleability of applications as the key
technology to reduce the average slowdown and response time of jobs. SD-Policy
is based on backfill and node sharing. It applies malleability to running jobs
to make room for jobs that will run with a reduced set of resources, only when
the estimated slowdown improves over the static approach. We implemented
SD-Policy in SLURM and evaluated it in a real production environment, and with
a simulator using workloads of up to 198K jobs. Results show better resource
utilization with the reduction of makespan, response time, slowdown, and energy
consumption, up to respectively 7%, 50%, 70%, and 6%, for the evaluated
workloads
- …