A subjective job scheduler based on a backpropagation neural network

Abstract

This paper aims to present and discuss the concept of a subjective job scheduler based on a Backpropagation Neural Network (BPNN) and a greedy job alignment procedure. The subjective criteria of the scheduler depend on the solution plan for a given job scheduling problem. When the scheduler is provided with desired job selection criteria for the problem, it generates user satisfying solution from a set of valid jobs. The job validation procedure is based on the similarity measure of the jobs with the seen dataset of the scheduler. The seen dataset is based on the subjective criteria of the scheduler. The prioritized and valid jobs are allowed to execute concurrently on the given identical machines. The satisfying criterion of the scheduler indicates the user satisfaction of the scheduler and is based on three measures: convergence test of the BPNN, job validity test and cost evaluation. The simulations presented in this paper indicate that the proposed scheduler approach is one of the most effective strategies of structuring a subjective job scheduler.

Introduction

Job scheduling problems fall into a class of intractable numerical problems that are complex in nature and may not provide subjective satisfying solutions. For instance, in traditional job scheduling each job consists of m sub-jobs called subtasks or tasks, with one machine for each task. As shown in[1, 2], if there are n jobs with each machine, then (n!)^m solution patterns are possible. The subjective job scheduler with a satisfying criterion based on a backpropagation neural network (BPNN)[3–5] simplifies the solution complexities in job scheduling. In this context, the utilization of the parallel processing ability of the BPNN and the significance of the greedy algorithm[6, 7] allow the formulation of a job scheduler which is suitable for generating user satisfying solutions. That is, the proposed scheduler has an ability to yield user satisfying solutions, especially for a problem with n independent jobs on m identical machines.

Details of the problem

In this research, a combination of a 3-layer BPNN and a greedy job alignment procedure are used to generate a “best” job scheduling result that satisfies a user for the job scheduling problem with n independent jobs on m identical machines.

It is assumed that all the jobs in a selected problem have different priorities as per the user and select the “best” possible jobs from the job queue based on the predefined job selection criteria, called subjective criteria. That is, prior to a scheduling process, the scheduler detects the user feasible jobs from the job queue which are supposed to be the in the valid form of the subjective criteria of the scheduler called valid jobs (if any). After a set of valid jobs is recognized, the scheduler allocates those jobs into the given identical machines in a concurrent manner without missing the essentiality of the top priority jobs. In this way, the scheduler maximizes the utilization of the machines to avoid any 'idle’ machine states during its action. Moreover, it is assumed that all machines are operating in parallel and jobs are allowed to migrate to any available machines without violating their priority order. The greedy task alignment procedure always determines the reasonable finishing time schedule from a given scheduling problem.

The initial dataset which is generated based on the user’s subjective criteria for the initial training of the BPNN called the seen data. These seen data and the job alignment procedure are meant to carry the details of how the job selection process happens and how the jobs are to be aligned on the machines. In this case, the user is replaced by the scheduler permanently. That is why this scheduler is named as a subjective job scheduler. Furthermore, this job scheduler employs the greedy algorithms which are, by their characteristics, quicker and they do not need to consider the details of all solution alternatives of the job scheduling problem.

Problem statement

In real life situations, people seek things that give them or provide optimum sense of satisfaction; therefore, all the endeavors of man are geared to finding it at all costs. On the other hand, the productions and service industry are working hard to develop goods and services that meet optimal satisfaction. In the current applications of technology, there is a need of having job schedulers that do not only schedule jobs but also provide the much needed satisfaction. Work procedures such as order of priority, time, due date and others have occupied a substantial search space unnecessarily making it almost impossible to determine whether the results are satisfactory or not[8]. Whenever a user is faced with many jobs at a time, as a human being, the user will select a set of feasible jobs subjectively and will be persuaded to complete them together without incurring any overhead. The proposed scheduler shows how a job scheduling agent would handle the above mentioned situation in an effective way.

Description of the problem and the structure of the scheduler

