New Improved Multi-Objective Gorilla Troops Algorithm for Dependent Tasks Offloading problem in Multi-Access Edge Computing

Computational offloading allows lightweight battery-operated devices such as IoT gadgets and mobile equipment to send computation tasks to nearby edge servers to be completed, which is a challenging problem in the multi-access edge computing (MEC) environment. Numerous conflicting objectives exist in this problem; for example, the execution time, energy consumption, and computation cost should all be optimized simultaneously. Furthermore, offloading an application that consists of dependent tasks is another important issue that cannot be neglected while addressing this problem. Recent methods are single objective, computationally expensive, or ignore task dependency. As a result, we propose an improved Gorilla Troops Algorithm (IGTA) to offload dependent tasks in the MEC environments with three objectives: 1-Minimizing the execution latency of the application, 2-energy consumption of the light devices, 3-the used cost of the MEC resources. Furthermore, it is supposed that each MEC supports many charge levels to provide more flexibility to the system. Additionally, we have extended the operation of the standard Gorilla Troops Algorithm (GTO) by adopting a customized crossover operation to improve its search strategy. A Max-To-Min (MTM) load-balancing strategy was also implemented in IGTA to improve the offloading operation. Relative to GTO, IGTA has reduced latency by 33%, energy consumption by 93%, and cost usage by 34.5%. We compared IGTA with other Optimizers in this problem, and the results showed the superiority of IGTA.


Introduction
Mobile Edge Computing or multi-access Edge computing (MEC) is an evolution of the centralized cloud server that aims at decentralizing the cloud computing services close to end users at the network edge or Radio Access Networks (RAN) of mobile systems [1,2]. The tremendous advances in Information and Communication Technologies (ICT), such as Internet of Things (IoT) technologies and Mobile Devices (MD), have widened the horizons of programmers towards discovering new and innovative applications that can automate and enhance our life. Examples of such applications are virtual and augmented reality, face detection and recognition applications, surveillance systems, smart agriculture applications, smart healthcare applications, etc. [3,4]. These applications call for high processing and storage requirements that cannot be fully provided by IoT and MD [5]. The first solution was to utilize cloud services, which suffered from bandwidth limitations and public network conditions. A more powerful solution was the MEC server due to its proximity to the end devices that get it away from the public network limitations [6,7].
MEC can be used in the client-server computing paradigm, where a client requests a service from a nearby MEC server. This model reduces the burden on the public network by getting cloud resources near the users [8]. MEC also can be used in the three layers computing paradigm to support high computing and storage-intensive applications where the computing power can be divided into three locations, including MD, MEC, and the central cloud [9]. The computation offloading is a big challenge in the two mentioned computing paradigms. Computation offloading is the transmission of whole/some tasks of a target application to a powerful server for processing [10]. The modularity of the fine-grained programming principle facilitates the offloading process [11]. However, deciding which tasks to be offloaded to which server is a critical part of the MEC and cloud paradigm [12,13]. Offloading some parts of an application while executing some parts locally with respecting the dependency relationship among tasks is still an open research point for which researchers try to find more efficient solutions. Since this is an NP-hard problem, many heuristics [14], metaheuristics [15], game-theoretic [16], mathematical, machine learning [17], and other algorithms were proposed to solve this problem. However, these methods are single objective, complex to implement, computationally expensive, or ignore the dependency among tasks.
Metaheuristic algorithms have recently been developed to solve many optimization problems and confirm near-optimal solutions [18,19]. One of the metaheuristics is The Gorilla Troops Optimization algorithm (GTO) [20], inspired by the social intelligence of gorilla troops in the wild. In this paper, we formulate a multi-objective offloading problem of a set of dependent tasks composing an application to multiple nearby MECs. Despite the extensive research on this point, our proposed work is different. We seek to provide a new innovative solution to the dependent task offloading problem in the MEC environment. Our proposed work considers minimizing three main objectives, including energy consumption (E), MEC charge cost (C), and completion time latency (CT). We added the charge level factor to MEC server for providing more flexibility to the model. We depended on an improved version of the GTO algorithm, which is the first time to be used in this problem. Also, we extensively tested our algorithm with generated and standard topologies to ensure its efficiency. The comparison with other algorithms has shown the superiority of our IGTA method. The results showed that Relative to GTO, IGTA has reduced latency by 33%, energy consumption by 93%, and cost usage by 34.5%. The main contributions can be summarized as follows: • We proposed an Improved Gorilla Troops Algorithm (IGTA) for real-time dependent tasks offloading in the MEC environment by optimizing three conflicting objectives simultaneously. In this regard, the Standard GTO algorithm is improved using a crossover operation, and the results have confirmed this improvement. Additionally, Each MEC is supposed to support multiple charge levels to add more flexibility to the system. We also adopted two vector values mapping methods to map the continuous values of the produced vectors into discrete and bounded values. A detailed discussion of the IGTA steps is presented in Section 4. • A Max-To-Min (MTM) load balancing strategy was implemented in IGTA to improve the offloading operation. This important step is introduced in Section 4.5. • Using a set of Standard and derived test cases with various topologies and task data, we have performed simulation experiments to test the performance of IGTA. The results demonstrate the superiority of IGTA, as in Section 6.
The following sections are organized as follows. Section 2 introduces a brief discussion of the related works. In Section 3, the system model and problem formulation are discussed. Section 4 discusses the proposed IGTA algorithm steps in detail. Section 5 provided an illustrative example to demonstrate the IGTA steps clearly. Experiments and results are discussed in Section 6. Finally, we conclude our work in Section 7.

