Service Time Optimization of Mixed-Line Flow Shop Systems

We consider deterministic mixed-line flow shop systems that are composed of controllable and uncontrollable machines. Arrival times and completion deadlines of jobs are assumed to be known, and they are processed in the order they arrive at the machines. We model these flow shops as serial networks of queues operating under a non-preemptive first-come-first-served policy, and employ max-plus algebra to characterize the system dynamics. Defining completion-time costs for jobs and service costs at controllable machines, a non-convex optimization problem is formulated where the control variables are the constrained service times at the controllable machines. In order to simplify this optimization problem, under some cost assumptions, we show that no waiting is observed on the optimal sample path at the downstream of the first controllable machine. We also present a method to decompose the optimization problem into convex subproblems. A solution algorithm utilizing these findings is proposed, and a numerical study is presented to evaluate the performance improvement due to this algorithm.      

Mean value analysis of re-entrant line with batch machines and multi-class jobs

We propose an approximate approach for estimating the performance measures of the re-entrant line with single-job machines and batch machines based on the mean value analysis (MVA) technique. Multi-class jobs are assumed to be processed in predetermined routings, in which some processes may utilize the same machines in the re-entrant fashion. The performance measures of interest are the steady-state averages of the cycle time of each job class, the queue length of each buffer, and the throughput of the system. The system may not be modeled by a product form queueing network due to the inclusion of the batch machines and the multi-class jobs with different processing times. Thus, we present a methodology for approximately analyzing such a re-entrant line using the iterative procedures based upon the MVA and some heuristic adjustments. Numerical experiments show that the relative errors of the proposed method are within 5% as compared against the simulation results.Scope and purposeWe consider a re-entrant shop with multi-class jobs, in which jobs may visit some machines more than once at different stages of processing, as observed in the wafer fabrication process of semiconductor manufacturing. The re-entrant line also consists of both the single-job machine and the batch machine. The former refers to the ordinary machine processing one job at a time, and the latter means the machine processing several jobs together as a batch at a time. In this paper, we propose an approximation method based on the mean value analysis for estimating the mean cycle time of each class of jobs, the mean queue length of each buffer, and the throughput of the system.     

基于规则的平行机台生产调度系统

针对某电器生产的平行机台调度系统，描述了该系统的组成结构与数据接口界定。     

Preemptive online scheduling with rejection of unit jobs on two uniformly related machines

We consider preemptive online and semi-online scheduling of unit jobs on two uniformly related machines. Jobs are presented one by one to an algorithm, and each job has a rejection penalty associated with it. A new job can either be rejected, in which case the algorithm pays its rejection penalty, or it can be scheduled preemptively on the machines, in which case it may increase the maximum completion time of any machine in the schedule, also known as the makespan of the constructed schedule. The objective is to minimize the sum of the makespan of the schedule of all accepted jobs and the total penalty of all rejected jobs. We study two versions of the problem. The first one is the online problem where the jobs arrive unsorted, and the second variant is the semi-online case, where the jobs arrive sorted by a non-increasing order of penalties. We also show that the variant where the jobs arrive sorted by a non-decreasing order of penalties is equivalent to the unsorted one. We design optimal online algorithms for both cases. These algorithms have smaller competitive ratios than the optimal competitive ratio for the more general problem with arbitrary processing times (except for the case of identical machines), but larger competitive ratios than the optimal competitive ratio for preemptive scheduling of unit jobs without rejection.     

An aggregation procedure for the deterministic job-shop problem

A new approach is proposed in this paper to solve the job-shop scheduling problem. Instead of considering operations or machines, the construction of partial schedules by dealing with jobs, one after the other, is suggested. A partial schedule for given jobs is characterized by the sequence of their operations on each machine. The principle of the algorithm is to aggregate a new job on the current schedule, i.e. to insert its operations without altering the previous order. Two main theoretical results are presented: firstly, the selection procedure for jobs and secondly, the aggregation algorithm. Next the method is explained using a simple example. Finally, the authors present and comment on computational results for an implementation of the algorithm, for some well-known job-shop problems.     

Multi-stage resource-aware scheduling for data centers with heterogeneous servers

This paper presents a three-stage algorithm for resource-aware scheduling of computational jobs in a large-scale heterogeneous data center. The algorithm aims to allocate job classes to machine configurations to attain an efficient mapping between job resource request profiles and machine resource capacity profiles. The first stage uses a queueing model that treats the system in an aggregated manner with pooled machines and jobs represented as a fluid flow. The latter two stages use combinatorial optimization techniques to solve a shorter-term, more accurate representation of the problem using the first-stage, long-term solution for heuristic guidance. In the second stage, jobs and machines are discretized. A linear programming model is used to obtain a solution to the discrete problem that maximizes the system capacity given a restriction on the job class and machine configuration pairings based on the solution of the first stage. The final stage is a scheduling policy that uses the solution from the second stage to guide the dispatching of arriving jobs to machines. We present experimental results of our algorithm on both Google workload trace data and generated data and show that it outperforms existing schedulers. These results illustrate the importance of considering heterogeneity of both job and machine configuration profiles in making effective scheduling decisions.     

