REAL TIME READ-FREQUENCY OPTIMIZATION FOR RAILWAY MONITORING SYSTEM

. Trains have a key role in transporting people and goods with the option of moving from source to destinations by passing through several stations, with time-based features like date scheduling and known arrival times, which makes time a critical factor. The main challenge here, is to ensure that the train trip or train schedules are not affected or delayed in any way during the whole train trip; by giving the control unit in the railway system, the required time to process requests regarding all collected data. This an NP-hard problem with an optimal solution of handling all collected data and all service requests by the control unit of the railway system. Operational research will be used to solve this problem by developing many heuristics to deal with tasks of real-time systems, to produce a significant time optimization in the railway systems. To solve this problem, the proposed approach employs optimization by adapting 22 heuristics based on two categories of algorithms, the separated blocks category algorithm and the blocks interference category algorithm. The proposed approach receives data from many different sources at the same time, then collects the received data and save it to a data base in the railway system control unit. Experimental results showed the effectiveness of the developed heuristics, more over the proposed approach minimized the maximum completion time that was elapsed in handling the received requests.

level, destination arrival is no more the major concerns of these customers; arrival time is the major concern to most of these customers.
Among the different means of transportation, this study will consider trains transportation, as trains have a key role in transporting people and goods. Moreover, many big cities rely on train transportation; due to the train features that fit the varying needs and provide the dynamic requirements of these cities. Trains have the option of moving from source to destinations by passing through several stations, with a pre known fixed features like date schedule and arrival times, such features are of interest to many customers. All of these features are time-based features; hence time is considered a critical factor in this study.
The railway system, in this context, is composed of many subsystems that are integrated to ensure the effective operation of the railway, which is reached by achieving a set of goals such as meeting all journeys' time table, efficient goods transportation, passengers safety, efficient customer service,... etc. Therefore, the train system receives the required data to ensure the achievement of those goals through the monitoring system. The monitoring system uses sensors, cameras, and other tools to receive data and various requests from railway subsystems. All these requests and data are sent to the control unit to accomplish the required tasks as soon as possible. Therefore, the delay in processing any of the requests or data will lead to weaknesses or deficiencies in the performance of the subsystem to which these requests or data belong, and this is an undesirable thing. To avoid this, this work presents a framework that will provide the necessary time, required for the control unit to complete all requests and data sent without any delay.
To ensure that trains meet the given time-based features, all factors and variables regarding the train system should be considered. One of the suggested solutions when time is critical is to utilize the capabilities of scheduling algorithms [12,46], it's worth to mention that scheduling here, is not date scheduling, it is how the railway system addresses large volume of services and requests within a limited time and resources [45]. There are many challenges and obstacles facing railway systems [14,15], some of these challenges will be addressed in this paper like, data handling and receiving and how scheduling is used to handle these problems to derive the seriousness of each, to specify the impact of these problems on the train trip or schedule. The priority here is to handle these problems so that the train trip or schedule is not affected or delayed in any way during the whole train trip. To avoid any latency, train options are limited to delaying or stopping the trip, because the train has a fixed route on its railway. Time needed to process the received data, is the major concern of this research. Data can be received from many sources: service requests, monitoring systems, visual-based systems, sensors, detection systems or any other sources. Once the data is received, it is collected and saved into a database for processing and for further analysis by the control unit of the railway monitoring system. To meet the required features of the railway system and the critical time issue; time and computing limitations should be considered, to give the control unit, the required time to handle the largest number of collected data. These limitations can be managed by optimization, through the adaptation of several heuristics developed for the parallel machine problem, which is an NP-hard problem with an ideal solution of handling all collected data and all service requests by the control unit.
The rest of this paper will be organized as follows, Section 2 presents the related work while Section 3 discusses problem presentation. Formulating the optimization problem will be presented in Section 4, the next section explains the scheduling problem. The sequencing-based train algorithm will be addressed in Section 6. Discussion of the experimental results will be presented in Section 7. Finally, the conclusion will be presented in Section 8.