Related work
MEC is the introduction of cloud services at the network edge. The introduced storage, computing, and networking services are used by small capabilities devices like smartphones and IoT devices for executing latencysensitive tasks, computing hungry, and consuming large Page 3 of 24 21 Vol.: (0123456789) energy for execution. Unlike cloud servers, the tasks can be scheduled among multiple nearby MEC servers [21]. Efficient allocation tasks to the available computing resources can reduce task processing time and energy consumption and maintain server load balance [22]. In this regard, effective task offloading utilizes the available computing resources and high bandwidth to improve the quality of service by reducing the system latency and minimizing the energy consumption and charge cost. Therefore, several research attempts have been conducted in this regard.
The work in [23] uses two edge servers alternatively for offloading the Mobile's tasks to minimize both latency and power consumption. Storing a copy of the file after the first time processing is another strategy implemented in this research for better results. Some attempts have been made using game-theoretic techniques in this regard. Authors in [24] formulated a Stackelberg game for multi-user computational offloading problems in the MEC system to take an offloading decision that can minimize execution time and energy consumption goals. Another attempt in this regard was done [25], where the authors formulated a stochastic game for modeling the offloading problem under a dynamic environment. The latency and energy consumption were the two objectives that the authors of this research had considered.
Recently, heuristic and metaheuristic algorithms are gaining a lot of attention in solving optimization problems, so some attempts have been made in this regard. Authors in [1] suggested a heuristic algorithm for obtaining an efficient solution to minimize the application execution cost under a pre-allocated tasks' finish times' constraint. Authors in [12] and [26] depended on the whale optimization algorithm (WOA) to develop a task scheduling method to reduce completion time and energy consumption at the same time. In a homogeneous MEC case, the work of [27] formulated the dependent task offloading problem with pre-specified service caching, then introduced a favorite successor-based heuristic algorithm to reduce application completion time. Liu et al. [28] proposed a one-dimensional search algorithm to reduce task execution delay, considering the application buffer queuing status and the processor state. Authors of [17] proposed a genetic algorithm (GA) based scheme to reduce task offloading time and failure risk. In the work of [29], Security, energy consumption, and application completion time were all factors considered by Huang et al. In their research, a GA was used to reduce the energy consumption of MDs while meeting application deadlines. Authors in [30,31] developed a particle swarm optimization (PSO) algorithm-based method to reduce the makespan and cost of the task scheduling problem. Another work by [32] suggested a load-balancing heuristic method to offload tasks and optimize task execution time.
Some attempts were done using supervised deep learning and Deep Reinforcement (RL) techniques and introduced innovative solutions to task offloading problems. First, the problem of dependent task offloading is also defined in the literature [33], and the goal is to reduce total execution costs while meeting application completion time constraints. Moreover, the Authors in [34][35][36] proposed a single objective RL-based offloading method to reduce the application completion time. The Works in [37][38][39][40] proposed two objective RL-based offloading methods to optimize completion time and energy consumption. Furthermore, the work in [21] proposed a multi-objective RL method to optimize energy consumption, completion time, and cost of MEC charge. Authors in [41] suggested a supervised deep learning approach for the single-user task offloading problem. This research used a mathematical model to generate the proposed model's learning dataset. They tend to provide an energy-efficient solution to the problem. The authors in [42] developed a Markov decision procedure to represent the joint user association and offloading decision of the MEC-based SAT-IoT networks. They suggested using deep RL to reduce energy usage and delay goals.
After reviewing the previous works in this area, we can say that our proposed solution has the flowing advantages over the developed ones: • Optimize three objectives (CT, C, and E) at the same time. • Consider the dependency among tasks. • Use a new algorithm to solve this problem. • Consider more than MEC and more than charge level for cost.