Minimizing the makespan on a batch machine with non-identical job sizes: an exact procedure

A batch processing machine can simultaneously process several jobs forming a batch. This paper considers the problem of scheduling jobs with non-identical capacity requirements, on a single-batch processing machine of a given capacity, to minimize the makespan. The processing time of a batch is equal to the largest processing time of any job in the batch. We present some dominance properties for a general enumeration scheme and for the makespan criterion, and provide a branch and bound method. For large-scale problems, we use this enumeration scheme as a heuristic method.Scope and purposeUsually in classical scheduling problems, a machine can perform only one job at a time. Although, one can find machines that can process several jobs simultaneously as a batch. All jobs of a same batch have common starting and ending times. Batch processing machines are encountered in many different environments, such as burn-in operations in semiconductor industries or heat treatment operations in metalworking industries. In the first case, the capacity of the machine is defined by the number of jobs it can hold. In the second case, each job has a certain capacity requirement and the total size of a batch cannot exceed the capacity of the machine. Hence, the number of jobs contained in each batch may be different. In this paper, we consider this second case (which is more difficult) and we provide an exact method for the makespan criterion (minimizing the last ending time).     

基于Petri网的JSP动态优化调度

提出一种在柔性制造系统动态优化调度中处理紧急定单的方法。以带有控制器的 Petri 网为建模工具对柔性生产调度中的离散事件建模,对系统的设备维护、各种优先级等特性进行描述,利用遗传算法和模拟退火算法获得调度结果,用于解决作业车间的加工受到机床、操作工人等双资源制约条件下的动态优化调度。当有紧急定单需要加工时,该方法把剩余任务和紧急任务作为两个独立的任务分别处理,然后进行集成,在紧急任务为最优调度的基础上选取剩余任务的最优调度,找到兼顾整体和局部的最优解。仿真结果说明了算法的有效性和鲁棒性。     

An interactive micro-computer software for general three machines flow shop sequencing problems

The order in which jobs pass through machines or work centres is a sequencing problem. The sequencing problems occur in flow shop as well as job shop production systems. In flow shop production systems, each job follows the same processing route whereas in the job shop production system, jobs flow across machines or work stations on many different routes. For optimizing the sequencing of such jobs, production planners may adopt different criteria such as makespan time, average completion time, due date performance, machine utilization and so forth. In the absence of given criteria, it is usual to accept the makespan time as the criteria and to attempt to minimize this. In a 2-machines flow shop, the jobs can be sequenced optimally for minimum total makespan time by using Johnson's algorithm [1]. Johnson's algorithm can also be used to find the optimal sequence for special three-machines flow shop problems satisfying certain conditions [1]. But for general three-machines sequencing problems, optimal sequence based on makespan time can be obtained by using a branch and bound solution procedure [1].

In this paper, the branch-and-bound procedure have been used to develop an interactive program in BASIC for finding the optimal job sequence for general three-machines flow shop problems. This program which is written for an IBM-PC or IBM-PC compatibles, also provides the time chart and the time chart drawing. Furthermore, it gives the results of the branching steps (i.e the partial sequences) in a tabular form.     

Receding Horizon Control of Mixed Line Flow Shop Systems

We consider reliable mixed line flow shop systems that are composed of controllable and uncontrollable machines. These systems are assumed to receive arrivals at random instants and process jobs deterministically in the order of arrival so as to depart them before their deadlines that are revealed at the time of arrival. We model these flow shops as serial networks of queues operating under a non-preemptive first-come-first-served policy. Defining completion-time costs for jobs and process costs at controllable machines, a stochastic convex optimization problem is formulated where the control variables are the constrained service times of jobs at the controllable machines. As an on-line solution method to determine these service times, we propose a receding horizon controller, which solves a deterministic problem at each decision instant. We quantify the available future information by the look-ahead window size. Numerical examples demonstrate the value of information and that the no-waiting property of the full-information case is not observed in the partial-information case.     

A decentralized model for flow shop production with flexible transportation system