Related studies
Several researchers worked about scheduling in railways. The researchers in [30] addressed the parallel jobs scheduling problem. the considered preferences were related to release dates and identical parallel machines. The main objective of their work was to minimize the makespan and to perform a parallel work, with a set of constraints on a group of identical machines, this work is achieved by an online model that handles sequentially the arrived tasks based on the obligation of the schedule before the next task is known.
While authors in [13] explain the case of an NP-hard problem where the number of tasks and machines are already known. The assigned tasks are restricted by single task per single machine and pre-known processing time. The assigned tasks are executed by both a meta-heuristic and an exact algorithm to achieve the goal of minimizing the maximum completion time. The discussed results by the authors concluded the ability of the developed algorithm to solved optimally the majority of the given instances efficiently. The remaining of the instances were solved optimally by the exact algorithm developed by Haouari and Jemmali [18].
Researchers in [31] used cost minimal schedule with column generation-based solution algorithm to explore the effect on cost when scheduling-fairness is increased. In this research, the authors addressed the problem of distributing highest possible fairness, undesirable tasks among train drivers. The considered constraint was to cover completely all train movements without violating minimal increase in cost work regulations. The authors claimed that schedule fairness was significantly improved with only slight increases in schedule cost.
In the same manner researchers in [44] presented a solution of the crew rescheduling problem based on re-timing with frequent train disruption, by using column generation techniques combined with Lagrangian heuristics. To encounter any delay or a budget loss when any disruption occurs, the available resources related to that trip at that time are rescheduled. The presented algorithm is based on the rescheduling of the train driver duties. The authors claimed that the used algorithm showed better results than the used classical approaches.
The use of identical parallel machines to schedule parallel jobs with release dates, were treated by Li and Zhang [35]. The authors discussed the solution of two problems in their work. The first problem considers two similar machines with speeds of 1 and s where ( > 1). While the second problem considered the m identical machines problem. The main objective in this research was, how to minimize the makespan and the jobs arrival time. The authors showed a competitive ratio for on-line LPT algorithm related to the first problem and for a lower bound related to the second problem.
Other researchers used the weaknesses, the strengths, the volatility and the robustness parameters of a train schedule in the presence of the delay. For example, Burdett et.al presented an analytical approach that handles unusual specific behavior, to determine an appropriate action plan or to modify a schedule in advance [11]. In addition, the adopted approach can quantitatively derive the delay cost. A case study was given to declare the main features of the given approach.
To minimize makespan for the identical parallel-machine scheduling problem, authors in [33] developed a cuckoo search algorithm (ICSA). A heuristic approach was developed using model operator with heuristic procedure that is based on the pairwise exchange neighborhood to generate the required cuckoos. Experimental results showed a better performance when comparing with different existing algorithms.
Optimal makespan was discussed in [42] where the authors solved the Resource-Constrained Project Scheduling Problem based on meta-heuristics. To improve time and solutions quality, hybrid techniques were employed by many researchers like [16], in this research, the authors solved combinatorial optimization problems (COPs) by integrating machine learning and algorithms. The results indicate a remarkable improvement in the term of computational time and quality of results compared with random operators.
Researchers in [2] utilized operational research ccc minimize the job's maximum completion time, the authors classified the proposed heuristics into two classes, the resolution of a subset-sum problem with knapsack problem and the dispatching rule. The proposed heuristics were developed to fit and to obtain, the exact solution of the railway scheduling problems. The data captured by railway track sensors will be saved in railway monitoring system database, the developed algorithms utilize the read frequency rate by reading the maximum number of saved data within a predefined time limit.
For the object of cost-effective maintenance, the authors in [43] constructed a problem taxonomy from the results obtained after reviewing railway track-related maintenance and scheduling plans in the literature. In the same approach, the authors in [8] presented an opportunistic preventive maintenance policy with the goal of minimizing the total maintenance cost. The proposed policy executes a steady-state genetic algorithm to search for a maintenance threshold that will decide when to perform the preventive tamping maintenance. The authors stated that considering the proposed policy may reduce the performance cost by 46%. The automatic inspection of railway performed by a track running robot is presented by Pradeep et al. [40] to monitor the railway for any railway defects. The proposed approach uses a Wi-Fi camera to send a live recording of the defect location, the required directions to locate the exact location of the defected parts are also sent to the inspection team. The group of factors that affect the railway maintenance planning processes were presented by Kovenkin and Podverbnyy [32]. The authors in [6] used Bayesian approach to build a model that can expose the actual defect rate and the probability of not locating any defects in order to optimize the railway track maintenance process. A different approach was presented by Movaghar and Mohammadzadeh [38] where the authors utilize Bayesian framework to generate data regarding uncertainties in railway track degradation model, the results presented by the authors reveal how the proposed model can affect the restricted budget and the limited resources for preventive maintenance processes scheduling.
Current railway systems consist of a set of subsystems; each subsystem is dedicated to handle different operation management functions. Previous studies in the literature present scheduling problem in the railway systems. Most of these studies proposed solutions that consider railway subsystems, for example train timetables problem was solved by researchers in [45], while train schedules problem was solved by Donzella et al. [15] and Burdett and Kozan [11]. For the railway crew scheduling, many solutions were proposed by Jütte et al. [31] and Veelenturf [44]. While the solution for obstacle detection problem was proposed by Lan et al. [34] and the railway tracks detection and turnouts recognition problem were discussed, and solutions were proposed by Qi et al. [41]. To the best of our knowledge the only solutions for improving railway system efficiency were presented by Dong et al. [14] in which the authors proposed a solution for bridging the gap in the information exchange between the subsystems in high-speed railway systems. This solution proposes that the huge amount of sent data will be executed by the control unit part of the presented approach without any delay. While the proposed solution in this research focuses on, how the received data will be managed and executed by the control unit of the railway monitoring system before any delay or cancelation of the train trip. The other study was presented by al Fayez et al. [2]. Unlike the previous studies, the proposed solution which is an extension of the work presented by al Fayez et al. [2] minimizes the maximum time required by the control unit to complete the received requests, this allows the control unit to gain more time to achieve integration between all railway subsystems, the control unit must coordinate between these subsystems to ensure safe and reliable railway systems, which is the main objective of this research.
The proposed algorithms can be improved and adopted to the problems studied in [4,9,10,17,37]. Several applications of scheduling problems in real life can be exploited to enhance the proposed algorithms [3, 21, 24-26, 29, 36].

