Travelling Salesman Problem Solution Based-on Grey Wolf Algorithm over Hypercube Interconnection Network

Travelling Salesman Problem (TSP) is one of the most popular NP-complete problems for the researches in the field of computer science which focused on optimization. TSP goal is to find the minimum path between cities with a condition of each city must to visit exactly once by the salesman. Grey Wolf Optimizer (GWO) is a new swarm intelligent optimization mechanism where it success in solving many optimization problems. In this paper, a parallel version of GWO for solving the TSP problem on a Hypercube Interconnection Network is presented. The algorithm has been compared to the alternative algorithms. Algorithms have been evaluated analytically and by simulations in terms of execution time, optimal cost, parallel runtime, speedup and efficiency. The algorithms are tested on a number of benchmark problems and found parallel Gray wolf algorithm is promising in terms o f speed-up, efficiency and quality of solution in comparison with the alternative algorithms.


Introduction
Due to the large increases in the number of cities in the world, mobility between cities has become difficult because of there existing many dissimilar roads to reach the same city with different travelling cost (Vukmirović and Pupavac, 2013), where there are several places that are all directly connected to each other by different long roads and the passenger wants to make the shortest trip.Some Algorithms can be used to guide people using one of the transport or movement methods (walking, train, car, and bus) to reach their destination on the shortest route.(Zhan and Noon, 1996).
TSP is arisen in many different practical applications such as School bus routes, Computer wiring, job -shop scheduling and many more (Matai, et al., 2010).While there is many applications of TSP then applied new algorithms and architecture could give the opportunity to inspire new solutions that could be better than existing ones, which means, optimizing for all of these applications.
TSP has received great interest from researchers and mathematicians, as it is easy to describe, difficult to solve.TSP problem has a place in a big class of problems known as NP-complete, as shown in Figure 1.In particular, if an efficient algorithm (polynomial time) can be found for solving TSP, then efficient algorithms could be found for all others.(Karla, et al., 2016).
Figure 1.NP -Complete Problems (Al-Shaikh, et al., 2016) TSP is the problem of finding the shortest route between cities or nodes which classified as minimization problem (Lam and Newman, 1985), the problem is to create the shortest route in the form of aggregation to visit each node exactly once and then return to the initial node (Kan and Shmoys, et al., 1985).
TSP is a permutation problem which required O (n!) as time complexity (Kaempfer and Wolf, 2018).There exist an algorithm called Held and Karp algorithm as in (Chekuri, 2017) based on dynamic programming to solve TSP where they reduce the computational time complexity to O (2nn2) but it's still too high for solving big size of realworld instance.