The recent advances in technology sectors often clash with traditional organizational paradigms which can limit or make difficult an efficient implementation in the real world. In this paper we show how it is possible to exploit the advantages of innovative technologies in manufacturing when these are supported by new and efficient methods for production management. More in details, we face a flow shop scheduling problem in a shoe manufacturing system in which overtaking of jobs is allowed thanks to an innovative transportation system. Overtaking means that a job can be put in waiting state and another job can surpass it, allowing the change of the scheduling sequence. Preemption is not allowed. The objective function of the problem is the minimization of the maximum lateness. We propose a decentralized model, based on multi-agent system theory, to represent the production cells of the plant and to include the potentiality offered by overtaking of jobs at decisional level. The adoption of a decentralized approach increases the system flexibility since each machine is able to solve its local scheduling problem. Adding or removing machines to the plant will not imply a change in the scheduling algorithms. The outcomes of this work are reached firstly through a formulation of the problem with three flow shop scheduling models, secondly through a comparison of the models with respect to different performance indicators. The results highlight as the decentralized approach is able to reach comparable performances with the centralized one for a relevant number of instances. Moreover sensitivity analysis shows as in the decentralized model the computational time required to solve bigger instances increases less quickly than in the case of centralized ones. Finally, simulations of the decentralized approach clarify as the correlation of the local solution procedure is effected by the number of machines of the flow shop and the coordination mechanism is effected by the number of the jobs to be scheduled.     

Scheduling Parallel Machines for the Customer Order Problem

This paper considers scheduling problems where jobs are dispatched in batches. The objective is to minimize the sum of the completion times of the batches. While a machine can process only one job at a time, multiple machines can simultaneously process jobs in a batch. This simple environment has a variety of real world applications such as part kitting and customer order scheduling.A heuristic is presented for the parallel machine version of the problem. Also, a tight worst case bound on the relative error is found. For the case of two parallel machines, we examine two heuristics, which are based on simple scheduling rules. We find tight worst case bounds of 6/5 and 9/7 on the relative error and show that neither procedure is superior for all instances. Finally, we empirically evaluate these two heuristics. For large problems, the methods find solutions that are close to optimal.     

Minimizing total tardiness and earliness on unrelated parallel machines with controllable processing times

Job scheduling has always been a challenging task in modern manufacturing and the most real life scheduling problems which involves multi-criteria and multi-machine environments. In this research our direction is largely motivated by the adoption of the Just-In-Time (JIT) philosophy in parallel machines system, where processing times of jobs are controllable. The goal of this paper is to minimize total weighted tardiness and earliness besides jobs compressing and expanding costs, depending on the amount of compression/expansion as well as maximum completion time called makespan simultaneously. Jobs due dates are distinct and no inserted idle time is allowed after starting machine processing. Also each machine is capable of processing only some predetermined jobs and operations with probably different speeds. A Mixed Integer Programming (MIP) model is proposed to formulate such a problem and is solved optimally in small size instances. A Parallel Net Benefit Compression-Net Benefit Expansion (PNBC–NBE) heuristic is then presented to acquire the optimal jobs set amount of compression and expansion processing times in a given sequence. To solve medium-to-large size cases, a proposed heuristic, two meta-heuristics and a hybrid technique are also employed. Experimental results demonstrate that our hybrid procedure is a proficient method and could efficiently solve such complicated problems.     

Optimization of a Flow Shop System of Initially Controllable Machines

We consider an optimization problem for deterministic flow shop systems of traditional machines with service costs penalizing small service times. A regular completion-time cost is also included so as to complete jobs as early as possible. The service times are assumed to be initially controllable, i.e., they are set at the startup time. Assuming convexity of the cost functions, we formulate a convex optimization problem after linearization of the max constraints. The numeric solution of this problem demands a large memory limiting the solvable system sizes. In order to relieve the memory bottleneck, some waiting characteristics of jobs served in fixed-service-time flow shop systems are exploited to result in a simpler equivalent convex optimization problem. These characteristics and the benefit of CNC machines are demonstrated in a numerical example. We also show that the simplifications result in significant improvements in solvable system sizes and solution times.      

Multiagent scheduling method with earliness and tardiness objectives in flexible job shops.

Flexible job-shop scheduling problems are an important extension of the classical job-shop scheduling problems and present additional complexity. Such problems are mainly due to the existence of a considerable amount of overlapping capacities with modern machines. Classical scheduling methods are generally incapable of addressing such capacity overlapping. We propose a multiagent scheduling method with job earliness and tardiness objectives in a flexible job-shop environment. The earliness and tardiness objectives are consistent with the just-in-time production philosophy which has attracted significant attention in both industry and academic community. A new job-routing and sequencing mechanism is proposed. In this mechanism, two kinds of jobs are defined to distinguish jobs with one operation left from jobs with more than one operation left. Different criteria are proposed to route these two kinds of jobs. Job sequencing enables to hold a job that may be completed too early. Two heuristic algorithms for job sequencing are developed to deal with these two kinds of jobs. The computational experiments show that the proposed multiagent scheduling method significantly outperforms the existing scheduling methods in the literature. In addition, the proposed method is quite fast. In fact, the simulation time to find a complete schedule with over 2000 jobs on ten machines is less than 1.5 min.     

