Scheduling on parallel machines considering job-machine dependency constraints

We study a scheduling problem in a multipurpose machine environment where every job can be processed by a subset of the machines operated in parallel, with the objective of minimizing makespan. We develop lower bounds, heuristic algorithms, and a branch-and-bound procedure. We perform an extensive computational experiment to assess how much flexibility is enough to render the multipurpose machine system equally efficient to an equivalent system of parallel identical machines. We find that very small amounts of flexibility appropriately distributed across processors provide nearly the same makespan performance as a system of fully flexible parallel machines.

Some clarifications and mathematical definitions which are concerned with the many fundamental concepts of computability theory based directly on the computer field, are presented. The sole aim of this paper is to attempt to bridge the gulf between the computer field on the one hand, and mathematics and logic on the other. The particular concepts are presented here for justification only: and therefore almost no theorems are included. (Fortunately there is no employer who could press me to prove the theorems!). The intention is to provide such mathematical definitions as would be very relevant to computers and to their languages, and even more, to their development and design.

In this paper, we discuss the use of specialized languages to give students experience with the basic concepts of computer science without encumbering the novice with the details of a fully-featured programming language. Using techniques developed in the area of domain-specific programming languages, we have created languages which lead directly into basic computational concepts such as abstraction, naming, types systems, and user interfaces without the associated clutter of a language such as Java. Using these languages, we can address traditional problem solving and, more importantly, address computing as a creative discipline. These programs are declarative: they describe media objects such as sound or animations.

Designing engaging exercises when students do not yet possess a lot of knowledge can be difficult. We show how we draw on students’ prior knowledge, along with basic introductory concepts, to design an elemental (but fun) port scan exercise in an introductory security testing module. While “capture the flag” is a security industry standard for exercises, it can require a lot of in-depth knowledge to properly implement and complete. Using basic computer science concepts such as ports and ASCII values, we design a simplified capture the flag exercise where students can make use of deductive reasoning to complete the game. Overall, the exercise was received favourably by the students who found it challenging but enriching.

In a multi-purpose machine (MPM) model there is a set of machines \({\mu _i}\left( {{\mu _{ij}}} \right) \subseteq \left\{ {{M_1},...,{M_m}} \right\}\) associated with a job J i (operation O ij ). J i (O ij ) has to be processed by one machine in the set µ i (µ ij ). Thus, scheduling problems with multi-purpose machines combine assignment and scheduling problems; we have to schedule each job J i (operation O ij ) on machines from the set µ i (µ ij ).

The Dial-a-Ride problem may contain various constraints for pickup-delivery requests, such as time windows and ride time constraints. For a tour, given as a sequence of pickup and delivery stops, there exist polynomial time algorithms to find a schedule respecting these constraints, provided that there exists one. However, if no feasible schedule exists, the natural question is to find a schedule minimising constraint violations. We model a generic fixed-sequence scheduling problem, allowing lateness and ride time violations with linear penalty functions and prove its APX-hardness. We also present an approach leading to a polynomial time algorithm if only the time window constraints can be violated (by late visits). Then, we show that the problem can be solved in polynomial time if all the ride time constraints are bounded by a constant. Lastly, we give a polynomial time algorithm for the instances where all the pickups precede all the deliveries in the sequence of stops.

A heuristic algorithm is developed for the classical scheduling problem in which independent jobs are nonpreemptively scheduled on identical parallel machines with the objective of minimizing the makespan with load balancing. The algorithm uses iteratively the LPT procedure to be successful computational tools in many hard Combinatorial Optimization problems. We present an approximation algorithm based on balance the Hopfild with binary decision variables which are a kind of assignment variables for the classical deterministic scheduling problem of minimizing the makespan on identical machines. These problems are characterized by their complexity, known as NP-hard in most cases. Computational results indicate that the proposed algorithm is very competitive with respect to well-known constructive algorithms for a large number of benchmark.

An auction mechanism for capacity allocation in identical parallel machines with time window constraints