System model and problem formulation
In this section, we provide the system model for the computational offloading problem in the multi-access edge computing environment considering the dependency among tasks. Table 1 provides an overview of the key notations used in this paper.

System Model
The architecture of the MEC system is shown in Fig. 1. The IoT sensors sense the data and transmit it to the point of Collection (PoC) device, which can be a Personnel Digital assistant (PDA) or smartphone. This PoC runs the application that analyzes the sensed data. Such applications are computationally intensive and contain complex tasks that require powerful resources. To meet such resources' requirements, the PoC device can perform partial offloading for some of its tasks to a nearby MEC server installed in the base station (gNB) at the network edge, as in the 5G network architecture [43]. We consider a system that consists of M MEC Nodes and only one PDA/ smartphone that runs an application composing a set of V tasks. We denote the set of dependent tasks composing the application as V = {v1, v2, v3, …, vN}, where N represents the number of tasks in the application. The analysis result is then transferred to the central cloud through the backhaul network of the 5G network core for further analysis and storage purposes.
To clarify the dependency relationship among the tasks, we modeled them as a Directed Acyclic graph (DAG), as shown in Fig. 2. Each vertex in the graph vi represents a task in the model, and i represent the task ID, where each edge E ij represents a dependency relationship between task v i and v j , such that task v j cannot be executed before task v i finishes its execution. We denote the pre_set(v i ) and post-set(v i ), which are the set of predecessor and successor tasks of v i, respectively. Predecessors express the set of tasks that must be executed before v i starts. In contrast, successor means the set of tasks that cannot start its execution before completing the execution of v i . Figure 2 depicts an application composing 11 tasks. Task v 0 is the start task because the number of elements in its pre_set is zero, and task v 10 is the end task as the number of elements in its post_set is zero.
We maintain three parameters for each task in the system. The number of CPU clocks needed to process the task CC i in a million instructions per second (MIPS), the input size Q in in megabytes, and the output size Q out in megabytes. Each task can be executed locally with the local device's full processing capacity or offloaded to one of the neighboring MECs at a specific charge level. Each MEC device support set of charge level with different processing capabilities and usage cost. Each MEC server can easily support this strategy by allocating its tasks to its cores under different Dynamic Voltage and Frequency Scaling (DVFS) levels [44]. We denote the set of processing locations is P = {p 0 , p 1 , p 2... p M }, such that 0 ≤ p k ≤ M, where M is the number of MEC servers in the system and P 0 is the PoC. The set of charge levels is denoted as L = {L 1 , L 2 ... L R }, such that 0 ≤ L r ≤ R, where R is the number of supported charge levels.

Problem Formulation
As mentioned earlier, MEC offers Cloud services at the network edge, a big technology revolution for the IoT and mobile applications. For this reason, we try to help maximize the benefit of this new technology paradigm. As a result, we seek in this research to build an optimization framework that can be used by mobile and IoT application developers to develop better MEC-based applications in terms of execution time, energy consumption, and usage cost.
This subsection will formulate the task offloading optimization problem considering M MECs and a PoC device. We seek to develop a framework that IoT and Mobile application developers can use in designing their applications and programs. As mentioned in the previous sections, there exist two offloading decisions in this problem: • Executes the task locally using its resources. • Offloads the task to one of the nearby MEC servers.
The extra intensive-computing tasks can be offloaded to cloud computing, but this is not included in our model, as it is a special case.

Task Local Processing
In the case of local processing, task v i is not transmitted to any MEC server, so the task completion time can be defined as follows: FT (P 0 ) is the finishing time of the P 0 queue before the addition of v i . It is also the start time of v i . ET i local is the task execution time on the local processor. It is calculated as CC i /F local . The CC i is the required CPU Clock cycle for executing task v i , and F local is the operating frequency of the PoC device. The WT i is the waiting time for task v i to be executed. WT i local is defined as follows: MaxPred(v i ) is the max predecessor completion time of task v i . it can be defined as: Where CT j MEC is the completion time of executing task v j on one of the MEC servers. Each task is executed in one location. If the task is executed locally, then CT j MEC = 0. Conversely, if the task is offloaded to one of the MEC servers, then CT j local = 0. The value of WT i local is neglected if it is a negative value or zero. According to [18], energy consumption is defined as follows: Where µ is a coefficient expressing the operating chip's capacitance, the cost of processing task v i on the local processor naturally equals zero.