The proposed job scheduler is meant to solve job scheduling problems such as n independent jobs on m machines. The scheduling problem can be described as follows: denote J = {1, .. , j} and M = {1,…, m} as the job set and the machine set, where J and M are the number of independent jobs and identical machines, respectively. The scheduler always starts with a set of input jobs (input jobs are unseen jobs) which are available in the queue, also called a job queue. Each job in the job queue is represented by a set of parameters referred to as job attributes. Let’s say a job, J₁ can be represented as {a₁₁ /\ a₁₂ /\ …./\ a_1n}, where a₁₁, a₁₂,.., etc., are the conjunctions of the attributes of the job J₁. In this paper, a job has four attributes provided in order to estimate its priority, P. It is assumed that these four parameters of a job are known in advance and are defined as follows:

•  R, job release-event, is the estimated triggering time of the job execution request[9].

•  K, job computation time, is the time to complete the execution of the task.

•  D, job relative deadline, is the maximum acceptable delay for its processing[9].

•  L, job critical type, indicates whether the job is critically needed.

The subjective criteria for determining the priority of a job and also the subjective criteria used to identify valid jobs out of a set of input jobs depend on the nature and the definition of these four attributes. The job attributes of the scheduler may vary with the nature of the scheduling problems and users’ preferences. Here the scheduler detects the execution concurrency of a set of valid jobs based on the job priorities and the priorities of the jobs depend on the subjective criteria of the scheduler as specified by the user. At this point, the priority definition of a job is informal. That means that the priority of a job cannot be described formally and it can only be detected through the subjective criteria of the scheduler. Subjective criteria for generating seen data for the scheduler for assigning priority to each valid job are described in Section Subjective criteria. Though the deadline attribute of a job is an important one for detecting its priority, it is considered that jobs are soft in nature such that a deadline is never missed to jeopardize the performance of the scheduler. Figure 1 shows the structure of the scheduler with a BPNN (3-layered BPNN with a network topology of four input neuron, thirty hidden neurons and one output neuron), a job queue, a priority queue, BPNN convergence test, job validation test, cost evaluation, greedy job alignment procedure and machine set. The scheduler is formulated in such a way that it works with a set of jobs simultaneously at a time.

Figure 1

Structure of the scheduler.

The selected 3-layer BPNN is trained with a backpropagation algorithm with the seen data until its Mean Squared Error (MSE) is reduced to a value less than 0.001. Section Subjective criteria shows the details of generating the seen data for the BPNN.

Description of backpropagation neural networks

The neurons are connected by links and each link has a numerical weight associated with it. Weights are the basic means of long-term memory in neural networks[4]. They express the strength, or in other words, importance of each neuron input. A neural network 'learns’ through repeated adjustments of these weights. The neurons are connected to the external environment through the input and output layers. The weights are modified to bring the network input/output behavior in line with that of the environment. Figure 2 shows the structure of a typical neuron.

Figure 2

Structure of a neuron[4].

Each neuron in the neural network is an elementary information-processing unit. It has the means of computing its activation level given the inputs and numerical weights. To build an artificial neural network, first it is to be decided how many neurons are to be used and how the neurons are to be connected to form a network. Then the learning algorithm to be used is selected. Finally, the neural network is trained with the selected supervised training algorithm. Training of the neural network means that the learning algorithm initializes the weights of the network and updates the weights from a set of training examples (seen data). In this paper, the backpropagation algorithm is used to train the 3-layer neural network (hence it is called a backpropagation neural network). Typically, a backpropagation neural network (BPNN) is a multilayer neural network that has three or four layers. The layers are fully connected, that is, every neuron in each layer is connected to every other neuron in the adjacent forward layer. A neuron determines its output by computing its net weight input as[4]:

$$X=\sum _{i=1}^n{x}_i{w}_i-\theta$$

(1)