TSP Formulation
Miller (as cited in Sawik, 2016) shows that TSP can be defined as an integer linear program as follow: Xij = 1 There is rout from city i to city j 0 No rout Where x is a variable for an n city problem, by defining the Travelling cost between two cities i and j is ci.j and ui is a temporary variable, Miller shows how TSP can be defined as an integer linear program as : Where equations 2 and 3 are used to ensure that each city on the route can only arrive from another city exactly once, Equalities 4 and 5, it is necessary for each city on the route, there is an exit to the another city.Fin ally, equation 6 is used to ensure that there is only one route covering all cities, which means that they cant be multiple, simultaneous and unconnected paths.
While the importance of the TSP in numerous fields and for its applications, many researchers s olve it using different approaches aspiring to get a better solution than existing such as : Bee Colony Optimization (BCO) (Wong, el al., 2008), Ant Colony Optimization (ACO) (Yang, et al., 2008), Firefly algorithm (FA)(Kumbharana and Pandey)( 2013) and Heuristic Algorithm (Hernández, el al., 2016).These methodologies do not generally locate the optimal solution.Rather; they will often find the near-optimal solutions for the problem.Most of these algorithms called Swarm optimization (SO) (Poli, el al,2007) or Meta-Heuristic optimization mechanisms (Blu m, el al, 2007), SI is an intent of design or distributed problem-solving inspired devices by the collective behavior of colonies of insects social and other sociedades animals (Raja, 2015), which can be used to solve many types of optimization problems.As an examples in natural systems of Swarm optimization are include Bacterial Growt h (Zwietering, el al.,1990), whales (Mirjalili and Lewis, 2016), Bird Flocking (Reynolds, 1987), Fish Schooling (Bastos, et al., 2008) and spiders (James and Li, 2015).Swarm intelligence techniques become very popular and commonly used in solving many types of optimization problems due to many advantages, some of these advantages are (Kordon): • Easy to implement.
• Fewer numbers of parameters to adjust.
• Less memory to save (less space complexity).
• Obtained good results in responsible time.
Grey Wolf Optimizer (GWO) is a recently established SI optimization mechanism where their many researchers used it to solve many optimization problems such as Parameter Estimation in Surface Waves (Song, el al., 2015), Economic Emission Dispatch (Song, et al., 2015) and Scheduling problem (Komaki and Kayvanfar, 2015).
The inspiration for GWO is from a species of wolves called the Grey Wolf (Canis lupus), by imitating its hunting methods and hierarchical pack distribution, which are referred to as; Alpha α, Beta β, Delta δ, and Omega (ω); these are used to imitate the series of commands as shown in Figure 2.
Figure 2. Hierarchy of Grey Wolf (Mirjalili and lewis, 2014) As seen in figure 2, sovereignty reclines from top to bottom.The first level is Alpha (α), which is the leader, which is not necessary to be the most robust wolf but the superior to other wolves in managing the pack.Thus it is responsible for the decision making.The second level is Beta (β), which helps Alpha in decision making.Thus, it represents as the mentor to Alpha and an educator to the pack.The third level is Delta (δ) which controls Omega (ω).This category could be Scouts , sentinels, elders, hunters, and caretakers.Finally, the fourth level is Omega (ω) that acts as the scapegoat and gives up to all dominant wolves.
In the real world, there are many complicated events that occur simultaneously and in a temporal sequence like weather and galaxy formation, where that far exceeds the capabilities of single-processor architectures (Worboys, 2005).
Therefore, the concept of parallel computing seemed to increase performance and reduce computation time to solve these problems (Barney, 2010) where parallel machines break a single problem in parallel tasks that were performed simultaneously, as TSP problem.Parallel computing is much more suitable for modeling and simulating complex problems (D'Angelo, 2011).
Hypercube is a multi-dimensional mesh of processors with exactly 2 processors in every dimension; this means that a two-dimensional hypercube is made up of processors p = 2 ^ d.For example, a zero -size hypercube is a single processor.In general, a hypercube (d + 1) -dimensional is constructed by connecting the corresponding twodimensional hypercube processors as shown in Figure 3 (Bhuyan and Agrawal, 1984).In this study, we decide to use hypercube because of its performance measure proved that it has a better performance compared with static network topologies (Kiasari, et al., 2008) wise of Diameter, Bisection Width, Arc Connectivity and the Cost as shown in Table1.And also, because of the topology of hypercube was implemented in many supercomputers such as Endeavour Supercomputer by NASA (Cathleen, 2011).
The main contributions of this paper are summarized as follows: • This study adapted GWO to solving the TSP problem, its executed sequentially on different size of World TSP benchmarks and measure the performance in terms of execution time and optimal cost.

•
To compare the result of the GWO with other meta-heuristic algorithms, GA (genetic algorithm) and CRO (optimization of the chemical reaction) are chosen and adapted to solve th e TSP, the performance metrics are measured in terms of execution times and optimal costs.
• Development of the parallel GWO.The parallel GWO is developed on the basis of both data and computation distribution techniques through the hypercube interconnectio n network.Data distribution technique is designed based on dividing the dataset map (cities) with a goal of achieving load balancing among the interconnection network.Computation distribution is provided by distributing GWO iterations through the interconnection network to reduce the computing time.
• A comparison between PGOW (Parallel Grey Wolf Optimizer), PCRO (Parallel Chemical reaction optimization) and PGA (Parallel Genetic algorithm) in terms of execution time, parallel runtime, speedup, efficiency and optimal cost.The PGWO shows better performance results than PCRO and PGA.
The remaining of this paper is structured as follows: In Section II, a work related to this study is presented, section III addresses our parallel model for GWO for solving TSP, then in Section IV, the analytical evaluation of the sequential and parallel version of TSP-GWO is presented.Section V shows the discussions of our experimen t al results.Finally, conclusions and future work are in section VI.

Related Works
Several researchers have been conducting research on solving TSP and apply their algorithm on different topologies; below are some of these very recent studies.
A recent meta-heuristic algorithm used to solve TSP in (Kumbharana and Pandey, 2013), where authors used the Firefly Algorithm (FA) to solve TSP problem, the experimental results obtained on different size TSP instances.Authors show that the proposed algorithm provides better results than (ant colony optimization) ACO, genetic algorithm (GA) and simulated annealing (SA) in most of the instances.Also, in (Bhardwaj and Pandey, 2014), they presented a Parallel Ant Colony (ACO) algorithm to solve TSP in heterogeneous platform using the OpenCL framework.All the parameters of the algorithm in ant system are been investigated to their best values as control parameters, where α and β represent the dependency of probability on the pheromone content or the heuristic and equal to α = 1, β = 5 and ρis the evaporation rate = 0.5.The parallel implementation is done on CPU and GPU using OpenCL, where GPU gives better results.In (AbdulJabbar and Abdullah, 2016), authors proposed a hybrid algorithm based on two metaheuristic methods: simulated annealing (SA) and tabu search (TS).The goal of using tabu search is to resolve the long computation times that take from SA by keeping the best -founded solution in each SA iteration.By comparing with the basic version of SA, authors found the proposed approach reduces the time complexity by finding the optimal path (best solution) with a few numbers of iterations.In another study (Anjaneyulu, et al., 2014), they used approximation algorithms to find near-optimal solution, the approximatio n algorithm used for maximizat ion or minimizat ion based on the problem, when it comes to TSP it is minimizat io n .They focused on a special case of TSP, which is Metric TSP (the distance between two cities is the same in each opposite direction), then they proposed a parallel two -approximation algorithm for metric TSP.Finally, they reported that the algorithm found near optimal solution with a significant reduction in runtime.In (Razali and Geraghty, 2011), authors have used the Genetic Algorithm (GA) but with Different Selection Strategies to solve the TSP problem, they firstly use Tournament selection strategy as a popular selection method in genetic algorithm then they try another selection strategy called Proportional Roulette Wheel Selection and as a final selection strategy, they use a Rank-based Roulette Wheel Selection.The algorithms are cod ed in MATLAB and tested by eight TSP instances.They found that GA with the rank-based roulette wheel selection always gives better solution quality than the other selection strategy.
Because of the importance of TSP and its applications (Applegate, et al., 2007), this study presents a solution to the TSP by using the GWO, where GWO is a recent establish meta-heuristic optimization mechanisms and its success in solving many types of optimization problems with good results.To compare the result of GWO with alternative meta-heuristic algorithms, GWO will be compared with GA and CRO.GA regardless of achieving great success in solving many optimization problems, it is also used for comparison in most meta -heuristic optimizatio n research like in (Shaheen and Sleit, 2016), (Ross and Corne, 1995) and (Ingber and Rosen, 1992).Also, CRO used to compared with GWO because it is one of the newest meta-heuristic algorithm where it also obtained good results in solving NP problems as in (Barham, et al., 2016), (Shaheen, et al.,2018) and (Sun, et al., 1990).

Proposed Approach
GWO is a new nature-inspired metaheuristic (Swarm intelligence) where this type of algorithms are inspired by natural systems (Mirjalili, et al., 2014).GWO gets its name from the nature of the social hierarchy of wolves, as well as their hunting behavior.The Hunting behavior of Grey Wolves is split into four procedures: (1) Chasing, (2) Encircling, (3) Hunting and (4) attacking the victim.In Chasing phase, The Algorithm considers that α is the best solution; β is the second best solution and δ is the third best solution.However, ω represents the rest candidate solutions.Thus the hunting is led by the dominant wolves (α, β, and δ).In other words; Grey Wolves could recognize the position of the prey through an iteration process and surround it as in encircling phase, Grey Wolves bounded the victim through the hunt (optimization) by calculating the distance between the location of the prey.
In hunting phase, The hunt generally is led be the leader (α).However, sometimes β and δ contribute in hunting.
In another hand, there is no idea about the position of the prey that represents the optimum.Therefore, the algorith m assumes that α, β, and δ has preferable knowledge about the position of prey.Thus, the algorithm saves the first three best solutions then update the locations of the rest wolves (ω) depending on the position of the dominant wolves (best search agent) and in attacking phase where it's the final phase, the hunting proceeding obtained the optimization solution the prey stops proceeding.
In this paper, we used the concept of GWO to solve TSP.The proposed solution is implemented in two approaches.
In the first approach, the algorithm is implemented sequentially using the standard JAVA programming language where the second approach of the implementation uses Java multithreading and aims to make the most of CPU processing power.The reason for implementing two approaches of the algorithm is to demonstrate the feasibility of the parallel structure.The approaches are implemented in the most logical way possible.

Sequential ALGORITHM: "GWO-TSP"
In GWO, there are four types of wolfs: Alpha (α), Beta (β), Delta (δ), and Omega (ω) and the prey, wolfs applied the hunting methods to hunt prey, this is being implemented in a hierarchical way until Alpha wolf take the decision of attack.TSP contains number of cities while there is a cost of Travelling between each pair of cities, the objective is to find the shortest path going through all cities, which means a simple cycle tour, which starts and ends at city 1.By applying GWO to find the possible solution for TSP, Figures 4 present the pseudo -code for the proposed "GWO_TSP" sequential algorithm, TABLE 1 shows the main attributes and their meaning related to the proposed algorithm "GWO_TSP", in comparison with wolfs meaning in GWO.

Fitness function
Current optimal TSP solution.
The GWO-TSP algorithm, as shown in Figure 4 (see lines 1, 6 and 23, present these three stages).First, the initialization stage can be shown in Figure 4 (see lines 1-5) to assign initial values for the algorithm parameters.Each individual in the Population is an array, which represents the maximum number of candidate solutions.While each of them consists a full tour as in Table 1.Next, initialize and as sign the value of three preys, this is because as the concept of GWO, its assumes that first three wolves (α, β, and δ) has preferable knowledge about the position of prey and as Table 1 each prey represent a city from the city map.Population (see line 4) is an empty array used to constructing the candidate solutions.In order to start building solutions, three preys (or cities) will be selected randomly from the city map (data-set) and added as an initial population where all towns that surrounding them are considered the grey wolves which is the final step in the initialization stage.The goal of Iteration stage is to generate and build the candidate solutions (or tours) until reaching the best solution.Iteration stage is shown in Figure 4 (see lines 6-22).After generating the three required population as in the initialization stage, each of them will contain a prey that surrounded by a group of wolves.The function (see line 9) used to calculate the destination of all wolfs from the prey then returns the nearest three wolfs from the prey and added to Xα, Xβ, and Xδ respectively.Now, based on the positions of the three best wolves, the Xα will be added to the original population and two new population will be created and added the prey in each one plus Xβ and Xδ respectively.That's mean, each population will generate two new population and each of them will contain two preys.In other words, after the first iteration, the number of population will be equal nine and each of them will contain two preys.Next, the algorithm will calculate the fitness for each population, which means, the cost of Travelling between cities.While increasing of number of population, the function (see line 20) used to remove the most costly tour.This will happen when the number of population is larger than the allowed population size.Iteration stage keeps working until reaches the stopping criteria, two stopping criteria used to stop the iteration stage.Firstly, the number of population must be larger than the allowed population size, and each population should be contained a full solution.Which means, as equal as the number of cities, this is done through FullTour function.In the final stage, the best solution found will be retrieved.
To understand how this study uses GOW to optimize TSP problem, as in figure 5.a.It shows a TSP problem which is an undirected graph of four cities and six edges, each edge has its own Travelling cost, which will be used in this example to represents the possible solutions.Based on TABLE 1, each element in GWO represent what its means in GWO-TSP, for instance, Gray wolf population in GWO represented in GWO-TSP as the candidate solutions of TSP.By adapting the elements in GWO to our proposed algorithm, The example that was displayed in Figure 5.a this will become as shown in Figure 5.b.

Parallel ALGORITHM: "GWO-TSP"
The large number of possible solutions, even with a GWO, opens the possibility of parallelizing the solution for the TSP problem, in which the main objective of this paper is to study the possibility of parallelizing the GWO to solve the TSP problem.In our proposed model, we have created the parallel version of GWO (PGWO) that can be efficiently executed on the Hypercube interconnection network.
For developing PGWO, original TSP map must be divided to achieve load balancing among all processors.In this study, We divide the problem of TSP into sub-problems by creating districts from the original map (dataset) during the partition operation, then we apply the GWO-TSP steps on each part of the district generated by the partition operation.The partition operation consists of two steps: • Find the highest and lowest values edges of the map.
• Divide the map into multiple districts by subtracting the highest v alues from the lowest values then dividing the difference by the desired value.Figures 6.1 -6.3 show how districts are created from a original map.The number of districts depends on the number of processors we use, for example, if the number of processors is 16, then the number of districts must be at least equal16.The equation 7 was used to find the number of districts.

D = N (7)
Where D is the number of districts, N is the number of processors.Figure 7 presents the districts algorithm.As discussed in the introductory section, the hypercube interconnection network contains 2d nodes, where d is the number of hypercube dimension.we can find the number of dimensions of hypercube from the number of nodes using equation 8, where N is the number of nodes.
To distribute districts over hypercube, label all nodes in the hypercube interconnection network, where the number of bits is required to label all nodes equal to the dimension value.For example, if the dimension is equal to 3, label all the nodes in three bits (000, 001, 010, ..., 111), which provides eight numbers of nodes.To distribute districts through the hypercube network, find d using equation 8, then check all the nodes.If d = 3, the loop will be executed three times, each time the districts are divided in half and send half to the next node along the dimension (d -1).Each node, the same operation is performed until it reaches the dimension of d = 0 as an indicator to be stopped (see Figures 9). Figure 9 shows the communication mechanism for d= 2. where a is a factor between [0-1], districtSize equals the number of cities in district and the population size is the maximu m number of candidate solutions.
The data combination is performed by overturning the order of the steps in the distribution phase.After each node completes all the planned iterations, sends the best solution to the node that contains a complete route (shorter path) and links the solution with the solution that it provides, in the end, the master node will contain the final solution (full path).Figures 4 present the pseudocode for the proposed parallel algorithm "GWO_TSP".
Figure 10.PGWO-TSP algorithm on the hypercube interconnection network

Analytical Evaluation
This section provides the analytical evaluation of sequential GWO-TSP algorithm in term of time complexit y and the parallel version on Hypercube interconnection network in terms of parallel time complexity, speedup, efficiency, and cost.

Analytical Evaluation of Sequential GWO-TSP Algorithm
As it is described in before, GWO-TSP consists of multiple steps, where initially create initial population then create new generation by Calculating the destination between cities.
All the terms that precede (see line 6) are constants.As shown in Figure 4 (lines 1-5), the outer while loop is expected to run until reach the population size where each population must contain a Full solution, as shown in Figure 4 (lines 2-8).In the worst case, the number of population is equal to the number of cities which means O (n).Inside the main loop, another loop runs equal to population size as shown in Figure 4 (lines 8-18), where in each iteration, three cities are picked and updated the population O(n).The function in line 9 which used to Calculate the destination of all wolfs is require O(n) while line 10 to 16 are constants.In line 17, the time complexity for the function of Calculate the fitness value for each Population is O(n).Variables in lines 17 to 19 are constants.
The total time complexity of sequential GWOTSP is shown in Equation 10where T is the time complexity, N is the number of population and C is constants: Equation 10 can be reduced to Equation 11T The largest term of equation 3 is n 2 , Thus, the final time complexity will be O (n 2 ).
This section provides the analytical evaluation of GWO-TSP algorithm on Hypercube interconnection network in terms of parallel time complexity, speedup, and efficiency.

Parallel Time Complexity
The parallel execution time is equal to the total of computation time plus the total of communication time.The time required to apply the sequential GWO-TSP on a set of cities represents the computation time and the communication time is equal to the number of communication steps required in both phases, distribution and combination.
The analytical evaluation of the of the parallel execution time for all phases of the GWO-TSP algorith m over hypercube interconnection network is demonstrated by tracing the algorithm in Fig. 10, as shown in Table 2.
The overall complexity of the parallel execution time of phases 1-4 is shown in equation ( 12) where T is the complexity of time, N is the number of cities, P is the number of processors and d is the size of the hypercube.
Table 2.All phases of GWO-TSP algorithm on Hypercube interconnection network.
Phase 1 (Load balancing phase) Root processor executes the Create districts algorithm in fig. 7. the execution will split the map to a number of districts, from line 1-3 the time complexity equal to O(5C+1), fro m line 4-10 the time complexity equal to O(n), finally, the time complexity for grouping cities in districts takes O(C×N 2 ), where C is the number of cities in input data and N is the array of districts.The total time complexity is O(C+n +C× n 2 ) ≈ O(n 2 ) Phase 2 (Data distribution phase) In the hypercube interconnection network, the number of steps necessary to distribute the data through all hypercube is required d steps, where d is the size of the hypercube, which is log P, the general execution time is O (d) Phase 3: Local Repetitive.
All processors run the sequential GWO-TSP on each district.This will require N /P ×N 2 time complexity, where N is the number of cities, P is the number of processors and N 2 is the run time complexity of the sequential GWO-TSP.Phase 4: Data Combining Phase All processors will send the solution to the root node, this will be performed in log P steps which equals d and root processor required O(n) as time complexity to combining all solutions.The total time complexity is O(d + n)

Speedup
Speedup is an important measure for a parallel algorithm, used to calculate the relation of the sequential computation time and the parallel time as equation 14: where TS is the time required by the sequential algorithm and TP is the time required by the parallel algorithm.
The sequential time complexity for GWO-TSP is O(n 2 ) and the parallel version is required which is illustrated in Eq. ( 3), the speedup of GWO-TSP over hypercube is shown in equation 15: S = n 2 * p / n 2 + d + n 3 /p (15)

Efficiency
One of the important factors to measure parallel performance is parallel efficiency which measures how much the processors being utilized in the interconnection networks.It is equal the ratio between speedup and the number of processors as equation 16: Where E is the Efficiency, S is Speedup as equation 6 and p is the number of processors.

Simulation Results
For our experiments, we used a computer with Intel Core i5-3317U CPU 1.70GHz with 8 GB of RAM.The simulation for GWO, CRO, and GA has implemented in Java JDK 8 programming language.The algorithms were tested by 6 different size TSP problems taken from the World TSP (TSP website, 2009); XQF131, XQG237, PMA343, PKA379, PBL395, and PBN423.The parameters are fixed on follows: number of wolves equals the number of cities in each TSP instance and the maximu m number of solutions equals 70% from the number of cities in the dataset, this value is selected to make the algorithm more scalable and to reduc e both of computation time and the required space.For fairness, the same specifications and same stopping criteria are used in our simulations for all algorithms.

Sequential Results
Since GWO, CRO, and GA are meta-heuristic mechanisms, the results obtained in different executions could be different.Because that we repeat the simulation 25 times and record the results as shown in Table 3.In Table 3, the first column shows the name of the instance (the numbers in the names indicate the nodes of each instance).The second column shows the best-known solution for each instance taken from the World TSP [42].
For each algorithm there are four columns, the best column shows the best fitness value of the best exe cution.The mean column shows the average quality of 25 executions of the algorithm.The error rate column shows the fitness function (minimum) of the best individual provided algorithm and the optimal TSPLIB.The error is calculated as in equation 18, finally, the time column shows the time needed to execute the entire program in seconds.

𝐸𝑟𝑟𝑜𝑟 = (
Where Error is the relative value of difference from the optimum tour, Best Solution is the tour length obtained by the experiment and Optimal Solution is the tour length of optimum solution.From Figure 11, it is clear that GOW always gives the highest solution quality (minimu m traveling cost) for all TSP instances tested.This is followed by CRO and GA algorithms.However, the quality of solution reduces as the size of instance increase with an increase in execution time for all algorithms.
From Figure 12, we can observe that the runtime for all algorithms is almost the same with a slightly different but the best runtime comes from CRO for some data instance such like PMA343 and PBN423.Also, it is clear that the experimental and theoretical time converge.

Parallel Results
For the Parallel results, we used a big TSP problem (IRW2802) taken from the World TSP, which contains 8423 cities with 5533 lengths as the known optimal solution.
In  Figure 13 shows that speed-up increases in all the algorithms apart from the increase in the number of nodes used until a certain number of nodes begins to decrease.We can see th at the speedup is almost linear for PGWO when it uses 32 to 256, while it is sub-linear when there are 512 processors and then begins to decrease.This is due to the communication overload in the 512 and 1024 processors scenario, which is much more than th at in 256 processors or less.PCRO got better Speedup compared to PCRO and PGA.Comparing the error rate of fitness values from Figure 14, we find that in most cases the quality of the solutions generated by PGWO is better than PCRO and PGA.This is because in GWO, populations (Solutions) are built from scratch, where the CRO and GA populations are created randomly.The results obtained by CRO are better than GA, because there are four types of reactions that improve the solutions more than the GA.Moreover, with the increase in the number of processors, the error rate has increased.This is mainly due to the division data and the number of iterations on the processors.
Figure 15.Relative efficiency for GWO, CRO and GA Figure 15 shows the relative efficiency for PGOW, PCRO, and PGA.As it shows that efficiency decreases in all the algorithms aside with increasing the number of nodes used, since the amount of data shared for each node decreases, so the difference between communication time and computation time is reduced, which affects the speedup.linear with the increase in the number of nodes used, which in turn affects the efficiency, but we can see that the efficiency of GWO is better than PCRO, PGA, where the worst efficiency is obtained from PGA .

Conclusions and Future Work
This study introduces a parallel model of GWO algorithm to solve the TSP problem called "GWO-TSP" in a hypercube interconnection network.The analytical evaluation of the sequential and parallel is presented.GWO is compared first with the sequential GWO and then with PCRO and PGA.The simulations are performed by TSP instances of different sizes.To be honest, the same stopping criteria are used in our simulations for all algorithms.
The results show that GWO for TSP can improve the fitness value and reduce the computation time with a higher speed-up and better parallel efficiency.
For future work, we intend to compare GWO-TSP with other meta-heuristic algorithms, design and test a deferential interconnection network.

Figure 6 .
Figure 6.Splitting the TSP map into multiple districts

Figure 11 .
Figure 11.Quality of solutions for GWO, CRO, and GA

Table 3 .
The experimental results of sequential GWO, CRO, and GA in terms of fitness value, quality of solution and the execution.

Table 4 .
Table2, the first column shows the number of processors, the time column shows the parallel time (best time) it takes to run the entire program in seconds on nodes.The third column shows the Speedup a ratio of the computation time of the sequential time and the parallel time as equation 14.The error rate column shows the error value of the fitness function (minimu m) of the best individual as equation 18. Parallel time, Speedup and Error rate for PGWO, PCRO, and PGA.