Task offloading to Nearby MEC
In case of offloading task v i to a MEC server p k , where 1 < k ≤ M, the PoC will transmit the input Q in including program code, to the MEC server, then receive the output Q out from the server using the uplink and downlink wireless channels, respectively. We denote CT i k,r as the completion time for processing task v i remotely on MEC server P k under charge level L r , where 1 < r ≤ R. it can be calculated as: Where ET i k,l is calculated as: Where F k l WTik is waiting for task vi to be executed on PK; it can be calculated in Eqs. (2) and (3), but for the Pk. Is the operating frequency of MEC server pk under the charge level Lr. TT i k and RT i k express the transmission time for the input data of task v i to MEC p k and the receiving time for the output data of task v i from MEC p k , respectively. They can be defined as follow: Where H K is the achievable uplink and downlink transmission rate between the PoC and the MEC server p k , we assumed the symmetry property for the two wireless channels. According to Shannon-Hartley theory [45], the H K is defined as: Where B is the channel bandwidth, WP is the wireless transmission and receiving the power of the PoC, A k is the channel's gain, and σ 2 is the channel noise. The propagation delay can be discarded as the distance is very small relative to the light speed, which generates a tiny number [21].
The energy consumption for offloading task v i to MEC server p k can be calculated as follows: E_ik trans and E_ik rec express the energy consumed for transmitting input data and receiving the output data of task v i to/from the MEC p k, respectively, and can be defined as following [46]: The WTP is the wireless transmission power, and WRP is the wireless receiving power. Offloading task v i to a MEC server P k at charge level L r imposes a cost C i r on the PoC for using the MEC computing resources for some time [47]. This usage cost can be obtained by: The symbol ▽ refers to a coefficient expressing the cost per unit of time.

Objective Function
Task offloading problem in the MEC environment is a multi-objective problem that minimizes the completion time or makespan, energy consumption, and cost usage of remote MEC servers.
The total completion time of task v i CT (v i ), the energy consumption E (v i ), and the total used cost C E_ik trans = WTP * TT k i , E_ik rec = WRP * RT k i .
(v i ) for completing this task can be obtained using the following equations: The total completion time CT, energy consumption E, and cost usage C for all tasks, including in the DAG of tasks, can be defined as follow: The objective function is defined as follows: Where a 1 , a 2 , and a 3 are weighting parameters in the mathematical period [0, 1], they must sum to 1. They are used to identify the relative importance of each objective in the problem.

IGTA Algorithm for Solving the Proposed Model
The proposed algorithm IGTA deal with optimizing the problem of offloading a single application composed of multiple dependent tasks using multiple neighboring MEC servers under different charge levels. The IGTA algorithm's overall flow is depicted in Fig. 3. For simplicity, we called the operations the vector values mapping, evaluated the fitness function, updated the current solution, updated the silverback position (Xsb) with the name, and updated the IGTA parameters. In this section, IGTA will be described in detail using several subsections. Firstly, the Gorilla vector initialization process is introduced. Then, the modeling of GTO Operations is discussed. After that, we introduce the mapping operation of the resultant continuous vector to a discrete one. Finally, we end our discussion with two subsections introducing the two improvement operations added to the standard GTO steps. These two enhancement operations are the crossover operation and the Maximum-to-minimum (MTM) load balancing method.

Gorilla Vector Initialization
As we explained in the system model, each task can be executed locally with the full processing capacity of the local device or can be offloaded to one of the neighboring MECs at a specific charge level. We Vol.: (0123456789) maintain a single vector to represent the offloading of tasks to different processing locations under different charge levels that will be optimized using our algorithm. The vector is divided into three sets as follows: • The first V items of the vector represent the allocated tasks. • The next V items represent the processing location of the tasks, respectively. • The last V items represent the charge level used in processing the task on a MEC server. The charge level is the node processing cost level for task processing.
We use algorithm 1 to generate a randomized task list vector. In the proposed algorithm, this vector is represented by the gorilla that needs to be optimized, where each gorilla vector represents a possible solution to the problem. So In this vector, the task at index i will be executed at the processing location at index V + i under a charge level at index V + 2i. Algorithm 1 is a recursive function that starts with the start task; the task with no predecessors then gets its post_set elements and shuffles them. The algorithm recursively does this operation for each task. This algorithm guarantees the random generation of task lists considering task interdependency relationships. We used Algorithm 2 to initialize the three parts of the gorilla. It initializes the task list by calling algorithm 1. The other two parts, the MEC list and the charge levels list, are initialized randomly. Figure 4 depicts an example of a gorilla vector (X) consisting of 11 tasks, 4 processing locations, including the PoC, and 7 charge levels. In the figure, task 0 will be offloaded to MEC 1 under charge level 1. This example is provided for a better understanding of the structure of each gorilla vector. X = (0, 1, 3, 2, 4, 5, 6, 7, 8, 9, 10, 0, 0, 1, 2, 3, 1, 3, 3, 1, 2, 2, 0, 0, 3, 4, 5, 5, 4, 2, 3, 1, 4).