where the variable, X, is the net weighted input to the neuron, x _i is the value of input i, w _i is the weight of input i, n is the number of neuron inputs, and θ is the threshold applied to the neuron. The sigmoid activation function guarantees that the neuron output is bounded between 0 and 1. The neuron in this backpropagation network uses a sigmoid activation function. Hence the output Y^sigmoid of the neuron is given as[4]:

$$Y^{\mathit{\text{sigmoid}}}=1/\left(1+e^{\_X}\right).$$

(2)

The BPNN with four input variables and one output variable used in this paper is shown in Figure 3, where R, K, D, L and P are the release-event, computation time, relative deadline, critical type and priority of the given job. In a typical 3-layer BPNN, the computation time will be asymptotically Θ (ih + ho), where i, h, and o are the number of input neurons, hidden neurons and output neurons, respectively. Again, the main function of the BPNN is to assign priorities to the jobs based on the given subjective criteria.

Figure 3

A 3-layer BPNN with input and output variables.

Subjective criteria

In order to generate a seen dataset for the initial training of the BPNN of the scheduler, there are five numerical values with their proper linguistic terms applied along with the parameters of each job. The four parameters of a job with their numerical values and linguistic terms are as follows:

• I. R _i is the release-event of job i with values: [0.1 (very small), 0.3 (small), 0.5 (not small), 0.7 (long), 0.9 (very long)].

• II. K _i is the computation time of job i with values: [0.1 (very low), 0.3 (low), 0.5 (not low), 0.7 (high), 0.9 (very high)].

• III. D _i is the deadline of job i with values: [0.1 (very near), 0.3 (near), 0.5 (not near), 0.7 (far), 0.9 (very far)].

• IV. L _i is the critical type of job i with values: [0.1 (very low), 0.3 (low), 0.5 (not low), 0.7 (high), 0.9 (very high)].

The output of the BPNN, P _i , is the priority of job i ranging from 0.01 (very low priority) to 0.99 (very high priority).Based on the numerical values and linguistic terms of the attributes of a job, the criteria for generating the seen data (including both input and output data patterns) for finding job priority are as listed below:

• (a) A valid job with a very high / high computation time never holds a very near / near deadline (deadline must be greater than or equal to computation time).

• (b) A valid job with a very long / long release-event never holds a very near / near deadline.

• (c) A very high critical job should hold a very near deadline.

• (d) A very high critical job never holds a very far deadline.

• (e) A very high / high critical job never holds a very high / high computation time.

• (f) A valid job with a very small / small release-event, a very low / low computation time, a very near / near deadline and a very high / high critical type holds a very high / high priority.

• (g) A valid job with a not small / long / very long release event, a not near / far / very far deadline, a not low / high / very high computation time and a very low / low / not low critical type can achieve only a priority value which is proportional to its critical type value.

• (h) A valid job with a very long / long release-event, a very high / high computation time, a very far / far deadline and a very low / low critical type holds a very low / low priority.

• (i) A valid job with a not small / long release-event, a not near / far deadline and a not low critical type will get a priority value which is proportional to its critical type.

• (j) A valid job with a very small / small release-event, a very high / high computation time, a not near deadline and a not low critical type will hold a priority value which is proportional to its deadline.

• (k) A valid job with a very long / long release-event, a very high / high computation time, a very far / far deadline and a very low / low critical type has a priority which is proportional to its critical type.

A sample seen dataset with input variables and their respective output data patterns based on the above subjective criteria is shown in Additional file1: Table S1.

Greedy job alignment procedure

The greedy job alignment procedure helps to generate possible alignment patterns of valid jobs on their respective machines based on their priority values. The jobs are sorted in descending order of their priorities to allocate them on the given identical machines. The greedy procedure of the scheduler reduces the finishing time of the jobs on the machines by allowing similar priority jobs to execute concurrently on the given identical machines[10]. Assume that the job priority queue, q has n indices and can be represented as q[0],…, q[n-1] and it holds J valid jobs {J₁,…, J _n } at a time. Let there are M identical machines in the scheduler and are represented as the set {M₁,…, M _m }.The relationship between machines and jobs of the scheduler is J > M. Based on their priorities, the valid jobs are concurrently executed by the given machines as shown below:

$$\begin{array}{c}\hfill \left\{\left(M_1:\mathrm{q}\left[0\right],\mathrm{q}\left[n-2\right],\dots \right)\right\}\hfill \\ \hfill \left\{\left(M_2:\mathrm{q}\left[1\right],\mathrm{q}\left[n-3\right],\dots \right)\right\}\hfill \\ \hfill \left\{\left(M_m:\mathrm{q}\left[n-1\right],\mathrm{q}\left[n-1\right]\right),..\right\}.\hfill \end{array}$$

The greedy procedure sorts the computation times of each machine to find the finishing time, FT, of the schedule. The maximum value of the finishing time is considered as the feasible solution for the schedule (Section Cost evaluation shows the details of the finishing time calculation).

Convergence test of the BPNN

There is a convergence test added along with the traditional backpropagation algorithm to verify the initial training process of the BPNN. The initial training of the BPNN depends on the size of the seen data and the topology of the network. Once the BPNN is trained with the seen dataset until its MSE is 0.001, it is essential to ensure that the BPNN is free from problems such as 'over-fitting’ and local maxima during its initial training process. The details of the convergence test of the BPNN are given here:

• (i) Train the BPNN with the seen dataset by proper training parameters such as learning rate (α) and momentum term (β) until its MSE is reduced to a value less than 0.001.

• (ii) Select the input data pattern from the seen dataset after its training.

• (iii) Select the output data from the seen data after its training (say, Q) similarly to step (ii),.

• (iv) Input the selected data pattern (from step ii) to the BPNN and find its output by the BPNN (say, Q’).

A similarity measure of Q and Q’ , S (Q, Q’) is the convergence test of the BPNN and can be interpreted as follows: if S (Q, Q’) is above or equal to +0.99, then the selected BPNN is an acceptable one and is considered as true. Otherwise, the BPNN is considered as unacceptable (false) and allow the BPNN to repeat its training with different parameters and topologies until an acceptable net topology is seen.

A correlation coefficient statistics[11] was used to measure the similarity between two datasets of equal size and the results showed values between -1 and +1 on the basis of the datasets. The mathematical formulae of the correlation coefficients are included below. Let S _i , _j be the normalized similarity between two sets of attribute values X _i and X _j of datasets i and j. The analytical expression of S _i , _j is;

$$S_{i,j}=\left(\sum _{k=1}^n,\left(X_{i,k}={\overline{X}}_i\right)\times \left(X_{j,k}-\overline{X_j}\right)\right)/\sum _{k=1}^n{\left(X_{i,k}-\overline{X_i}\right)}^2\times \sum _{k=1}^n{{\left(X_{j,k}-\overline{X_j}\right)}^2]}^{1/2},$$

(3)

where

$${\overline{X}}_i=1/n\times \left(\sum _{k=1}^n,X_{i,k}\right)$$

(4)

and

$${\overline{X}}_j=1/n\times \left(\sum _{k=1}^n,X_{j,k}\right).$$

(5)

Like with the BPNN convergence test procedure, there is a job validity test procedure of the scheduler as described in the following section.

Job validity test

The job validity test, V, of the scheduler provides a degree of measure of the unseen data (input jobs) of the scheduler with respect to its seen dataset. The job validity test depends on the similarity measure of the unseen data (input jobs) and seen dataset of the scheduler for a given problem. For instance, consider each job in a problem that has a set of four attributes. Hence a set of n jobs has a size of n × 4 (i.e., n rows and 4 columns) for the unseen data values. The similarity measure of an input job (unseen) is calculated with each seen data value (except its seen priority value) of the scheduler. The resulted similarities (called correlation values) are stored in a buffer and then the maximum value is selected as the job’s correlation value. The job is valid only when its correlation value is greater than zero. Similarly, the scheduler finds the correlation values of all input jobs in the job queue. The scheduler selects only valid jobs for their priority estimation.

