15,042 research outputs found

    Towards Optimality in Parallel Scheduling

    Full text link
    To keep pace with Moore's law, chip designers have focused on increasing the number of cores per chip rather than single core performance. In turn, modern jobs are often designed to run on any number of cores. However, to effectively leverage these multi-core chips, one must address the question of how many cores to assign to each job. Given that jobs receive sublinear speedups from additional cores, there is an obvious tradeoff: allocating more cores to an individual job reduces the job's runtime, but in turn decreases the efficiency of the overall system. We ask how the system should schedule jobs across cores so as to minimize the mean response time over a stream of incoming jobs. To answer this question, we develop an analytical model of jobs running on a multi-core machine. We prove that EQUI, a policy which continuously divides cores evenly across jobs, is optimal when all jobs follow a single speedup curve and have exponentially distributed sizes. EQUI requires jobs to change their level of parallelization while they run. Since this is not possible for all workloads, we consider a class of "fixed-width" policies, which choose a single level of parallelization, k, to use for all jobs. We prove that, surprisingly, it is possible to achieve EQUI's performance without requiring jobs to change their levels of parallelization by using the optimal fixed level of parallelization, k*. We also show how to analytically derive the optimal k* as a function of the system load, the speedup curve, and the job size distribution. In the case where jobs may follow different speedup curves, finding a good scheduling policy is even more challenging. We find that policies like EQUI which performed well in the case of a single speedup function now perform poorly. We propose a very simple policy, GREEDY*, which performs near-optimally when compared to the numerically-derived optimal policy

    Common Due-Date Problem: Exact Polynomial Algorithms for a Given Job Sequence

    Full text link
    This paper considers the problem of scheduling jobs on single and parallel machines where all the jobs possess different processing times but a common due date. There is a penalty involved with each job if it is processed earlier or later than the due date. The objective of the problem is to find the assignment of jobs to machines, the processing sequence of jobs and the time at which they are processed, which minimizes the total penalty incurred due to tardiness or earliness of the jobs. This work presents exact polynomial algorithms for optimizing a given job sequence or single and parallel machines with the run-time complexities of O(nlogn)O(n \log n) and O(mn2logn)O(mn^2 \log n) respectively, where nn is the number of jobs and mm the number of machines. The algorithms take a sequence consisting of all the jobs (Ji,i=1,2,,n)(J_i, i=1,2,\dots,n) as input and distribute the jobs to machines (for m>1m>1) along with their best completion times so as to get the least possible total penalty for this sequence. We prove the optimality for the single machine case and the runtime complexities of both. Henceforth, we present the results for the benchmark instances and compare with previous work for single and parallel machine cases, up to 200200 jobs.Comment: 15th International Symposium on Symbolic and Numeric Algorithms for Scientific Computin

    A Novel Approach to the Common Due-Date Problem on Single and Parallel Machines

    Full text link
    This paper presents a novel idea for the general case of the Common Due-Date (CDD) scheduling problem. The problem is about scheduling a certain number of jobs on a single or parallel machines where all the jobs possess different processing times but a common due-date. The objective of the problem is to minimize the total penalty incurred due to earliness or tardiness of the job completions. This work presents exact polynomial algorithms for optimizing a given job sequence for single and identical parallel machines with the run-time complexities of O(nlogn)O(n \log n) for both cases, where nn is the number of jobs. Besides, we show that our approach for the parallel machine case is also suitable for non-identical parallel machines. We prove the optimality for the single machine case and the runtime complexities of both. Henceforth, we extend our approach to one particular dynamic case of the CDD and conclude the chapter with our results for the benchmark instances provided in the OR-library.Comment: Book Chapter 22 page

    Innovative systems for the transportation disadvantaged: towards more efficient and operationally usable planning tools

    Get PDF
    When considering innovative forms of public transport for specific groups, such as demand responsive services, the challenge is to find a good balance between operational efficiency and 'user friendliness' of the scheduling algorithm even when specialized skills are not available. Regret insertion-based processes have shown their effectiveness in addressing this specific concern. We introduce a new class of hybrid regret measures to understand better why the behaviour of this kind of heuristic is superior to that of other insertion rules. Our analyses show the importance of keeping a good balance between short- and long-term strategies during the solution process. We also use this methodology to investigate the relationship between the number of vehicles needed and total distance covered - the key point of any cost analysis striving for greater efficiency. Against expectations, in most cases decreasing fleet size leads to savings in vehicle mileage, since the heuristic solution is still far from optimality

    A Multicore Tool for Constraint Solving

    Get PDF
    *** To appear in IJCAI 2015 proceedings *** In Constraint Programming (CP), a portfolio solver uses a variety of different solvers for solving a given Constraint Satisfaction / Optimization Problem. In this paper we introduce sunny-cp2: the first parallel CP portfolio solver that enables a dynamic, cooperative, and simultaneous execution of its solvers in a multicore setting. It incorporates state-of-the-art solvers, providing also a usable and configurable framework. Empirical results are very promising. sunny-cp2 can even outperform the performance of the oracle solver which always selects the best solver of the portfolio for a given problem
    corecore