Problem presentation
In this study the focus is on the method of handling the received data from the many sensors that are placed along the railway track. Various data are collected to guarantee the arrival of trains within a fixed time at their destinations. Indeed, railway could be subject to damages, fires, incidents, floods, and other rail obstacles like rocks, sand, trees or animals that influence the regular operation of trains. In order to avoid any disruption or latency of the train trips, it is crucial for the railway track sensors to detect and to provide the required data to the control unit of the railway system, before train reaches the location of these obstacles. The provided data are collected in the control unit that handles and extracts the required information to provide the required interest within an appropriate time. The treatment of this data requires processing time which is critical in this case. This data is modeled as tasks, which are modeled as processing time and the problem is modeled as a parallel machine problem. This problem is NP-hard and we are willing in this study to propose and develop suitable heuristics to solve the addressed problem within an acceptable time.

Notation
The railway monitoring system relies on a set of sensors, distributed on the railway tracks and on the train itself, the used notation to describe these sensors is as follows, Temperature: , Humidity: , Fog: , Wind: and Image from located sensor: . The objective of these sensors is to continuously capture data and forward it to the control unit of the railway monitoring system. For the data sent by the sensors ( , , , ) the related information is directly inferred from the received data, while for the sensor, the system executes a function called () to handle and to analyze the received images. The input of this function is . The output of () will be values assigned to the set of variables: , , and , with the following details: The total number of the received data sent by sensor when the train arrives is:

Significant variation vector
In the monitoring system, the control unit receives frequently the sensors' data. The vectors 0 ( ) and ( ) are instances of vector at time = 0 and at time = , respectively. The control unit handles and analyzes the received data after that the derived information will be values that will be compared with the saved initial values 0 ( ) for each sensor. For the monitoring system to identify any change in the state of railway system at time , it should compare 0 ( ) with ( ) at time for the sensor ( ). The comparison process between the saved initial values and the values sent by sensor at time produces a value change, which will be used to detect any change in the monitored subsystem status. The vector of the variation values at time is denoted by ( ): In practice, if the variation in ( ) is not remarkable, it will be discarded by the control unit and will not be considered in the generated instructions.
Example 3.1. In 0 ( 4 ) the saved temperature is 32. But the temperature in ( 4 ) = 34. The temperature increased by 2 degrees yielding a variation of 2. This variation is not significant because 2 degrees, is not expected to have any impact on the railway system different components. So, the control unit will not consider this variation i.e. the control unit will not perform any process for this variation.
To avoid unnecessary processes, the proposed approach is designed with a predefined threshold for each variable. The corresponding vector of all threshold values is denoted by ℎ ( ). By using ℎ ( ), it will be faster for the control unit to calculate significant variations easily, resulting in a fewer computations and higher performance. The resulted significant variation values will be stored in a new vector called the significant   This work considers only the significant variation vector, for all data readings. For every time values with significant values of ( ) will be stored in DC table as a (Received Data) in the database. Figure 1 shows the process from the stage of sending the sensor's data to the stage of storing it in the database.