Two extensions of the classical scheduling model with two parallel identical machines and a partially ordered set of unit execution time tasks are considered. It is well known that the Coffman—Graham algorithm constructs for this model a so-called ideal schedule: that is, a schedule which is optimal for both makespan and total completion time criteria simultaneously. The question of the existence of such a schedule for the extension of this model, where each task has a release time, has remained open over several decades. The paper gives a positive answer to this question and presents the corresponding polynomial-time algorithm. Another straightforward generalization of the considered classical model is obtained by the introduction of multiprocessor tasks. It is shown that, despite the fact that a slightly modified Coffman-Graham algorithm solves the makespan problem with multiprocessor tasks for arbitrary precedence constraints, generally an ideal schedule does not exist and the problem with the criterion of total completion time turns out to be NP-hard in the strong sense even for in-trees.

A new polynomial algorithm is developed for the classical multiprocessor scheduling problem in which independent jobs are nonpreemptively scheduled on identical parallel machines with the objective of minimizing the makespan, i.e. the latest job finishing time. The algorithm at first generates and merges a set of partial solutions in order to obtain a feasible solution for the multiprocessor scheduling problem. Then a set of bin packing problems are solved in order to improve the solution, by iteratively using a MultiFit type procedure on different job sets. The effectiveness of this approach is evaluated by solving a large number of benchmark instances. The results indicate that the proposed algorithm, called PSMF, is very competitive with well known constructive algorithms for a wide range of instances. Furthermore, PSMF is competitive with respect to some of the best heuristics for parallel machine scheduling problems only when it uses a 2-exchange procedure.

A branch and bound algorithm for an identical parallel machine scheduling problem with a job splitting property

This paper deals with a multiobjective parallel machines scheduling problem. It consists in scheduling n independent jobs on m identical parallel machines. The job data such as processing times, release dates, due dates and sequence dependent setup times are considered. The goal is to optimize two different objectives: the makespan and the total tardiness. A mixed integer linear program is proposed to model the studied problem. As this problem is NP-hard in the strong sense, a metaheuristic method which is the second version of the non dominated sorting genetic algorithm (NSGA-II) is proposed to solve this problem. Since the parameters setting of a genetic algorithm is difficult, a fuzzy logic controller coupled with the NSGA-II (FLC-NSGA-II) is therefore proposed. The role of the fuzzy logic is to better set the crossover and the mutation probabilities in order to update the search ability. After that, an exact method based on the two phase method is also developed. We have used four measuring criteria to compare these methods. The experimental results show the advantages and the efficiency of FLC-NSGA-II.

We consider the problem of scheduling orders on identical machines in parallel. Each order consists of one or more individual jobs. A job that belongs to an order can be processed by any one of the machines. Multiple machines can process the jobs of an order concurrently. No setup is required if a machine switches over from one job to another. Each order is released at time zero and has a positive weight. Preemptions are not allowed. The completion time of an order is the time at which all jobs of that order have been completed. The objective is to minimize the total weighted completion time of the orders. The problem is NP‐hard for any fixed number (≥2) of machines. Because of this, we focus our attention on two classes of heuristics, which we refer to as sequential two‐phase heuristics and dynamic two‐phase heuristics. We perform a worst case analysis as well as an empirical analysis of nine heuristics. Our analyses enable us to rank these heuristics according to their effectiveness, taking solution quality as well as running time into account. © 2006 Wiley Periodicals, Inc. Naval Research Logistics, 2006

The annual Alzheimer’s Association International Conference (AAIC) took place in London, UK in July 2017. In an expert interview, Roxana Carare recaps on the topic of her presentation during the ‘Emerging Concepts in Basic Science’ session, clearance of interstitial fluid of the brain and pathogenesis of dementia.1

The suffix array is a fundamental data structure to support string analysis efficiently. It took about 26 years for the sequential suffix array construction algorithm to achieve $$\mathcal {O}(n)$$ time complexity and in-place sorting. In this paper, we develop the D-Limited Parallel Induce (DLPI) algorithm, the first $$\mathcal {O}(\frac{n}{p})$$ time parallel suffix array construction algorithm. The basic idea of DLPI includes two aspects: dividing the $$\mathcal {O}(n)$$ size problem into p reduced sub-problems with size $$\mathcal {O}(\frac{n}{p})$$ so we can handle them on p processors in parallel; developing an efficient parallel induce sorting method to achieve correct order for all the reduced sub-problems. The complete algorithm description is given to show the implementation method of the proposed idea. The time and space complexity analysis and proof are also given to show the correctness and efficiency of the proposed algorithm. The proposed DLPI algorithm can handle large strings with scalable performance.