Modeling the GTO Operations
After initializing the population of the gorilla positions, the IGTA algorithm will start its operations with the GTO algorithm. The GTO algorithm simulated the Gorillas' troops' behaviors [20]. The Gorillas' group behavior was mathematically modeled using five different operations. Three operations included in the exploration phase are migration to unknown places, to known places, and other gorillas. Furthermore, the two other operations are included Algorithm 1. Task list generation algorithm in the exploitation phase. These two operations are to obey the silverback and compete with adult males. The silverback is the leader of the gorilla group. The GTO algorithm supposes that the best solution is the silverback position. The mathematical formulation of the three operators included in the exploration phase depends on a seed variable S and a randomly generated value P. thus, when P < S, the migration to an unknown place is used, and the candidate solution GX in the next i iteration can be calculated as follow: Where L and U are the lower and upper bounds for the variables, respectively, r 1 is a random variable in the range [0: 1]. r 1 is continuously updated in each iteration. The movement to other gorillas' operator is Vol.: (0123456789) selected when P ≥ 0.5, and the next candidate solution is obtained by: X r is a randomly obtained position vector for an individual from the gorillas' population. y, a, and h are variables that can be defined according to the following equations: X(i) is the current position vector. In the last case, if P < 0.5, the migration to known locations operator is selected, which is formulated as follows: The selection from the two operations of the exploitation phase is based on the value of the y variable obtained using Eq. (21). When y is greater than or equal to a pre-settled variable w, obeying the silverback is mathematically selected and modeled. X sb is the silverback or best solution position vector, and b is calculated using the following equation.
GX t (i) is a candidate position vector in iteration i for each gorilla member t. N represents the total number of gorillas. On the other side, when y is less than W, the competition for adults' behavior is selected by the GTO algorithm. This operator is modeled as follows: (20) GX(i + 1) = (r 2 − y) + X r (i) + a * h Where f is the impact force, β is a variable that should be given a value before starting the optimization operation. £ is used to determine the violent effect. £ value is determined based on a random number r 0 with two expected values in the normal distribution and the dimensions of the problem ifr 0 ≥ 0.5 . We have added two operations to extend the functionality of the standard GTO algorithm. The customized crossover operation and MTM load balancing operation are the two added operations. The results showed that our modification had improved the quality of the GTO algorithm to provide better results.

Vector Mapping Operation
The generated Gorilla vector (after performing the mathematical formulas of each operation of IGTA) produces a vector of continuous values that need to be mapped to discrete bounded ones according to the value position in the gorilla vector. In this regard, we depended on two mapping methods to discretize the values of the produced gorilla position vector.
The first mapping method is used to map the values of the task list part. To respect the dependency constraint among tasks, firstly, we start with the first task from the task list and get its successors. For example, we take task v 0 and get its successors v 1 , v 2 , and v 3 .
Suppose that the values of generated task list of GX i are as in Table 2. We then put the start task v 0 in index 0 of the gorilla vector GX i . We then get the values of the task successors from GX i . The successors of task 0 should be in indices 1, 2, and 3 with values 0.94, 3.1, and 2.12. We sort these values as in Table 3.
Then we replace each vector value in the GX i vector with its corresponding successor's list value. So the vector will be as in Table 4 after this step.
If two or more tasks have the same successor task, this successor task will be added only once to satisfy the uniqueness constraint for executing each task only once. This operation will be repeated for each task in the task list.
The second mapping method is used to map the values of the MEC list and the charge level list. This method is simply a direct normalization of the vector values according to the following equation: Where maxval and minval are the maximum and minimum values of the vector part (MEC list or level list) to be mapped, respectively, this equation will be multiplied by the number of MEC set in case of MEC vector value mapping and by the number of charge level in case of the level vector value mapping.