Formulating optimization problem
The variations of all ( ) values stored in the DC, will be checked by the control unit. The system is expected to be free of problems when the variations value is 0 and the control unit has no processes to perform. However, if any of the elements in ( ) has a value greater than 0; the control unit will begin to produce the proper instructions required to handle any problem that is specified by the values of ( ). These instructions will be denoted by , where is an integer and can be as: For each instruction there is a corresponding processing time denoted by . The monitoring system will execute one or more set of the predefined instructions for all non-null elements of vector ( ). The monitoring system utilizes the corresponding stored data to generate in advance a suitable set of instructions that suits each variable variation. For example, for sensor , if the received data ( ) requires the attention of the processes 3 , 6 and 7 then the needed processing time to run the selected instructions is given as = 3 + 6 + 7 . As shown in Figure 3, is the total number of the data that are sent by all sensors from to . In this work, data sent by ( ) at time are grouped in the same time slot SD( ). Where: -is the index that represents data sending frequency for all sensors, ∈ {1, · · · , }. -SD( ) the period related to . -all instructions processing time that are defined by the system and related to sensor at period SD( ).  Example 4.1. Assume that we have at SD (3), indicates a sudden high increase in temperature, the system should signal fire-fighters, this process is linked with the instruction 4 . For = [ ( 4 )] 4 = 3 an indication high risk of wind speed, the system must interfere by sending SMS to the monitoring administrator and alert the train driver, this process is linked to instructions 1 and 2 . For = [ ( 4 )] 5 = 1, an indication of obstacle detection on the railway track in the position ( 4 ), this process is linked with instructions 1 , 3 and 7 . For = [ ( 4 )] 6 = 1, an animal detected on the railway track in the position ( 4 ), this process is linked with instructions 1 , 3 and 8 . For = [ ( 4 )] 8 = 1, an indication that there is serious amount of sand on the railway track, the system responds by calling maintenance section, which is related to instructions 3 and 1 0.
The total processing time at time is: For each sensor , at period SD( ), the system will group all the called instructions then calculate the total processing time. The grouped instructions will be replaced by a single process denoted by with a processing time given by . In Example 4.1, time calculations are performed for one sensor 4 . Now, suppose that there were 3 other sensors that have values in the vector ( ) i.e. the system will execute several processes in the same period, a process for each sensor with a total of 4 processes each of them has its own processing time .
The railway system has to perform all the processes of the previous period SD( − 1) to retrieve data from the DC table to execute the latter processes SD( ). The required time to complete the execution of all assigned processes SD( ) of the period SD( ) is given by max . To calculate max , we start by = 1 until SD( ) = SD max , which is the last period before the end of the trip or the train arrival. The main purpose here is to increase the rate of the reading frequency from the DC table. Proof. If the value of max at period SD( ) was minimized then the minimization amount will be utilized to read another data from the DC table, which in turn increases the number of read processes at period SD( ). So, for each max minimization, we will have an increase in the number of read processes thus an increase in the read frequency rate.  Remark 4.4. The optimal solution in such problems is to read all the DC table saved data i.e. SD max = . Such problems is known as scheduling problems, where the set of processes is represented by = { , 1 ≤ ≤ , 1 ≤ ≤ SD max } and the related processing times by . For a fixed SD( ) values the system handles a scheduling problem. Thus, the proposed system has an SD max scheduling problem that should be solved, this problem type is known as blocks scheduling.
The control unit in the proposed approach has a number of identical processors, which allows to consider the scheduling problem as an identical parallel processor scheduling problem. The objective of this problem is to reduce the makespan max , which is the time required to finish executing all given processes for the most loaded processor. To complete the identical parallel processors scheduling problem, the proposed solution must address this question: will the system be capable of reading data from DC table before the execution of all previous processes? For the proposed system to handle this question, it must select between the following categories of algorithms: -Separated blocks category algorithm (SB): The case for which the system can't read data from DC table before it executes all processes of the current period. -Blocks interference category algorithm (BI): The case for which the system can read data from DC table before it completes the execution of all the processes of the current period.
Example 4.5. Let us discuss a case where the control unit has 3 processors, applying SB algorithm will produce the following results = 10 h:10 min, = 10 h:13 min, = 1 data/min So, = ( − ) × = 3 × 1 = 3 So, for this case the best solution will be to have 3 data retrieval from 10 h:10 to 10 h:13 i.e. we can retrieve all data from DC. Consider the below instances (time in seconds) ( Table 1): Figure 3 illustrates how the system schedules the given processes by applying SB algorithm, where it can be noticed that SD max = 2.
Example 4.6. To achieve a change in schedule 1 that was described in Example 4.5 in order to minimize 1 max . Executing the enhanced algorithm will produce the results given in Figure 4. Figure 4 shows that SD max = 3. it is easy to obtain SD max = SD(3) = 3. Thus, the used algorithm in this example to schedule processes at period SD(1) in Figure 4 gains better results than the algorithm cited in Figure 3. Besides that, the case of this example is the best one because SD max = SD(3) = 3.

Scheduling problem
To solve the scheduling problem based on identical parallel processors problems, many heuristics will be developed and adapted for the case when the period SD( ) is fixed and the concerned problem is denoted by . The function (SD( )) that will retrieve data from DC table based on the period SD( ) is called by the control unit, the called function will provide the number of the corresponding processes and the table that has all the processes in the period SD( ).
The control unit calls a function named ( , ) to execute the heuristic described by the algorithm above, where ( , ) produces the appropriate schedule during the period SD( ) for the set of processes and  the number of related processes . Execution of the function ( , ) provides processes assignment and the corresponding max . Where (SD( )) is the set of processes that will be sent during the period SD( ) and will be scheduled to the available processors.
The following Section 5.1 is devoted to explaining the heuristics already cited in literature review regarding parallel machines, which will be utilized in this paper, by the developed algorithms for the studied problem.