Opportunity cost algorithms for reduction of I/O and interprocess communication overhead in a computing cluster

Computing clusters (CC) consisting of several connected machines, could provide a high-performance, multiuser, timesharing environment for executing parallel and sequential jobs. In order to achieve good performance in such an environment, it is necessary to assign processes to machines in a manner that ensures efficient allocation of resources among the jobs. The paper presents opportunity cost algorithms for online assignment of jobs to machines in a CC. These algorithms are designed to improve the overall CPU utilization of the cluster and to reduce the I/O and the interprocess communication (IPC) overhead. Our approach is based on known theoretical results on competitive algorithms. The main contribution of the paper is how to adapt this theory into working algorithms that can assign jobs to machines in a manner that guarantees near-optimal utilization of the CPU resource for jobs that perform I/O and IPC operations. The developed algorithms are easy to implement. We tested the algorithms by means of simulations and executions in a real system and show that they outperform existing methods for process allocation that are based on ad hoc heuristics.     

Solution algorithms for synchronous flow shop problems with two dominating machines

In this paper, we present solution algorithms for synchronous flow shop problems with two dominating machines. In such an environment, jobs have to be moved from one machine to the next by an unpaced synchronous transportation system, which implies that the processing is organized in synchronized cycles. This means that in each cycle the current jobs start at the same time on the corresponding machines and after processing have to wait until the last job is finished. Afterwards, all jobs are moved to the next machine simultaneously. Motivated by a practical application, we investigate the special case of two dominating machines where the processing times of all jobs on these two machines are at least as large as the processing times of all jobs on the other machines and hence always determine the cycle times. After formulating the considered problem as a special vehicle routing problem, we propose mixed integer linear programming formulations and a tabu search algorithm. Finally, we present computational results for randomly generated data and show the efficiency of the approaches.     

Irreducible bin packing and normality in routing open shop

The open shop is a classical scheduling problem known since 1976, which can be described as follows. A number of jobs have to be processed by a given set of machines, each machine should perform an operation on every job, and the processing times of all the operations are given. One has to construct a schedule to perform all the operations to minimize finish time also known as the makespan. The open shop problem is known to be NP-hard for three and more machines, while is polynomially solvable in the case of two machines. We consider the routing open shop problem, being a generalization of both the open shop problem and the metric traveling salesman problem. In this setting, jobs are located at nodes of a transportation network and have to be processed by mobile machines, initially located at a predefined depot. Machines have to process all the jobs and return to the depot to minimize makespan. A feasible schedule is referred to as normal if its makespan coincides with the standard lower bound. We introduce the Irreducible Bin Packing decision problem, use it to describe new sufficient conditions of normality for the two machine problem, and discuss the possibility to extend these results on the problem with three and more machines. To that end, we present two new computer-aided optima localization results.

     

Coordination mechanisms for selfish scheduling

In machine scheduling, a set of jobs must be scheduled on a set of machines so as to minimize some global objective function, such as the makespan, which we consider in this paper. In practice, jobs are often controlled by independent, selfishly acting agents, which each select a machine for processing that minimizes the (expected) completion time. This scenario can be formalized as a game in which the players are job owners, the strategies are machines, and a player’s disutility is the completion time of its jobs in the corresponding schedule. The equilibria of these games may result in larger-than-optimal overall makespan. The price of anarchy is the ratio of the worst-case equilibrium makespan to the optimal makespan. In this paper, we design and analyze scheduling policies, or coordination mechanisms, for machines which aim to minimize the price of anarchy of the corresponding game. We study coordination mechanisms for four classes of multiprocessor machine scheduling problems and derive upper and lower bounds on the price of anarchy of these mechanisms. For several of the proposed mechanisms, we also prove that the system converges to a pure-strategy Nash equilibrium in a linear number of rounds. Finally, we note that our results are applicable to several practical problems arising in communication networks.     

Completion time variance minimization in single machine and multi-machine systems

In this paper we consider the problem of minimizing the completion time variance of n jobs on a single machine with deterministic processing times. We propose a new heuristic and compare the results with existing popular heuristics for the problem. We also propose a method based on genetic algorithms to solve the problem. We present the worst case performance analysis of the proposed heuristic. We also consider the problem of minimizing the completion time variance of n jobs on m identical parallel machines in both restricted and unrestricted versions. A heuristic method and a method based on genetic algorithms are presented for both the cases and results of computational testing are provided. It is concluded that the proposed methods provide better results compared to existing methods for the single machine case as well as for the multi-machine case.