Crossover Improvement Operation
We suggested a special crossover operation to enhance the generated solution's quality and improve the performance of the GTO algorithm.
We perform the crossover operation on each generated position X i t and the silverback position X sb . For the task list part, we then choose a random number from the task list and swap its successors between the two input vectors. Assume the chosen random index is 0 with task number 0. We then find its successors in the two Children and swap them. To swap them, we get the position of the successor list in each child. After that, we swap the positions of tasks between the two Children, as shown in Fig. 5. The Crossover operation algorithm for the task list is provided in algorithm 3.
Furthermore, for the other two parts of the gorilla vector, we choose a random index for the second and third parts and swap its value between the two Children.

MTM Load Balancing Operation
We proposed the MTM method to redistribute the load of the task among the processing locations. The MTM load balancing operation continuously updates tasks' processing locations from maximum completion time to minimum one until the completion time of the minimum location reaches or exceeds the best-obtained completion time or the maximum completion time. In the MTM load balancing method, we search for the two processing locations with maximum and minimum completion times. The pseudo-code for the MTM load balancing operation is provided in algorithm 4. The pseudo-code of the IGTA algorithm is shown in algorithm 5.

Illustrative Example
In this section, we provide a motivating example to clarify the offloading strategy of this research. Depending on the DAG of Fig. 2, that shows an application consisting of eleven dependent tasks V = {v 0 , v 1 … v 10 }. We randomly generated the values of the three parameters maintained for each task. Table 5 shows these generated values. We suppose there are three MEC servers and a PoC in the system p = {P 0 , P 1 , P 2 , P 3 }, P 0 expresses the PoC processor. By assuming the symmetry property for the two wireless channels, the achievable uplink and downlink rates are provided in Table 6. We suppose that the transmission and receiving powers of the PoC equal 0.1 Watts. Each MEC device supports a set of charge levels with different processing capabilities. Each MEC server can support up to six charge levels L = {L 1 , L 2 … L 6 } in addition to L 0, which expresses the task's local processing. Each charge level has a different operating frequency and unit price, as shown in Table 7. The dependency among tasks is provided in Table 8. Assuming that the mobile dynamic energy is 0.125. For simplicity, we suppose sequential execution of tasks from each mobile device on MEC. As in the case of parallel execution, it is a confusing issue to distribute the operating frequency among tasks. This distribution will directly impact the task completion time, so we suppose sequential execution to avoid this. Assume we have a candidate solution: Where X i (i = 0... 10) is the task id, X i (i = 11... 21) is the execution location of V i , and X i (i = 22... 32) is the charge level.
Firstly, we calculate the execution time matrix for executing each task under each charge level, equal to the CC i /F op , where F op is the operating frequency. The time execution matrix for this example is shown in Table 9.
For simplicity, we will use the equations presented in the problem formulation section to calculate the completion time of this example task. Since v 0 and v 1 are executed locally, their completion time can be obtained as follow.
WT 0 local = 0. Since it is the start task.
We need to compute each task's waiting time, transmission time, and receiving time for remote-processing tasks. We set the H value by 1 GBps for all channels to  The completion times for the other tasks were computed similarly and provided in Table 10. Figure 6 shows the complete task offloading chart for this example. The completion time of the application is   Algorithm 5 shows the pseudo-code for the proposed IGTA algorithm. We first initialize a gorilla vector. After that, the initialized vector is passed as input to the GTO algorithm, producing a vector of continuous values. We then discretize this vector's continuous values and improve this vector using the crossover and MTM load balancing operations.

Experiments and Results
Several experiments and empirical tests are performed in this section to evaluate the effectiveness of the IGTA algorithm. All tests are conducted on a laptop with the following specifications. The processor specification is Intel (R) Core (TM) i7-3540 M @ 3.00 GHz, and the RAM size was 8 GB. Windows 10 Professional 64-bit was the installed operating system. All the simulated experiments were done using the java programming language.