Parallel processors heuristics
Many parallel processors algorithms will be utilized to develop new heuristics that are expected to solve the presented problem. The first algorithm is the longest processing time and is denoted by LPT. This algorithm is based on sorting the given processes according to the non-increasing order of their processing time. The complexity of the LPT algorithm is ( log ). The second algorithm is the dispatching rule SPT, in this algorithm the processes are sorted based on the non-decreasing order of their processing time. The complexity of the SPT algorithm is ( log ). While the third algorithm is the subset-sum based-heuristic (SS). The complexity of the SS algorithm is ( ). The chosen approach for SS is the utilization of the greedy algorithm to solve iteratively different subset-sum problems (SSP) that is denoted by with { = 1, · · · , − 1} and presented in equation (5.1). The processing time of the process is denoted by . : where is the returned processes when applying the subset-sum algorithm for and where = {1, 2, · · · , − 1}. ( , ) is a lower bound of the problem with a resulted makespan for the instance that is defined by ≤ processors and a subset of processes ⊂ . As a result, the system will continue assigning processes to the first processor until reaching on 1 . The remaining processes will be distributed over the rest of the available processors, this will generate the second problem 2 that will be solved by the new SSP until the limit is reached and so on [19]. A pseudo-polynomial based on dynamic programming algorithm detailed in [39] is used to solve the subset sum problem.
The heuristic multi-start subset-sum (MSS) described in [19] will be derived based on solving the problem. The MSS algorithm can be explained as follows. As shown in [19] the 2 || max will be reformulated as a subsetsum problem. Based on this proposition, a multi-start local search method will be implemented, this method requires a repetitive solving of a two-processor problem. Given a feasible schedule and assuming that all processors are indexed such that 1 ≤, · · · , ≤ . Define a binary variable with a value 1 if the process is assigned to 1 , and a value 0 otherwise. Then, 2 || max will be interactively solved by applying SSP. The idea developed in (MSS) will be used in the multi-start knapsack heuristic (MSK), a difference of how the problem is being solved in each iteration. MSK uses knapsack problem (KP) to solve the given problem for each iteration rather than using the SSP [18]. Since the KP problem can be solved efficiently in pseudo-polynomial time. The complexity of the MSS algorithm is ( 2 ). The complexity of the knapsack ( ) where, is the number of items and is the capacity of knapsack. The MSK heuristic utilize the knapsack problem with multi restart.
In this paper, we propose five categories of algorithms. Each category utilizes the parallel machines heuristics presented earlier. The first category is the separated blocks algorithms. The second one is the reverse-interference based algorithms. The third category is the fictitious-processes based algorithms. The fictitious-processes with the MSS heuristic for each iteration will represent the fourth category. The fifth category is the interference processes-blocks based algorithms. The first category is presented by the separated blocks category, while the categories 2, 3, 4 and 5 are presented by the blocks interference category.

Separated blocks category algorithm
For the separated blocks algorithm (SB), the constraint to consider when retrieving data from DC table is the following: "For the current period, the system can't retrieve data from DC table before the execution of all processes" as explained in Example 4.1 above. Calculate the corresponding max for each period SD( ), where the total of max is the sum of all max . So, max = ∑︀ SDmax =1 max . In this algorithm current time is returned by the function () and the algorithm SB is structured as follows: The disadvantage of the SB is the lose of opportunity to assign processes of the period SD( + 1) to the available time slot in the period SD( ). This is because of the data retrieval constraint, which prevents reading from the DC table before processing all processes in SD( ).
In this paper, () represents one of the parallel processors algorithms described in the Section 5.1 and ( , ) is the related result, which is obtained by the heuristic for the processes set and the number of processes .
Based on the five presented algorithms in Section 5.1, Algorithm 2 can be used by replacing ( , ) by one of the parallel processors algorithms presented in Section 5.

Blocks interference category algorithm
For the blocks interference algorithm (BI), the constraint for data retrieval from the DC table is the following: "The system can retrieve data from DC table before the execution of all processes at the current period". This means, for the first block we try to utilize the SD(1) processors availability. After assignment of processes in SD(2) we use SD(2) processors availability by processes given in SD (3) and so on. The total max is calculated after scheduling of all processes.
The problem here, is how to utilize the processors availability between blocks SD( ) and SD( + 1).
Remark 5.1. For each block or period SD( ) we apply a heuristic 1 to schedule processes at this period. To merge two blocks SD( ) and SD( + 1) we must apply a method that ensures merging. The fictitious-processes based algorithm given in Section 5.3.2 is one of the methods that ensure merging. For this latter algorithm, we have to choose one of heuristics 2 that can be applied for merging. The heuristics applied for each block and the heuristics applied to merge blocks are not necessary the same. The question here is: to have a best solution, what is the best choice for 1 and the best choice for 2 ?
This study presents algorithms that are related to the blocks interference algorithm (BI). The complexity of the blocks interference category algorithm depends on the choice of 1 and 2 .

Reverse-interference based algorithm
The procedures that are used in the reverse-interference based algorithm is described next. The completion time of the processor in the period SD( ) is denoted by . The given processes are sent to the procedure ( ) to be sorted by list in the non-decreasing order. However, ( ) is the procedure that arranges the given processes in the list in the non-increasing order. The reverse-interference algorithm (RI) is described in Algorithm 3.
Once we started the execution of the processes in the period SD( ) and at the moment when the data of the period SD( + 1) arrives, we assign the processes of SD( + 1) according to the remaining of processors availability, after the period SD( ). The availability will be calculated based on fixing the time for each processor related to period SD( ). So, the control unit supposes that all the processes of SD( ) period are scheduled, then the control unit takes advantage of the processors availability during the period SD( ). To utilize the availability in each period the control unit takes some processes of SD( + 1) and allocates it to the available periods of SD( ). As shown in Figure 7 cited in Example 4.6 when the data of process 7 arrives, the control unit places this process on processor 3 during the period SD(2) before 2 max . if ( == 1) then 10: if ( ≥ 2) then 14: ( 1)