Let the seen data be given index i and the unseen data be given index j and X _i , X_{i+ 1},…, X _i+n , are the n parameters of set i and X _j , X_{j+ 1},…, X _j+n , are the n parameters of set j (assuming that the sizes of sets i and j are the same). Then the validity of sets i and j, V _i,j , based on Equation (3) can be given as:

$$V_{i,j}={\left(\sum _{k=1}^n,\left(\overline{X_{i,k}}-\overline{Y_i}\right)\times \left(\overline{X_{j,k}}-\overline{Y_j}\right)\right)/\left[\sum _{k=1}^n,{\left(\overline{X_{i,k}}-\overline{Y_i}\right)}^2\times \sum _{k=1}^n{\left(\overline{X_{j,k}}-\overline{Y_j}\right)}^2\right]}^{1/2},$$

(6)

where

$$\overline{X_{i,k}}=1/n\times \left(\sum _{i=1}^n,X_{i,k}\right),$$

(7)

$$\overline{X_{j,k}}=1/n\times \left(\sum _{j=1}^n,X_{j,k}\right),$$

(8)

$$\overline{Y_i}=1/n\times \left(\sum _{k=1}^n,\overline{X_{i,k}}\right)$$

(9)

and

$$\overline{Y_j}=1/n\times \left(\sum _{k=1}^n,\overline{X_{j,k}}\right).$$

(10)

Based on Equation (6), the correlation value of unseen job i, can be given as:

$$V_i=max\left(V_{i,1},V_{i,2},V_{i,3},\dots V_{i,j}\right),$$

(11)

where V_i,1, V_i,2, V_i,3,…, V _i,j are the correlation values of job i with seen_ job_ data₁, seen_ job_data₂,…. , etc. If V _i > 0, then it is assumed that the unseen job i, is based on the scheduler’s subjective criteria and is valid. The job validity test V, is true only when the size of valid jobs is greater than the size of machines for a given problem.

Cost evaluation

The cost evaluation of the scheduler depends on its cost value, C, and is based on its finishing time. The cost evaluation of a multi-machine job scheduler can be expressed by the following theorem[7]:

Every feasible schedule has a finishing time which is not earlier than the time

$$T=\left(\sum _{i=1}^n,K_i\right)/m,$$

(12)

where K _i {i = 1,…, n} is the computation time of i jobs and m is the number of machines. It is assumed that all machines are operating in parallel and each machine has an initialization time, w _ti {i = 1,…, n}, in order to prepare for a job processing. Let T_{m 1} is the total computation time taken by machine m₁ and is given as:

$$T_{m1}=w_{t1*}\sum _{i=1}^n{K}_{1i},$$

(13)

where K_1i {i = 1,…, n} is the computation time of i jobs on machine m₁. Similarly, T _mn is the total computation by n^th machine, m _n of the scheduler and is given as:

$$T_{\mathit{\text{mn}}}=w_{t,\mathit{\text{mn}}*}\sum _{i=1}^n{K}_{\mathit{\text{ni}}}$$

(14)

For simplicity, it is assumed that w _ti is 1. Hence the finishing time, FT, of a complete schedule with n machines can be estimated as

$$\mathit{\text{FT}}=max\left\{T_{m1},T_{m2},\dots .,T_{\mathit{\text{mn}}}\right\}.$$

(15)

During a scheduling result with a finishing time, FT, the m machines of the scheduler can use a total of at most (m × FT) time units[7]. At this time, for executing all valid jobs requires$\sum _{i=1}^n{K}_i$ time units. Hence the cost value, C, of the scheduler can be derived from Equations (12) and (15) as follows:

$$C=\left[\mathit{\text{FT}}-T\right],$$

(16)

where T is the average execution time of n jobs on m machines (see Equation (12)).

Based on Equation (16), the cost term can be interpreted, as follows:

•  If C is equal to 0, then it is a 'good enough’ schedule and C is true.

•  If C > 0, then it is a 'reasonable’ schedule and C is true.