Data Description
For the experiment, we will suppose that M = 3 MEC servers will be available for the PoC. We suppose that the transmission and receiving powers are 0.1 watts and the mobile dynamic energy is 0.125 [21,25,48]. By assuming the symmetry property for the two wireless channels, the achievable uplink and downlink rates are previously shown in Table 6. Additionally, we use six distinct charge levels previously noted in Table 7. The operating frequency and unit price values rise from the first level to level six.  We adopt level zero to denote the full capacity of the PoC device.
The datasets used in our experiments will be described here. The used datasets are open and accessible at [49]. The task graphs in the datasets are divided into three sets, each with 100 graphs. The first set of graphs all has the same topology, N = 9 tasks. Three must be executed locally, and the other six can be offloaded. The second set of graphs has the same topology, N = 29 tasks, and 20 off-loadable tasks. The third set of graphs all shares the same topology, N = 23 tasks, and 19 off-loadable tasks. The number of offloadable components per task graph is also adjustable by users. In this experiment, we assume that all tasks in each graph can be offloaded.
We selected three task graphs from each graph set from the dataset mentioned above for our experiment. Moreover, for testing purposes, we randomly generated the input data Qin in the range [5,50] megabytes and the output data Qout in the range [0.5, 5] megabytes. Table 11 contains the full description of the experiment's task graphs (TG).
Since the number of tasks in the described datasets is relatively small, we set the number of iterations to 200 to allow for a fair assessment of the algorithms. Each algorithm's population size is set to 10. Each algorithm is evaluated by the results of executing it 20 times. We set the parameters of the GTO as follows: • P parameter to control the selection of the exploration operations = 0.03; • W parameter to control the selection of the exploitation operations = 0.8; • The beta that is used in calculating the coefficient vector to determine the degree of violence in conflicts = 3; The crossover probability parameter P for IGTA is set to 0.7. However, the results of some experiments on a few random datasets show that 0.7 is the most suitable probability. This procedure maintains population diversity while improving the quality of the new solutions produced by IGTA.
The parameters of the comparison algorithms are set as the authors recommend. For GA, we have set the mutation rate to 0.001. Beginning from the start task, we have implemented a crossover operation between the successors of each task in the DAG. We select the random number in the task list, mutate its    processing location charge level, and shuffle its successor list. The PSO's basic parameters are set as follows as recommended in [56,57]: • The social coefficient is 1.57. • The cognitive coefficient is 1.42.
The other algorithms' parameters as set following recommendations made by their authors.

Comparison between GTO and IGTA
In this case, we focus on analyzing how the proposed algorithm was affected by the crossover and MTM improvement operations. Therefore, using six DVFS levels and three MECs, we will experimentally determine how different task sizes and parameters defined in Table 11 affect the performance of GTO and IGTA. In this experiment, we employ four distinct measures, including average values for completion time, energy, cost, and fitness. Algorithm 5. The IGTA algorithm Table 12 displays the outcomes of the two algorithms (GTO and IGTA) classified based on the abovementioned measures. We can see from the outcomes that IGTA performs better than GTO across all datasets. It scored better values on all the performance measures. The results have clarified the role of the added improvement operations in enhancing the behavior of the standard GTO algorithm.
The total values of the findings from Table 12 for each of the ten datasets are shown in Fig. 7 for the GTO and IGTA algorithms. IGTA receives the minimum completion time with a value of 93.5, while GTO receives 139.5. Additionally, IGTA achieves improved energy consumption and cost savings with 71.5 and 55.46, respectively. It also scored the minimum fitness of 55.46 points, a good performance metric for distributing task loads across mobile edge computing servers at various charge levels.
In the second experiment, we used the dataset TG2-100 to examine how the performance of GTO and IGTA will change when five different numbers of MEC servers (2, 3, 5, 7, and 9) are used. The local processor is also added in each experiment. First, we determine the completion time values for executing the dataset TG2-100 twenty times using each MEC number. The average of the completion time values is then calculated. The average completion time for each MEC number is then added up. This procedure is repeated for the other three performance metrics (energy consumption, used cost, and fitness function). As seen in Fig. 8, the improvements proposed on the GTO algorithm resulted in better results across all performance metrics.
We can see in Fig. 8 that IGTA obtained better results for all performance metrics. It scored the minimum completion time with a value of 121.5 s, the minimum total Energy consumption with 0.56 J, the minimum total cost usage with 77.47$, and the minimum fitness function with a value of 66.97.