16:
for ( = 1 to ≤ ) do 17:  Table 2. Fictitious-processes. For instruction 6 in Algorithm 3, we replace ( , ) by one of the parallel processors algorithms described in Section 5.1. Thus, we denoted by RI LPT , RI SPT , RI SS , RI MSS and RI MSK the values returned by the Algorithm 3 replacing the function ( , ) by LPT, SPT, SS, MSS and MSK, respectively.
The complexity of the Reverse-interference based algorithm depends on the choice of ( , ).

Fictitious-processes based algorithm
For this algorithm, instead of making the reverse of the completion time between increasing and decreasing, in order to enhance the final completion time, we apply a dispatching rule, which considers that all processes are executed on one processor as one fictitious process. Indeed, for SD(1) we apply a ( , ). For the second period SD(2), we apply the same ( , ). Now, the connection between SD(1) and SD(2) is as follows, for SD(2) we assume that each completion time 2 of each processor is considered as a fictitious process 2 . Applying a dispatching rule to schedule all 2 on processors while taken into consideration the period SD(1). In general, for the period SD( ) the fictitious processes denoted by has the processing time ( ) . The following example gives an illustration of the fictitious-processes constitution.
Example 5.2. Let = 10 and = 3. Assume that the details of the sending data are as shown in Table 2. After applying a given heuristic to schedule processes in Table 2 to all processors, the results are given in Figure 5. From Figure 5, during the period SD(2) on processor 1, there are processes 5 and 6. These processes, will be treated as one fictitious process 2 1 . The sum of processing time of processes 5 and 6 will constitute the processing time of ( ) 2 1 . Therefore, ( ) 2 1 = 2 5 + 2 6 = 30. Applying the same method for processes 7 and 8 on processor 2, we have ( ) 2 2 = 20 and for processes 9 and 10 on processor 3 we have ( ) 2 3 = 25, (please refer to Table 2, to check processes 5, 6, 7, 8 and 9 processing time). Now, the processes 2 1 , 2 2 and 2 3 will be scheduled on all processors, taken into account the processes already assigned during SD(1) and the processing time ( ) 2 1 , ( ) 2 2 and ( ) 2 3 . Applying LPT rule, 2 1 will be assigned to the most available processor in SD(1) which is processor 1. So, the completion time on processor 1 will be 70. After that, the most available processor is processor 3, the largest fictitious processes is 2 3 . We schedule 2 3 on processor 3 and the completion time of processor 3 will be 85. Next assign 2 2 to the most available processor which is processor 1 with minimum completion time of 70 comparing to processors 2 and 3 which have 100 and 85 as their completion time, respectively. Thus, the completion time of processor 1 will be 90. At this stage the maximum completion time is 100 in processor 3. Figure 6 illustrates the scheduling of fictitious-processes.
After constructing of fictitious-processes, scheduling of these processes will be performed by applying suitable heuristics. Thus, we denoted by FP LPT , FP SPT , FP RL and FP IRL the values returned by fictitious-processes based algorithms when applying LPT, SPT, RL and IRL, respectively. The RL is the randomized LPT and IRL is the iterative randomized LPT.
The complexity of the fictitious-processes based algorithm depends on the choice of ( , ).

Fictitious-processes with multi-subset based algorithm
For this algorithm, the first step is to construct all fictitious processes, then schedule these processes by using some of the proposed heuristics that were described in Section 5.3.2. The scheduling of these processes is the manner that is used by 2 to merge two blocks SD( ) and SD( + 1) described in Remark 5.1. For each block or period SD( ), we apply the heuristic MSS to schedule processes at each period. We denoted by FPM LPT , FPM SPT ,

FPM RL
and FPM IRL the values returned by fictitious-processes based algorithm when we apply LPT, SPT, RL and IRL as 1 . While MSS will be applied as 2 .
The complexity of the fictitious-processes with multi-subset based algorithm depends on the choice of 1 and 2 .

Interference Processes-blocks based algorithm
For this heuristic, instead of constructing of the fictitious processes, to ensure connection between periods; the system schedules processes of period SD( + 1) with continuity of period SD( ). This means, the system schedules process by process of period SD( + 1). Indeed, for the first period SD(1) we apply heuristic 1 and for period SD(2), we apply the same heuristic, but we schedule process by process taking into account the scheduling made in period SD (1). In other words, heuristic 1 selects the process to be scheduled on the most available processor after finishing the scheduling of processes in period SD( ).
We denoted by IPB LPT , IPB SPT , IPB RL and IPB IRL the values returned by interference processes-blocks based algorithm when we apply LPT, SPT, RL and IRL, respectively.
The complexity of the interference Processes-blocks based algorithm depends on the choice of 1 .