For both cases, it can be noticed that C is true. The reason is that the scheduler never generates a non-reasonable schedule due to the application of the greedy alignment procedure. Furthermore, due to the application of Equation (16), the cost, C, of a feasible schedule will never reach a value greater than or equal to 1.

Definition of satisfying criterion

The satisfying criterion, Sat, of the scheduler is a binary term which indicates the satisfaction of the scheduler for a given problem. The Sat of the scheduler can be defined in terms of three binary measures: (i) S; (ii) V; and (iii) C, where S, V and C are the binary results of convergence test, job validity test and cost evaluation of the scheduler, respectively. The propositional logic representation of Sat with respect to the atomic variables S, V and C can be expressed as[8]:

$$\left(\left(S\wedge V\wedge C\right)\to \mathit{\text{Sat}}\right).$$

(17)

The interpretation of Equation (17) is that if S, V and C are true, then it is possible to say that Sat is true. Otherwise, it is not possible to claim that Sat is true. Because of the application of BPNN convergence test, job validity test and cost evaluation, the proposed scheduler always generates user-satisfactory schedules. Whenever all the jobs in the job queue are invalid, then the scheduler will indicate an unsatisfying situation. The same situation will happen when the number of valid jobs is less than the number of given machines for a problem.

Procedure of the scheduler

The implementation of the proposed procedure includes the following distinct steps:

• (i) Generate jobs and machines randomly.

• (ii) Declarations: Let M be the set of m identical machines, where ∀ M = 0 (initialize all machines). The selection criteria of both job and machine can be given as J > M, where J is the total number of jobs in the job queue.

• (iii) Job validation test: Checks whether any invalid job(s) available in the job queue. If so, such jobs will be exempted from the job queue.

• (iv) Backpropagation algorithm: The backpropagation algorithm trains the BPNN for assigning priorities to each valid job. Let P is a set of priorities of n jobs and P can be denoted as {P ₁ , P ₂ ,…,P _n }. The convergence test measures the acceptability of the BPNN before its selection.

• (v) Greedy job alignment procedure: The job alignment procedure aligns valid jobs into a set of identical machines for their concurrent execution based on their priorities. The alignment procedure returns a best finishing time, FT, of the schedule which is either 'good enough’ or a reasonable one.

• (vi) Cost evaluation: The cost evaluation of the scheduler evaluates result of a schedule to either a good enough or a reasonable schedule on the basis of its finishing time, FT.

• (vii) Satisfying criterion: Satisfying criterion defines the satisfying conditions of the scheduler. Whenever the number of valid jobs is zero and the number of valid jobs is less than the machines, then satisfying criterion of the scheduler fails.

• (viii) Go to step (i).

Simulation results

The subjective scheduler is written in C++ and supportive simulations are made to show the satisfying nature of the scheduler for several given scheduling problems of different kinds. For the purposes of this study, three such kinds are shown: first, a problem with twelve jobs on three machines and second, a problem with sixteen jobs on four machines. Third, a problem with twenty one jobs on seven machines. In this section, the situations, such as the scheduler with only invalid jobs or when the size of the valid jobs is less than the size of the machines, are omitted. Details of the simulations carried out are given below.

Scheduling problem with twelve jobs on three machines

The unseen dataset of twelve jobs with their respective correlation values (as per Equation (6)) are shown in Table 1. As per Equation (3), the 3-layer BPNN is acceptable with a similarity value of +0.9978 (i.e., S is true). Table 1 shows that there are six valid jobs (J₄, J₅, J₇, J₉, J₁₀ and J₁₁) in the job queue as per Equation (11) and the invalid jobs are discarded. Validity, V, of the selected jobs is true because the size of the valid jobs is greater than the size of the identical machines (M₁, M₂ and M₃) for the problem. Priority order of the six valid jobs with their priority value, P, by the BPNN is shown in Table 2.

Table 1 Unseen dataset of twelve jobs with their respective correlation values

