Comparison of schedule generation schemes for designing dispatching rules with genetic programming in the unrelated machines environment

Highlights

• Two novel schedule generation schemes for automatically designed dispatching rules

• Comparison of automatically and manually designed dispatching rules

• Inserting idle in the schedule by dispatching rules leads to better results

• Selecting machines by using priority functions leads to significantly better results

• Machine selection by priorities is the main advantage of automatically designed rules.

Abstract

Automatically designing new dispatching rules (DRs) by genetic programming has become an increasingly researched topic. Such an approach enables that DRs can be designed efficiently for various scheduling problems. Furthermore, most automatically designed DRs outperform existing manually designed DRs. Most research focused solely on designing priority functions that were used to determine the order in which jobs should be scheduled. However, in some scheduling environments, besides only determining the order of the jobs, one has to additionally determine the allocation of jobs to machines. For that purpose, a schedule generation scheme (SGS), which constructs the schedule, has to be applied. Until now the influence of different choices in the design of the SGS has not been extensively researched, which could lead to the application of an SGS that would obtain inferior results. The main goal of this paper is to perform an analysis of different SGS variants. For that purpose, three SGS variants are tested, two of which are proposed in this paper. They are tested in several variations which differ in details like whether they insert idle times in the schedule, or if they select the job with the highest or lowest priority values. The obtained results demonstrate that the automatically designed DRs with the tested SGS variants perform better than manually designed DRs, but also that there is a significant difference in the performance between the different SGS types and variants. The best DRs are analysed and show that the main reason why they performed well was due to the more sophisticated decisions they made when selecting the appropriate machine for a job. The results suggest that it is best to apply SGS variants which use the evolved priority functions to choose both the next job and the appropriate machine for that job.

Introduction

Scheduling problems have been extensively researched in the literature due to their complexity and applicability in different areas. In general, scheduling is defined as the process in which a certain set of jobs (activities) has to be scheduled on a scarce set of machines (resources) to optimise some user-specified criteria [1]. Scheduling problems are quite widespread and have applications in different areas from the medical sector [2], [3], workforce scheduling [4], biopharmaceutical companies [5], and many others. Since most scheduling problems are NP-hard, the majority of researchers focused on either designing new problem-specific heuristic methods or applying existing metaheuristic methods. However, the type of methods that can be applied depends on the conditions under which the schedule has to be constructed. For example, if all the information about the schedule is known beforehand, then the entire schedule can first be constructed and then executed. In such static conditions, it is possible to use a great number of heuristic and metaheuristic methods to construct the schedules [6], [7], [8].

Metaheuristics have become one of the most popular methods used for solving not only scheduling but also other continuous or combinatorial optimisation problems. Among them, the most prevalently used are some of the older and most acclaimed methods like genetic algorithms [9], particle swarm optimisation [10], and ant colony optimisation [11]. However, in recent years a plethora of new metaheuristic methods, which usually mimic various natural phenomena or animal behaviour, have been designed by different researchers. Some of these newer metaheuristic algorithms include the sine–cosine optimisation method [12], grey wolf optimisation [13], whale inspired optimisation algorithms [14], [15], moth flame algorithm [16], salp chain optimisation methods [17], [18], and many others.

Aside from the aforementioned methods that search for the optimal solution of only one problem instance, methods like genetic programming (GP) [19], gene expression programming (GEP) [20], Cartesian genetic programming (CGP) [21], and others have also been proposed. These methods differ in the sense that they can be used to evolve a strategy or heuristic that can solve a set of problems, rather than only one problem instance. GP has not only demonstrated the ability to obtain good solutions for many different problems [22], [23], but also that it is highly appropriate of being applied as a hyperheuristic method, i.e. a method for automatic design of novel heuristics [24], [25], [26], [27], [28], [29]. In recent years, GP and similar methods were applied for automatic generation of heuristics for various problems like the capacitated arc routing problem [30], [31], [32], timetabling problem [33], [34], [35], vehicle routing problem [36], design of pipeline networks [37], and multidimensional knapsack problem [38].

In the case when scheduling is performed under dynamic conditions, the number of methods that can be used to construct the schedule is limited. This is because the characteristics of jobs become available during the execution of the system and are not known at the beginning. Thus, algorithms that search the solution space, as most metaheuristics do, cannot be applied to these problems without modifications, since they would not have all the necessary information to construct valid solutions. Such scheduling problems are usually solved by using constructive heuristics, which iteratively construct the schedule during the execution of the system. Constructive heuristics are most often designed in the form of dispatching rules (DRs), which rank all the jobs by a certain priority calculated based on selected job and system parameters, and then schedule the job with the highest priority [39], [40], [41]. Therefore, DRs do not need all the information about the problem, but rather use only the information that is currently available to construct the schedule. However, DRs are problem-specific heuristics, which means that different DRs need to be designed for optimising different criteria and solving different kinds of scheduling problems. Designing DRs is not a trivial task, and a lot of domain knowledge and experience is necessary to design effective DRs. This is a serious drawback since it would mean that DRs would need to be manually designed for all possible scheduling problems that could appear, which is not feasible.