Sequencing-based train algorithm
This section presents the algorithm that describes the details of all running processes during a train trip, from the starting point till the train arrives at its final destination. For that purpose, we construct a sensors index, based on sensors positions { ( 1 ) < ( 2 ) < · · · < ( )}. So the first sensor is the one nearest to the train passage. If the sensor stimulates an attention request in the control unit, this means that the variation value of vector ( ) is not null, for which the algorithm must run a function that is responsible of estimating the needed time to complete the required intervention. This function is called (), the input of this function is the location state of the considered sensor. while ( ( 1 )) returns the estimated time of maintenance reserved to position ( 1 ) related to sensor 1.
( ( 1 )) is the function that reads a file saved in the server and sent by the maintenance group, this file specifies the time required to finish maintenance process in position ( ) in real time. In this case, when implementing the sequencing-based train algorithm in real time, we must consider this question, what are the train options if it reaches the problem location before maintenance is finished? What instructions, the control unit must execute to avoid latency or an accident? To answer these questions, the algorithm named: sequencing-based train algorithm, was proposed. Figure 7 shows the train tracking example when an intervention is required.
As Figure 7 shows, if maintenance time is greater than the time required for the train to arrive at the position of the sensor with the problem; then there are two choices: The remaining time to arrive at a sensor location will be denoted by = − (in minutes), as shown in Figure 7. If ≤ then the train can continue without any delay or any stopping. But if > the control unit must send an alert to the driver, requesting a speed decreasing. The train delay time will be: = − . The distance between the position of the train at time and the position of sensor indexed will be denoted by and will be calculated as: . While the new reduced speed that was proposed by the control unit after the maintenance alert, will be denoted by where = ×60 . Which means the train must travel with a speed (in worst case) to arrive at time with > . In the case of a delay, the control unit will activate a function that sends an alert to the driver with the following data (new speed, the modified arrival time considering the delay), this function will be denoted by ( , , ). Based on the above analysis we propose the following heuristic:

Experimental results
This section presents the experimental results obtained by executing the implemented heuristics. The performance of the lower and upper bounds assessment is achieved after the implementing the developed heuristics in Microsoft Visual C++ (Version 2013). All experiments were executed on an Intel(R) Xeon(R) CPU E5-2687W v4 @3.00 GHz and 64 GB RAM workstation that has windows 10 with 64 bits operating system.

Test instances
The used instances are based on the selection of , , and . We generate 8 types of class instances of different processing times. These classes are based on the uniform distribution and normal distribution. The uniform distribution is denoted by [ , ] which gives a random number between and . While, the normal distribution is denoted by [ , ] with mean and standard deviation . (SD( )) 5: (SD( )) 6: while ( (SD( )) ̸ = ∅) do 7: Alert to maintenance in ( ) The processing time in this paper is generated as follows: -A, the is in [1,5]. -B, the is in [1,10]. -C, the is in [5,10]. -D, the is in [10,20]. -E, the is in [10,30]. -F, the is in [1,20]. -G, the is in [5,2]. -H, the is in [5,4].
For the variables ( , , , ), where represents the number of sensors, is the related multiplicator, is the number of processors and is the type of the generated processing time. The generated instances of processes were 10.
This type of generation resulted in a total number of instances equals to 6 × 5 × 4 × 8 × 10 = 9600. The number of sent data is × . For example, if = 3 and = 7, there are 21 sent data which addresses the value of .

Evaluation metrics
To assess the performance of the developed heuristics, several metrics are defined and presented as described next: -* is the minimum value returned after the execution of all algorithms. is the studied heuristic.   is the percentage of instances when * = over a specific number of instances. -is the average running time for a fixed number of instances.
Our experimental study is based on the comparison between the developed algorithms for each category. After that we consider the best heuristic in each category and compare between them. Finally we present the comparison between all algorithms.

Separated-blocks category comparison
In this category of algorithms, five heuristics were developed as was described in Section 5.2. The results of the separated blocks category algorithms are presented in Table 3. From this table we can observe that SB MSK is the best heuristic in the separated-blocks category in 98.4% of the cases. However, the average running time of this heuristic is very high around 749.628 s. The heuristic that has the minimum percentage is SB SPT . Whereas SB MSS heuristic has the second best case value of 69.9%; if we consider the running time which is only 1.687 s or (0.0022) of the time consumed by SB MSK heuristic. In Table 4, the behavior of GAP according to SB heuristics is presented, as it can be seen from the shown results, SB MSK heuristic has the best results with (0.00) GAP for all values, while the SB SPT has the worst performance at = 20. The GAP value less than 0.01 was obtained by heuristics SB LPT at = 3, SB SS at = {3, 5}, SB MSS at = {3, 5, 10} and SB MSK for all values. The behavior of GAP according to the number of processers for all SB algorithms is given in Table 5, where SB MSK heuristic has the best results for all values, while the SB SPT has the worst performance at = 6. The GAP value less than 0.01 was obtained only by SB MSK heuristic for all values.  Notes. The best results are given in bold.
The results of all SB category algorithms are presented in Table 6, for comparison purposes and for more details. The worst GAP values were obtained by heuristics SB SPT at = 50 and = 8, SB LPT at = 5 and = 2, SB SS at = 100 and = 2 and SB MSS at = 100 and = 2. While all GAP values for SB MSK heuristic were less than 0.01 for all and values except at = 20 and = 2 the GAP value was 0.01.