Table 2 Order of valid jobs with their priority values by BPNN in twelve jobs on three machines problem

Figure 4 shows the scheduling of six valid jobs on three identical machines (M₁, M₂ and M₃). The computation time, K, of each job is shown in brackets. The greedy job alignment procedure allocates valid jobs on the given identical machines based on their order of the priority. The finishing time, FT, is 1.52 and cost value, C, is 0.22 and is true as per Equation (16) and the resulted schedule is a reasonable one. Because of the true values of S, V and C (as per Equation (17)), the schedule from scheduler for the given problem is a satisfying one.

Figure 4

Scheduling of six valid jobs on three machines ( FT = 1.52).

Scheduling problem with sixteen jobs on four machines

A simulation of the scheduler with an unseen dataset of sixteen jobs on four identical machines (M₁, M₂, M₃ and M₄) is illustrated.

Table 3 shows an unseen dataset of sixteen jobs with their respective correlation values. From the Table 3, it can be noticed that there are seven valid jobs (J₁, J₆, J₁₁, J₁₂, J₁₄, J₁₅ and J₁₆) in the job queue. Validity, V, of the selected jobs is true because the size of the valid jobs is greater than the size of the identical machines (M₁, M₂, M₃ and M₄) for the problem. Priority order of the seven valid jobs with their priority values, P, by the BPNN is shown in Table 4.

Table 3 Unseen dataset of sixteen jobs with their respective correlation values

Table 4 Order of valid jobs with their priority values by BPNN in sixteen jobs on three machines problem

Figure 5 shows the scheduling result of seven valid jobs on four identical machines (M₁, M_2,M₃ and M₄). The computation time, K, of each job is shown in brackets. The finishing time, FT, is 1.08 and cost value, C, is 0.33 and is true as per Equation (16). As per the cost value, the resulted schedule is a reasonable one. As per Equation (17), the result from the scheduler for the given problem is a satisfying one.

Figure 5

Scheduling result of seven valid jobs on four machines ( FT = 1.08).

Scheduling problem with twenty one jobs on seven machines

Similarly a simulation of the scheduler with an unseen dataset of twenty one jobs on seven identical machines (M₁, M₂, M₃, M₄, M₅, M₆ and M₇) is illustrated in this section. Table 5 shows an unseen dataset of twenty one jobs with their respective correlation values.

Table 5 Unseen dataset of twenty one jobs with their respective correlation values

Table 5 shows that there are eleven valid jobs (J₂, J₃, J₄, J₈, J₉, J₁₂, J₁₄, J₁₆, J₁₈, J₁₉ and J₂₁) in the job queue. The validity, V, of the selected jobs is true. Priority order of the eleven valid jobs with their priority values, P, by the BPNN is shown in Table 6.

Table 6 Order of valid jobs with their priority values by BPNN in twenty one jobs on seven machines problem

Figure 6 shows the scheduling of eleven valid jobs on seven identical machines (M₁, M_2,M₃, M₄, M_5,M₆ and M₇). The computation time, K, of each job is shown in brackets. The finishing time, FT, is 1.08 and cost value, C, is 0.263 and is true as per Equation (16). As per the cost value, the resulted schedule is a reasonable one and as per Equation (17), the result from the scheduler is a satisfying one.

Figure 6

Scheduling result of eleven valid jobs on seven machines ( FT = 1.08).

Conclusions

The presented subjective job scheduler shows its ability in generating user satisfying schedules by establishing proper neural net training paradigm, exempting invalid jobs from the job queue and evaluating its results with a cost evaluation. The scheduler utilizes the customizable nature of the BPNN and the feature of the greedy algorithm.

The term 'job priority’ of the scheduler cannot be described formally, that is, it is not possible to define the priority of a job in a normal way because that depends only on the given subjective influence. Therefore, the results of the scheduler are biased towards certain objective based on its subjective criteria.

The proposed scheduler is flexible enough to adopt views of various users for a given problem and it functions like an intelligent job scheduling agent for providing user satisfied results.