Fig. 1 illustrates how a DR could schedule a certain set of jobs in a simple scheduling problem. In this example, six jobs need to be scheduled on three available machines starting from a certain time point $t_0$. The DR is invoked each time a machine is free and decides which job to schedule on which machine. At the start of the system, the DR selects and schedules one job on each of the machines as all three machines are free. Based on the properties of jobs, the DR ranks all the jobs and selects the best one, which would in this case be job $J4$. The DR then schedules this job on one of the machines that are free. In this case, it would schedule the selected job on machine $M1$, as denoted in Fig. 1(a). Since some machines are still available, the remaining jobs are ranked again, and the best job is selected and scheduled on a free machine. This is illustrated in Fig. 1(b), where job $J1$ is selected and scheduled on machine $M3$. Machine $M2$ is still available, therefore the entire procedure is repeated once again, after which job $J5$ is selected and scheduled on machine $M2$. At this point, there are no free machines, and the system executes those jobs that are currently scheduled on the machines until a certain machine becomes available again. This happens at time moment $t_1$, when machine $M2$ finishes executing its job. At that point, the DR is invoked again and determines that job $J2$ should be executed on that machine. This is shown in Fig. 1(d). After this, the machines continue executing until machine $M3$ becomes available at time moment $t_2$. The entire procedure is repeated, and the DR selects and schedules job $J6$ on machine $M3$, as shown in Fig. 1(e). Finally, the DR is invoked one last time at moment $t_3$ when machine $M3$ becomes available once again. Since only job $J3$ is left, the DR selects and schedules it on machine $M3$, as illustrated in Fig. 1(f). The machines would then continue executing until all the jobs are completed.

In recent years, a great deal of research focused on applying GP and similar methods for the automatic creation of DRs. In this approach, the DR is decomposed into two parts, a priority function (PF) used to calculate the priorities of jobs, and a schedule generation scheme (SGS) that uses the PF to construct the schedule. Such an approach of designing DRs has demonstrated to be quite efficient, not only because new DRs can be designed in a smaller amount of time, but also since the automatically designed DRs perform equally well or even better than existing manually designed DRs. As a consequence, the topic became extensively researched [42], [43]. However, the entirety of research focused almost exclusively on designing PFs, while the SGS part did not receive a lot of attention. One of the main reasons for this is that most research focused on the job shop environment, in which the only decision that had to be made was the ordering of jobs. Therefore, the SGS only had to rank all the jobs using the PF and then schedule them in that order. However, research in different scheduling environments has already demonstrated that even subtle differences in the design of the SGS can lead to a significant difference in the obtained results [44]. Therefore, in environments in which ordering the jobs is not the sole decision that has to be made, the SGS also has a more significant influence on the quality of the constructed schedule. For example, in some environments, it is additionally required to determine to which machine the selected job will be allocated, like in the parallel machines environment. Therefore, the SGS does not only have to rank the jobs but also in a certain way determine how to allocate them to different machines. Thus, they are required to perform an additional decision that can have a significant effect on the quality of the constructed schedules. Even though DRs have already been generated for the unrelated machines environment, the design and choice of an appropriate SGS have still not received much attention, and thus it is not known whether better results could be obtained by performing different design choices.

Because of the above reasons, the goal of this paper is to analyse how different designs of the SGS can affect the performance of automatically generated DRs in the unrelated machines environment. Therefore, in addition to the existing SGS used in the literature for the unrelated machines environment, two additional schemes are proposed. One proposed SGS is modelled to more closely resemble the schemes used in manually designed DRs. By using this scheme it will be possible to determine whether the existing manually designed DRs already present the best that can be obtained or whether it is possible to fine-tune the PF even further. The second SGS is modelled with the motivation to separate the choice of selecting the next job and the machine it will execute on into two independent PFs, which was not the case until now. This division should hopefully lead to the design of more interpretable PFs. Furthermore, the paper also analyses the influence of several design choices, like selecting whether to schedule jobs with the smallest or largest priority value, or whether to take the absolute value of the priorities, which have also not been considered until now. The influence of using an SGS with and without idle times will also be analysed, as in the unrelated machines environment this decision largely affects the construction process of the schedule. Although it is intuitively expected that using idle times should lead to better schedules, we were unable to find any research in designing DRs to support this claim. A detailed analysis of the evolved DRs is also performed, both based on the interpretability of the evolved PFs, and the decisions performed by the different DRs. The analysis shows that the main reason for the superior performance of the automatically designed DRs lies in their ability to evolve the strategy by which to allocate jobs on machines. This observation can influence how DRs are designed, especially the manually designed ones, as it demonstrates the significance of the decision of allocating jobs to machines, and the limitation of the scheme used by manually designed DRs. Therefore, instead of putting most focus on designing the PF which ranks the jobs, equal attention should be placed also on designing better schemes for allocating jobs on machines. The contributions of the paper can be summarised through the following points:

• Comparison of three SGS variants for the unrelated machines environment, two of which are proposed in this paper

• Analysis of the influence of selecting jobs with highest or lowest priorities, taking absolute values of priorities, and inserting idle times in the schedule

• A detailed analysis of the scheduling decisions performed by the SGS variants showing that a superior performance can be obtained by those SGS variants which also use a PF for the allocation of jobs to machines

The rest of the paper is organised as follows. Section 2 gives a short overview of the existing research performed in the area of automatic design of DRs by GP. Section 3 provides background information about scheduling in the unrelated machines environment and designing new DRs with GP. The SGS variants are described in Section 4. Section 5 describes the experimental design and outlines the selected parameter values for performing the experiments. The results obtained from the performed experiments are presented in Section 6. Section 7 provides an analysis of several PFs that were designed for different SGS variants. The discussion about the obtained results and the performed analysis is given in Section 8. Finally, the conclusion and directions for further research are given in Section 9.