Reverse-interference category comparison
For this category of algorithms, five heuristics were developed as described in Section 5.3.1. The results of the reverse-interference category algorithms are shown in Table 7. In this table it can be noticed that RI SS is the best heuristic in the reverse-interference category with 84.2% cases. However, the average running time of this heuristic is acceptable around 0.034 s. The heuristic that has the minimum percentage is RI SPT . It is worthy to note that, MSK is the best heuristic for the parallel machines, however for the RI algorithms the utilization of SS becomes more efficient and produces better results for the studied problem.
In Table 8, the behavior of GAP according to is presented for all RI category algorithms, the given results show that the RI SS heuristic has the best performance based on GAP values for all values, while RI SPT heuristic

Fictitious-processes category comparison
In this category of algorithms, four heuristics were developed as described in the Section 5.3.2. Table 11 shows the results for the fictitious-processes category algorithms. From this table it can be observed that FP LPT has the best heuristic in the fictitious-processes category with 76.2% of cases, with a good average running time around 0.005 s. The heuristic that has the minimum percentage is FP SPT . In Table 12      The behavior of GAP according to the number of processers for all FP algorithms is given in Table 13. Based on the given results, increasing the number of processors does not necessarily mean an increase in the performance. For example, the GAP value for FP SPT heuristic was 0.76 at = 2 and increases up to 0.96 when = 8. While for FP LPT heuristic, the case was different as it can be seen from

Fictitious-processes with multi-subset category comparison
In this category of algorithms, four heuristics were developed as described in the Section 5.3.3. Table 15 shows the results of the fictitious-processes with multi-subset category algorithms. From this table, it can be observed that FPM LPT is the best heuristic in the fictitious-processes with multi-subset category in 76% of the cases. However, the average running time of this heuristic is acceptable around 1.294 s. The heuristic that has the minimum percentage is FPM SPT . In Table 16, we present the behavior of GAP according to for all FPM category algorithms. Based on the shown results it is noticed that the performance of the given algorithms increases as the value of increases for all heuristics. Also, it is noticed that FP LPT , FP RL and FP IRL heuristics were more sensitive to values than FP SPT heuristics. The behavior of GAP according to the number of processers for all FPM algorithms is given in Table 17. Based on the given results, the best obtained results for all heuristics were obtained at = 2, increasing the number of processors does not necessarily mean an increase in the performance.
For more details of the FPM category algorithms,   Notes. The best results are given in bold.

Interference processes-blocks category comparison
In this category of algorithms, five heuristics were developed as described in the Section 5.3.4. Table 19 shows the results for the interference processes-blocks category algorithms. From this table it can be observed that IPB LPT is the best heuristic in the interference processes-blocks category in 79.2% of the cases. However, the average running time of this heuristic is good around 0.006 s. The heuristic that has the minimum percentage is IPB SPT . In Table 20, we present the behavior of GAP according to for all IPB category algorithms. As it can be noticed from the given results, increasing values improves the values of all heuristics and that the IPB SPT heuristic was the least sensitive to the increase for the given problem.
The behavior of GAP according to the number of processers for all IPB algorithms is given in Table 21. The given results showed that increasing the number of processors does not necessarily mean an increase in     the performance for all the given heuristics. For the given problem in this research, increasing the number of processors is not significant and the best GAP results were obtained at = 2 for all heuristics. For more details of the IPB category algorithms,

Comparison between best category algorithms
The best algorithms were SB MSK , RI SS , FP LPT , FPM LPT and IPB LPT for the categories SB, RI, FP, FPM, and IPB respectively. Notes. The best results are given in bold.
In this subsection, we compare these heuristics to find the best heuristic between all algorithms developed in this paper.

Conclusion
This research utilizes operational research in railway systems to address identical parallel processors scheduling problem. Because of trip constraints and time schedule limitations, railway system must complete all the given requests in a limited time. This is an NP-Hard problem, and the main goal is to minimize the maximum completion time of the received requests. This problem was solved by developing new heuristics based on two categories of algorithms, the separated blocks category algorithm (SB) and the blocks interference category algorithm. The first category is composed of 5 heuristics. While the second category is composed of four algorithm types, which are, Reverse-interference based algorithm (RI), Fictitious-processes based algorithm (FP), Fictitious-processes with multi-subset based algorithm (FPM) and Interference Processes-blocks based algorithm (IPB). Each algorithm type is also composed of different heuristics, RI algorithm has 5 different heuristics, FP algorithm has 4 different heuristics, FPM algorithm has 4 different heuristics and IPB algorithm has 4 different heuristics. The total of the developed heuristics are 22. The performance assessments of the developed heuristics were performed for the execution time based on the average relative gap; the given results showed that there isn't any dominance between the algorithms and the best heuristic for the proposed problem was FPM LPT heuristics in 34.2% of the cases. The presented solution was capable of reading data from DC table before finishing the execution of all previous processes, which enables the control unit of the railway monitoring system, to derive the proper instructions for each request type, to ensure that there will be no latency or cancelation for any of the scheduled trips.
In this work, the maximum percentage is 34.2% which is relatively small, the next objective of this work will be to enhance the presented heuristics to achieve a percentage of no less than 50%. The expected enhancement will be reached by considering three aspects. The first issue will be to search for a metaheuristic that use all the given heuristics. The second consideration is to apply a variable neighborhood search (VNS)to enhance the given heuristics. Finally, derive a lower bound for the studied problem to be compared with the results obtained by the given heuristics.