Comparison with Other Algorithms
This subsection compares the performance of the proposed algorithm with HHO, WOA, PSO, BAT, GWO, and GA using the datasets defined in Table 11. Four performance metrics are used (completion time, energy consumption, cost usage, and fitness function) to evaluate the effectiveness of the algorithms. We run each algorithm on each dataset twenty times using six charge levels. As a result, we calculated the average for each used performance measure (PerM) using the following equation: where PerM j is the performance measure value obtained from running an algorithm on a dataset. Figure 9 shows the average completion times of each algorithm on the adopted datasets. The figure shows that the proposed algorithm outperforms the other algorithms on all used datasets. It is also obvious that the ranking of other comparison algorithm change on each dataset. This observation ensures that our datasets validated the comparison approaches' performance metrics. Furthermore, Fig. 10 presents the total average completion times for the used data sets obtained by summing the average completion times produced from running each algorithm on all adopted datasets. The results showed that our algorithm provides the minimum completion time value of 93.45 s. HHO algorithm scored a completion time value of 140.31 s as the second minimum completion time value. On the other side, the maximum completion time value of 300.58 s is scored by the GA algorithm.
The second performance metric used in the comparison is the energy consumption measure. This metric is significant since batteries are the primary power source for mobile and IoT devices. Using the adopted test cases,    The third performance measure is the cost used to execute the application tasks, which is important for designing an economic plan. As a result of running each algorithm on the test datasets of Table 11 using the seven charge levels prices provided in Table 7, Fig. 13 shows the total average cost usage results. It is clear from the results that our algorithm introduces the minimum cost levels for all test sets. Figure 14 also did its role in providing an obvious viewpoint in quantifying the cost usage results scored by the comparison algorithms. The figure shows that the proposed algorithm hit the most optimized cost by 71.21$.WOA hit the second optimum value of 82.18$. The maximum cost usage value of 176.35 is obtained from the GA algorithm.
The fitness values are an absolutely important factor in measuring the performance of the algorithms since they present a general viewpoint that combines all of the previously mentioned metrics. Figure 15 depicts the average fitness for each algorithm on the test sets. This figure confirmed the other metrics' results that witnessed the proposed algorithm outperforming the other approaches. Figure 16     The average CPU time for each algorithm on the TG2-100 dataset is presented in Fig. 17. It is obvious in the figure that our algorithm hit the maximum CPU time with a value of 0.08 s, and GA hit the minimum value of 0.022 s. The other algorithms' CPU times are as follows: PSO with a value of 0.026 s, BAT with a value of 0.029 s, WOA with a value of 0.029 s, GWO with a value of 0.03 s, HHO with a value of 0.03 s, and standard GTO with value 0.05. But the CPU times have no impact on the performance measure of our proposed approach if this IGTA is used in the design phase of the IoT and mobile applications. As we previously mentioned in subsection 3.2, this framework aims to enable IoT and mobile application developers to build efficient applications that can benefit the MEC servers the most. Moreover, we suggest the installation of IGTA on the MEC server in the MEC environments that dynamically change the importance of the objective over time, which can reduce the impact of the relatively long CPU time of IGTA on the performance measures, especially for computationally extensive applications. Figure 18 shows the total average performance measures' values of the algorithms using different MEC servers (2, 3, 5, 7, and 9) on the TG2-100 dataset. It can be seen from the figure that IGTA scored the minimum completion time value of 121.5 s, and the HHO algorithm scored the second minimum value of 146.2. Conversely, the BAT algorithm scored the maximum value of 349.11 s. But regarding the energy consumption measure, our algorithm also accomplished the most optimized value of 0.56 J, and the WOA scored the second optimum value of 20.96. While the maximum value of 174.02 was produced from the BAT algorithm.
Regarding used cost, IGTA also reached the minimum value of 77.47$. The second minimum value of 80.06$ was obtained by the WOA, while the BAT Fig. 15 Fitness function results using adopted datasets and three MEC servers  The results also showed that IGTA outperforms all the algorithms included in the comparison. These results confirm the stability of the IGTA performance on the change in the number of installed MEC servers in the environment.
We can infer from the extensive experiments that the proposed algorithm has performed significantly better than other meta-heuristic algorithms at saving energy, minimizing the cost, and shortening computation time.

Conclusion
This study examines a multi-server mobile edge computing system with multi-task dependence in which three goals were optimized simultaneously: the application completion time, MD energy consumption, and MEC server usage fee. Moreover, IGTA can be used in MEC environments that dynamically change the relative importance of objectives over time. To overcome these issues, we offered an improved multi-objective gorilla troops algorithm for solving the dependent task offloading problem in the MEC environment with three objectives. In the proposed method, each gorilla vector was broken down into three parts: a task list part, a MECs list part, and a charge levels list part. A particular initialization method was also used to create workable gorilla vectors. Since the gorilla vectors that are produced by the GTO algorithm are continuous values, two mapping techniques were used to convert such vector values into discrete and bounded ones. Additionally, we have extended the operation of the standard Gorilla Troops Algorithm (GTO) by adopting a customized crossover operation to improve its search strategy. A Max-To-Min (MTM) load-balancing strategy was also implemented in IGTA to improve the offloading operation. To validate IGTA performance, we have run extensive simulation experiments on ten test instances with various task topologies and profiles. These experiments compared IGTA with GTO, HHO, WOA, GWO, BAT, PSO, and the GA algorithm. Finally, the simulation results confirmed the superiority of IGTA's overall performance metrics. For instance, Relative to GTO, IGTA has reduced latency by 33%, energy consumption by 93%, and cost usage by 34.5%.