1. Introduction
In complex dynamic scenarios such as forest fire monitoring, traditional fixed monitoring systems have several notable drawbacks. These systems rely on stationary ground sensors and pre-deployed communication infrastructure, which limits their coverage, makes them vulnerable to terrain interference, and creates rigid resource scheduling. As forest fires become increasingly frequent and destructive around the world, the demand for real-time, reliable, and adaptive monitoring continues to grow. Conventional cloud-based processing, although widely used, suffers from long transmission delays and bandwidth bottlenecks, making it difficult to meet the stringent latency and reliability requirements of emergency fire response.
Mobile edge computing (MEC) has emerged as a promising paradigm that brings computation and storage resources closer to the network edge. By enabling task offloading from resource-constrained terminals to nearby edge servers, MEC significantly reduces transmission latency and improves energy efficiency. However, the limited resources of edge nodes make efficient resource management a critical issue. The joint optimization of task scheduling, communication, and computational resource allocation remains a central challenge in MEC research.
The unmanned aerial vehicle (UAV), with its high mobility, flexible deployment, and programmable flight control, has become an important carrier for disaster monitoring and emergency communication. A UAV can act as an aerial base station, a wireless relay, or a flying edge server. Its high altitude enables line-of-sight communication links with ground devices, thereby mitigating signal blockage and shadowing in complex environments. When a UAV is integrated into a MEC system, the resulting UAV-assisted MEC framework can greatly improve the coverage and responsiveness of monitoring networks.
Despite these advantages, most existing studies on UAV-assisted MEC assume that either the edge devices or the terminal devices are static, or only one type of device is mobile. Such assumptions fail to capture the complexity of real-world disaster environments, where both terminal nodes and edge nodes move continuously. In a forest fire monitoring scenario, ground sensors may be carried by mobile platforms or move along predetermined paths, while UAVs must fly along trajectories that are dynamically adjusted to maintain communication links and balance computation loads. The collaborative mobility of both terminals and edges, along with the dynamic allocation of communication and computational resources, has not been fully investigated.
To address these challenges, this paper studies UAV-assisted edge computing based on movable terminals and movable edges. I first establish a cooperative optimization model in which mobile terminals move in circular patterns while UAVs move in parallel translation patterns. In this model, I jointly consider the UAV flight trajectory, the terminal movement path, the allocation of computational resources, and the task offloading decisions. The objective is to minimize a weighted system cost that combines the task completion time and the total system energy consumption. I then extend the model to multiple movement modes for both UAVs and mobile terminals. The UAV motion modes include circular flight, zigzag flight, and linear translation, while the mobile terminal modes include circular motion and linear motion. For both scenarios, I design a genetic algorithm (GA) to search for the optimal task offloading strategy.
The remainder of this paper is organized as follows. Section 2 reviews related research. Section 3 presents the system model and problem formulation. Section 4 introduces the genetic algorithm design. Section 5 reports the simulation results and performance analysis. Finally, Section 6 concludes the paper and discusses future directions.
2. Related Work
Existing research on MEC systems can be categorized into three classes according to the mobility of the devices involved: static edges and static terminals, mobile terminals with static edges, and mobile edges with static terminals. Each category has its own focus, advantages, and limitations.
2.1 Static edges and static terminals
Many early studies in MEC assumed that both edge nodes and terminal nodes are fixed in location. These works mainly focused on task scheduling and resource allocation in stable network topologies. For example, researchers have proposed energy-efficient task offloading algorithms using non-orthogonal multiple access, deep Q-learning, or sub-gradient methods. These methods are effective when the network infrastructure is well-deployed and the devices do not move. However, in practical disaster scenarios, the assumption of static devices is often unrealistic. Fixed edge servers cannot easily adapt to the spatial distribution of mobile users, and the network topology changes over time. Thus, the applicability of these approaches is limited in dynamic environments.
2.2 Mobile terminals with static edges
A second category of studies considers mobile terminal devices, such as vehicles or handheld devices, while the edge servers remain static. These works have made significant progress in addressing user mobility, dynamic task arrivals, and heterogeneous IoT services. Lyapunov optimization, deep reinforcement learning, and convex decomposition have been used to optimize offloading decisions and resource allocation. However, in large-scale disaster areas, static edge servers may not provide sufficient coverage. The movement of terminal devices alone is not enough to overcome the limitations of fixed infrastructure, especially when the communication network is partially destroyed.
2.3 Mobile edges with static terminals
In recent years, UAV-assisted MEC has attracted considerable attention. In the third category of studies, the edge devices are mobile because they are carried by UAVs, while the terminal devices are assumed to be static. These works focus on the joint optimization of UAV trajectories, task offloading decisions, and computational resource allocation. Various algorithms have been proposed, including alternating optimization, successive convex approximation, and deep reinforcement learning. While these methods demonstrate that UAV mobility can enhance the performance of MEC systems, they usually ignore the mobility of terminal devices. In complex environments such as forests or mountainous terrains, ground terminals often move continuously. Fixing their positions may lead to suboptimal task offloading strategies.
2.4 Limitations and my approach
From this analysis, I observe that current research mostly assumes static or single-device mobility. It rarely considers the collaborative mobility of both terminal devices and edge devices, nor does it consider the dynamic communication links and real-time resource constraints that arise when both sides move. Furthermore, many existing optimization frameworks focus on a single objective, such as latency or energy consumption. In practical applications, the task completion time, the energy efficiency, and the load balance among edge nodes should be optimized jointly.
To fill this gap, I propose a UAV-assisted edge computing framework based on movable terminals and movable edges. The main contributions of this work are summarized as follows:
- I establish an edge computing model in which UAVs move in parallel translation while mobile terminals move in circular patterns. The system model integrates the UAV flight trajectory, the terminal movement path, the computational resource allocation, and the task offloading decisions. The weighted sum of task completion time and system energy consumption is used as the system cost, and the minimization of this cost is formulated as an optimization problem.
- I further extend the model to multiple motion modes for both UAVs and mobile terminals. The UAV motion modes include circular flight, zigzag flight, and translation, while the terminal motion modes include circular motion and linear motion. I analyze how different motion modes affect task delay, energy consumption, and coverage efficiency in forest fire monitoring scenarios.
- I design a genetic algorithm to solve the optimization problem. The algorithm uses population initialization, fitness evaluation, selection, crossover, and mutation to dynamically allocate computational tasks. It balances computational latency and energy consumption under constraints such as dynamic communication links, safe distances between UAVs, and real-time computational resource limits.
3. System Model and Problem Formulation
This section describes the system architecture and the mathematical models used in this study. The overall system consists of multiple mobile terminals and multiple UAVs. The mobile terminals collect environmental data such as temperature, humidity, and smoke concentration, while the UAVs serve as mobile edge servers. Each time interval is indexed by \(t \in \{1, 2, \ldots, T\}\). Let the set of mobile terminals be \(\mathcal{M} = \{1, 2, \ldots, M\}\) and the set of UAVs be \(\mathcal{U} = \{1, 2, \ldots, U\}\). Table 1 summarizes the key notations used in this paper.
| Symbol | Meaning |
|---|---|
| \(M\) | number of mobile terminals |
| \(U\) | number of UAVs |
| \(T\) | number of time slots |
| \(\theta_{step}\) | angular increment of terminal circular motion |
| \(t_u\) | UAV flight time |
| \(r_u\) | UAV coverage radius |
| \(q_u(t)\) | horizontal coordinate of UAV \(u\) at time \(t\) |
| \(p_u(t)\) | propulsion power of UAV \(u\) |
| \(E_u^{fly}(t)\) | propulsion energy consumption of UAV \(u\) |
| \(L_m(t)\) | amount of task data generated by terminal \(m\) |
| \(C_m\) | required CPU cycles for task \(m\) |
| \(f_{m,u}(t)\) | computational resource allocated by UAV \(u\) to terminal \(m\) |
| \(z_{m,u}(t)\) | binary variable indicating whether terminal \(m\) connects to UAV \(u\) |
| \(d_{m,u}(t)\) | distance between terminal \(m\) and UAV \(u\) |
| \(g_{m,u}(t)\) | wireless channel power gain between terminal \(m\) and UAV \(u\) |
| \(r_{m,u}(t)\) | transmission rate from terminal \(m\) to UAV \(u\) |
3.1 Mobile terminal model
In this study, the mobile terminals are assumed to be ground devices that move within a rectangular monitoring area. The rectangular area is defined by its lower-left corner \((x_{min}, y_{min})\) and its upper-right corner \((x_{max}, y_{max})\). The initial position of terminal \(m\) is randomly generated using a uniform distribution:
$$x_m^{center} = x_{min} + rand() \times (x_{max} – x_{min})$$
$$y_m^{center} = y_{min} + rand() \times (y_{max} – y_{min})$$
For the circular motion model, each terminal moves along a circular path centered at its initial position with radius \(r_m\). The total number of movement steps is \(movesteps\), and each step corresponds to an angular increment:
$$\theta_{step} = \frac{2\pi}{movesteps}$$
At each time slot \(t\), the new position of terminal \(m\) is updated as follows:
$$x_{next} = x_{center} + r_m \cos(\theta_{current})$$
$$y_{next} = y_{center} + r_m \sin(\theta_{current})$$
where \(\theta_{current}\) is updated by \(\theta_{current} = \theta_{current} + \theta_{step}\). The generated path is stored in an array \(path\_m\). By randomly generating the initial position and the radius, the paths of different terminals are diversified and cover different parts of the monitoring area.
For the linear motion model, terminal \(m\) starts from an initial position \((x_0, y_0)\) and moves along a direction with angle \(\theta\) relative to the horizontal axis at speed \(v_m\). The position at time \(t\) is expressed as:
$$x_m(t) = x_0 + v_m t \cos(\theta)$$
$$y_m(t) = y_0 + v_m t \sin(\theta)$$
In both models, the velocity \(v_m\) is assumed to be constant. The movement of terminals plays an important role in the communication quality and task offloading efficiency, as it directly affects the dynamic distance between a terminal and the UAVs.
3.2 UAV movement model
The UAVs fly at an average altitude \(H\). At each time slot, a UAV hovers at its current position to provide services to the mobile terminals. The horizontal coordinate of UAV \(u\) at time \(t\) is denoted by:
$$q_u(t) = (x_u(t), y_u(t))$$
For the translation movement mode, the UAV moves along a straight line with a constant speed \(v_u\). The flight direction angle is \(\alpha_u(t)\). The position update equations are:
$$x_u(t) = x_u(t-1) + v_u t_u \cos(\alpha_u(t))$$
$$y_u(t) = y_u(t-1) + v_u t_u \sin(\alpha_u(t))$$
When the UAV approaches the boundary of the rectangular area, the flight angle is adjusted so that the UAV remains within the area. In the optimized coverage strategy, odd-numbered UAVs fly from left to right, while even-numbered UAVs fly from right to left. This alternating pattern improves the overall coverage of the monitoring region.
For the circular motion mode, the position of the UAV at time \(t\) is given by:
$$x_u(t) = x_u^{center} + R_{uav} \cos(\omega_{uav} t + \varphi_0)$$
$$y_u(t) = y_u^{center} + R_{uav} \sin(\omega_{uav} t + \varphi_0)$$
where \((x_u^{center}, y_u^{center})\) is the center of the circular path, \(R_{uav}\) is the radius, \(\omega_{uav}\) is the angular velocity, and \(\varphi_0\) is the initial phase.
For the zigzag flight mode, the UAV moves in the \(x\)-direction following a sinusoidal function, while moving at a constant speed \(v_y\) in the \(y\)-direction:
$$x_u(t) = x_0 + A \sin\left(\frac{2\pi}{T_{zigzag}} t\right)$$
$$y_u(t) = y_0 + v_y t$$
where \(A\) is the amplitude of the sinusoidal motion. This mode enables the UAV to explore areas with complex terrain or signal interference, because it avoids obstacles and increases coverage opportunities across different regions.
The propulsion energy consumption of UAV \(u\) at time \(t\) is calculated as:
$$E_u^{fly}(t) = p_u(t) t_u$$
where \(p_u(t)\) is the propulsion power. In the zigzag mode, because of frequent turning, the energy consumption is relatively higher. The general expression for the flight energy in a time-varying path is:
$$E_u^{fly}(t) = \int_0^t p_{flight} \sqrt{\left(\frac{dx_u(\tau)}{d\tau}\right)^2 + \left(\frac{dy_u(\tau)}{d\tau}\right)^2} d\tau$$
3.3 Communication model
The distance between terminal \(m\) and UAV \(u\) at time \(t\) is computed as:
$$d_{m,u}(t) = \sqrt{H^2 + \|S_m(t) – q_u(t)\|^2}$$
The wireless channel power gain is modeled as:
$$g_{m,u}(t) = \beta d_{m,u}(t)^{-2}$$
where \(\beta\) is the channel power gain at a reference distance of 1 meter. The transmission rate from terminal \(m\) to UAV \(u\) is given by the Shannon formula:
$$r_{m,u}(t) = \frac{B_M}{M} \log_2\left(1 + \frac{P_M g_{m,u}(t)}{\sigma^2}\right)$$
where \(B_M\) is the total bandwidth available for uplink communication, \(P_M\) is the transmit power of the mobile terminal, and \(\sigma^2\) is the noise power.
The transmission time for offloading the task from terminal \(m\) to UAV \(u\) is:
$$D_{m,u}^{comm}(t) = \frac{z_{m,u}(t) L_m(t)}{r_{m,u}(t)}$$
The corresponding communication energy consumption is:
$$E_{m,u}^{comm}(t) = D_{m,u}^{comm}(t) P_M$$
For the downlink, the UAV transmits the computation result back to the terminal. The downlink transmission rate is:
$$r_{u,m}(t) = \frac{B_U}{M} \log_2\left(1 + \frac{P_U g_{m,u}(t)}{\sigma^2}\right)$$
where \(B_U\) is the total downlink bandwidth and \(P_U\) is the UAV transmit power. The downlink transmission time is:
$$D_{u,m}^{down}(t) = \frac{D_{m,i}^{result}(t)}{r_{u,m}(t)}$$
The downlink energy consumption is:
$$E_{u,m}^{down}(t) = D_{u,m}^{down}(t) P_U$$
In cases where the UAV has moved out of the coverage area of the terminal after completing the computation, the terminal must wait for the UAV to return. The waiting time is approximated by:
$$D_{u,m}^{wait}(t) = \frac{2 d_{toboundary}}{v_u}$$
where \(d_{toboundary}\) is the distance from the current horizontal coordinate of the UAV to the boundary in the UAV flight direction.
3.4 Computation model
When the task is offloaded to UAV \(u\), the UAV allocates a portion of its computational resources to the task. The computation time is expressed as:
$$D_{m,u}^{comp}(t) = \frac{L_m(t) C_m z_{m,u}(t)}{f_{m,u}(t)}$$
In this work, the computational resources are allocated based on the current number of tasks. For example, if the total computational resource of a UAV is \(f\), and it is currently processing 10 tasks, then each task receives a resource share of \(f/10\).
The total completion time of task \(i\) on terminal \(m\) at time \(t\) is the sum of the task generation time, the communication time, the computation time, the downlink transmission time, and the waiting time:
$$D_{m,i}(t) = D_{m,i}^{gene}(t) + D_{m,u}^{comm}(t) + D_{m,u}^{comp}(t) + D_{u,m}^{down}(t) + D_{u,m}^{wait}(t)$$
The completion time of all tasks on terminal \(m\) is the maximum of the completion times of its individual tasks:
$$D_m(t) = \max\{D_{m,1}(t), D_{m,2}(t), \ldots, D_{m,I}(t)\}$$
3.5 Problem formulation
In this paper, the system cost is defined as the weighted sum of the total task completion time and the total system energy consumption:
$$C_{total} = \omega_D D_{total}(t) + \omega_E E_{total}(t)$$
where \(\omega_D\) and \(\omega_E\) are weighting factors. In an emergency scenario, a larger value of \(\omega_D\) places more emphasis on reducing the task completion time, while a larger value of \(\omega_E\) emphasizes energy reduction.
The total task completion time is the maximum completion time among all mobile terminals:
$$D_{total}(t) = \max\{D_1(t), D_2(t), \ldots, D_M(t)\}$$
The total system energy consumption includes the communication energy of the terminals, the propulsion energy of the UAVs, and the downlink energy of the UAVs:
$$E_{total}(t) = \sum_{m=1}^{M} \sum_{u=1}^{U} E_{m,u}^{comm}(t) + \sum_{u=1}^{U} E_u^{fly}(t) + \sum_{u=1}^{U} \sum_{m=1}^{M} E_{u,m}^{down}(t)$$
The optimization problem is formulated as:
$$\min \; C_{total} = \omega_D D_{total}(t) + \omega_E E_{total}(t)$$
subject to the following constraints:
$$0 \leq \alpha_u(t) \leq 2\pi, \quad \forall u \in \mathcal{U}$$
$$z_{m,u}(t) \in \{0,1\}, \; \sum_{u=1}^{U} z_{m,u}(t) \leq 1, \quad \forall m \in \mathcal{M}, \forall t \in \mathcal{T}$$
$$\sum_{m \in \mathcal{M}} f_{m,u}(t) \leq f_u^{max}, \quad f_{m,u}(t) \geq 0$$
$$\|d_u(t) – d_{u’}(t)\| \geq d_{min}, \quad \forall u \neq u’ \in \mathcal{U}$$
The first constraint defines the allowable range of the UAV flight angle. The second constraint ensures that each terminal can connect to at most one UAV at any time. The third constraint limits the total computational resources assigned by a UAV to the tasks of all connected terminals so that it does not exceed its maximum capacity. The fourth constraint enforces a minimum safe distance between any two UAVs to avoid collisions.
4. Genetic Algorithm Design
The optimization problem formulated above is a mixed-integer nonlinear programming problem. Traditional optimization methods struggle with such problems, especially when the number of terminals and UAVs is large. I therefore use a genetic algorithm to search for a near-optimal task scheduling strategy. The GA is particularly suitable because it can handle the discrete binary variables \(z_{m,u}(t)\) and the continuous resource allocation variables simultaneously.
4.1 Encoding and population initialization
In the GA, each individual represents a complete task scheduling scheme over the entire time horizon. The individual is encoded as a three-dimensional binary matrix of dimension \(T \times M \times U\). Each element \(z_{m,u}(t)\) indicates whether terminal \(m\) is connected to UAV \(u\) at time \(t\). The population is initialized randomly. For each time slot and each terminal, the algorithm randomly selects at most one UAV for connection. This ensures that the initial population satisfies the connection constraint.
As an example, consider a setting with \(T=2\), \(M=3\), and \(U=2\). The individual encoding takes the form of a two-dimensional matrix for each time slot, as shown below:
$$individual = \begin{bmatrix} 0 & 1 & 1 & 0 \\ 1 & 0 & 0 & 0 \\ 1 & 0 & 0 & 1 \end{bmatrix}$$
In this representation, each row corresponds to a terminal, and each column corresponds to a UAV in a given time slot.
4.2 Fitness function
The fitness of an individual is evaluated based on the total system cost. The fitness function is defined as:
$$Fitness = \omega_D D_{total}(t) + \omega_E E_{total}(t)$$
For the multi-mode extension, the fitness function also incorporates the load-balancing factor, and is normalized as:
$$Fitness = \alpha \frac{\sum_{i=1}^{m} T_{i}^{completion}}{\max_{i} T_{i}^{completion}} + \beta \frac{\sum_{j=1}^{u} E_{uav,j}}{\max_{j} E_{uav,j}} + \gamma \frac{\sum_{k=1}^{u} |L_{uav,k} – \bar{L}|}{\max_{k} |L_{uav,k} – \bar{L}|}$$
where \(\alpha\), \(\beta\), and \(\gamma\) are weight coefficients that balance the importance of task completion time, energy consumption, and load balance. The load balance term measures the deviation of each UAV’s computational load from the average load. By including this term, the algorithm encourages an even distribution of tasks among UAVs, which helps prevent individual UAVs from becoming overloaded.
4.3 Selection
The selection operation determines which individuals are retained for the next generation. In this study, I use the tournament selection method. The algorithm randomly picks \(s\) individuals from the current population, compares their fitness values, and selects the individual with the smallest fitness value to enter the next generation. This process is repeated until the new population reaches the desired size. Tournament selection avoids the issue of premature convergence that can occur with roulette-wheel selection, because it preserves a degree of diversity even when the fitness values of individuals are close.
4.4 Crossover
For the task assignment matrix, I adopt partial mapped crossover (PMX). Two parents are selected randomly, and two crossover points \(i\) and \(j\) are chosen. The gene segments between the two crossover points are exchanged to produce two offspring. After the exchange, the mapping relationships between the genes are used to adjust other positions in the offspring, so that the resulting task scheduling scheme remains feasible. For the encoding of movement modes, a simpler mode crossover is used, in which the mode values of the two parents are exchanged according to the crossover rate.
4.5 Mutation
The mutation operation randomly changes the connection relationship of a terminal at a given time slot. For example, if terminal \(m\) is originally connected to UAV \(u\), mutation may change the connection to another UAV \(u’\), or disconnect the terminal entirely. In the movement-mode encoding, mutation randomly changes the mode value of a UAV or a terminal. The mutation rate is set to a small value, such as \(0.2\), to ensure that the algorithm explores new regions of the solution space without destroying good solutions too quickly.
4.6 Evolutionary process
The overall genetic algorithm is described in Algorithm 1. The algorithm starts by initializing the population. During each generation, the fitness of every individual is evaluated. Then, tournament selection is performed to choose parents. Crossover and mutation are applied to generate offspring, which form the new population. The algorithm records the best individual and its fitness value in each generation. After reaching the maximum number of generations, the algorithm returns the best individual as the optimal task scheduling scheme.
| Input: number of terminals \(M\), number of UAVs \(U\), time slots \(T\), population size \(P\), generations \(G\), crossover rate \(p_c\), mutation rate \(p_m\), tournament size \(s\) |
| Output: best scheduling scheme \(X^*\), best fitness |
| 1. Initialize population \(P\) |
| 2. \(best\_fitness \leftarrow \infty\) |
| 3. for generation = 1 to \(G\) do |
| 4. for each individual \(X\) in population do |
| 5. compute fitness \(F(X)\) |
| 6. if \(F(X) < best\_fitness\) then |
| 7. update \(best\_fitness\) and \(X^*\) |
| 8. parents \(\leftarrow\) tournament_selection(population, \(s\)) |
| 9. offspring \(\leftarrow\) crossover(parents, \(p_c\)) |
| 10. population \(\leftarrow\) mutation(offspring, \(p_m\)) |
| 11. end for |
| 12. return \(X^*\), \(best\_fitness\) |
5. Experiments and Analysis
To evaluate the performance of the proposed model and algorithm, I conducted a series of simulations. The experiments were implemented in Python 3.10 using NumPy, Random, Math, Time, and Matplotlib. The computational environment was configured with an Intel(R) Core(TM) i5-4300M CPU at 2.60 GHz and 8 GB RAM.
5.1 Simulation parameters
The default simulation parameters are listed in Table 2. In different experiments, some parameters were varied to analyze their influence on the system performance.
| Parameter | Value |
|---|---|
| Number of mobile terminals | 20 / 40 |
| Radius of terminal circular motion | 20 m |
| Number of movement steps | 25 |
| Number of UAVs | 4 / 10 |
| UAV coverage radius | 25 / 50 m |
| Iterations | 30 / 50 |
| Rectangular area minimum coordinate | (0, 0) m |
| Rectangular area maximum coordinate | (100, 100) m |
| UAV circular motion radius | 30 m |
| UAV zigzag amplitude | 10 m |
| UAV zigzag period | 10 s |
| Terminal linear motion speed | 3 m/s |
5.2 Convergence validation
I ran the genetic algorithm 30 times independently, with a maximum of 30 generations per run. In each run, I recorded the average fitness value of each generation. Figure 1 shows the change in the average fitness value over generations when the UAV moves in circular motion.
The results indicate that the average fitness value decreases steadily as the generation number increases. This trend confirms that the genetic algorithm gradually improves the quality of the solutions and converges toward a near-optimal solution. Similar convergence trends were observed for the zigzag motion mode and the linear motion mode. The final fitness values remained stable across the 30 independent runs, which demonstrates the stability and reliability of the algorithm.
5.3 Optimal task allocation scheme
I recorded the optimal task allocation scheme in a complete experiment. Table 3 presents the best connection pattern between 20 mobile terminals and 4 UAVs over 10 time slots when the UAVs move in circular motion. Each entry in the table indicates the index of the UAV that serves the corresponding terminal at a given time slot.
| Terminal | t0 | t1 | t2 | t3 | t4 | t5 | t6 | t7 | t8 | t9 |
|---|---|---|---|---|---|---|---|---|---|---|
| m0 | 2 | 1 | 3 | 2 | 3 | 0 | 3 | 0 | 2 | 2 |
| m1 | 0 | 2 | 3 | 3 | 3 | 2 | 1 | 2 | 0 | 2 |
| m2 | 0 | 0 | 0 | 1 | 0 | 2 | 2 | 1 | 3 | 3 |
| m3 | 3 | 0 | 2 | 1 | 1 | 1 | 2 | 3 | 3 | 2 |
| m4 | 1 | 3 | 1 | 3 | 0 | 3 | 2 | 2 | 0 | 2 |
| m5 | 1 | 0 | 0 | 3 | 3 | 2 | 3 | 2 | 3 | 2 |
| m6 | 1 | 3 | 3 | 1 | 1 | 0 | 3 | 0 | 1 | 1 |
| m7 | 2 | 0 | 1 | 2 | 3 | 1 | 0 | 3 | 3 | 2 |
| m8 | 3 | 1 | 2 | 2 | 3 | 3 | 2 | 1 | 0 | 2 |
| m9 | 1 | 2 | 1 | 3 | 2 | 3 | 3 | 1 | 1 | 2 |
| m10 | 3 | 2 | 3 | 3 | 0 | 0 | 0 | 2 | 1 | 0 |
| m11 | 1 | 0 | 3 | 0 | 0 | 2 | 2 | 3 | 1 | 2 |
| m12 | 0 | 3 | 3 | 0 | 1 | 3 | 2 | 2 | 3 | 1 |
| m13 | 0 | 0 | 2 | 2 | 2 | 0 | 3 | 3 | 2 | 2 |
| m14 | 3 | 1 | 0 | 3 | 2 | 1 | 2 | 2 | 1 | 3 |
| m15 | 0 | 0 | 3 | 1 | 0 | 3 | 1 | 0 | 0 | 3 |
| m16 | 2 | 0 | 3 | 0 | 1 | 2 | 0 | 0 | 2 | 0 |
| m17 | 3 | 1 | 0 | 2 | 0 | 3 | 3 | 2 | 1 | 2 |
| m18 | 3 | 0 | 0 | 3 | 1 | 3 | 0 | 1 | 3 | 3 |
| m19 | 3 | 1 | 1 | 1 | 2 | 2 | 0 | 3 | 3 | 1 |
The table reveals the dynamic nature of the task scheduling. The same terminal often connects to different UAVs in different time slots. This indicates that the algorithm adapts to the changing network topology and resource availability. In addition, the load is distributed across all UAVs rather than concentrated on a single one. This load-balancing behavior helps to prevent UAV overload and improves the overall efficiency of the system.
5.4 Sensitivity analysis
To evaluate the robustness of the model, I studied the influence of key parameters such as the number of mobile terminals, the number of UAVs, and the number of movement steps.
5.4.1 Impact of the number of mobile terminals
I varied the number of mobile terminals from 5 to 40 and measured the computational task completion time, the system energy consumption, the algorithm running time, and the total system cost. The results are summarized in Table 4.
| Terminals | Completion time (s) | Energy (J) | Running time (s) | Total cost |
|---|---|---|---|---|
| 5 | 420.04 | 5073.14 | 4.63 | 88.54 |
| 10 | 904.67 | 17284.04 | 7.44 | 254.26 |
| 15 | 1388.38 | 36515.03 | 10.50 | 490.10 |
| 20 | 2159.38 | 90315.16 | 14.56 | 1097.50 |
| 25 | 2506.48 | 132105.02 | 18.16 | 1546.63 |
| 30 | 3265.32 | 192538.55 | 21.50 | 2219.26 |
| 35 | 3685.97 | 244449.52 | 24.95 | 2776.23 |
| 40 | 4300.01 | 325141.12 | 28.57 | 3638.41 |
As the number of mobile terminals increases, the total number of tasks increases, which places greater pressure on the UAV resources. The task completion time, the system energy consumption, and the total system cost all increase significantly. The running time of the genetic algorithm also increases because the search space becomes larger. These results suggest that if the system has to process a large number of tasks, it is beneficial to deploy more UAVs to balance the load and reduce the cost.
5.4.2 Impact of the number of UAVs
I varied the number of UAVs from 5 to 25, while keeping the number of mobile terminals at 40. Table 5 shows the results.
| UAVs | Completion time (s) | Energy (J) | Running time (s) | Total cost |
|---|---|---|---|---|
| 5 | 2084.77 | 87516.72 | 15.02 | 1062.80 |
| 10 | 2117.40 | 75733.32 | 15.79 | 947.90 |
| 15 | 2022.08 | 59199.87 | 14.30 | 773.99 |
| 20 | 1970.17 | 39966.09 | 18.37 | 576.98 |
| 25 | 1927.46 | 35673.98 | 17.28 | 530.21 |
The results show that increasing the number of UAVs reduces the energy consumption and the total system cost. The task completion time also tends to decrease, although there is a slight fluctuation when increasing from 5 to 10 UAVs. This fluctuation is likely due to the increased complexity of coordination among a moderate number of UAVs. When the number of UAVs is large enough, the tasks are distributed more evenly and the overall performance improves. The marginal benefit of adding more UAVs is larger when transitioning from a small number to a moderate number, and diminishes as the number grows larger. This suggests that there is an optimal number of UAVs for a given application scenario.
5.4.3 Impact of movement steps
I also analyzed the impact of the number of movement steps (\(movesteps\)) on the system performance. The results are shown in Table 6.
| Steps | Completion time (s) | Energy (J) | Running time (s) | Total cost |
|---|---|---|---|---|
| 5 | 845.73 | 2339.00 | 0.95 | 99.51 |
| 10 | 1103.61 | 4743.79 | 1.44 | 146.76 |
| 15 | 1178.18 | 6501.74 | 1.90 | 171.05 |
| 20 | 1337.75 | 12015.73 | 2.68 | 240.55 |
| 25 | 1480.23 | 12904.63 | 3.08 | 262.27 |
| 30 | 1644.90 | 17723.29 | 3.66 | 325.27 |
| 35 | 1489.39 | 18854.10 | 4.20 | 322.59 |
| 40 | 1740.50 | 21994.83 | 4.85 | 376.59 |
| 45 | 1893.39 | 36573.14 | 6.92 | 536.14 |
| 50 | 1861.05 | 48215.41 | 8.64 | 649.65 |
In general, increasing the movement steps leads to a larger number of task positions and therefore a higher communication distance and task processing time. As a result, the task completion time, the system energy consumption, and the total system cost increase. The running time of the genetic algorithm also grows because the encoding dimension expands. However, the relationship is not perfectly monotonic because of the randomness in the initial positions and the dynamic allocation of tasks.
5.5 Comparison with the signal-strength scheme
To further validate the advantage of the genetic algorithm, I compared it with a traditional signal-strength-based allocation method. In the signal-strength scheme, each terminal selects the UAV with the strongest received signal, regardless of the current load or the global balance of tasks. This greedy approach is simple but often leads to overload of certain UAVs and high system cost.
The comparison was conducted with 5 UAVs, a coverage radius of 50 meters, and a varying number of mobile terminals from 5 to 80. Table 7 reports the total costs of the two schemes.
| Terminals | GA total cost | Signal-strength total cost |
|---|---|---|
| 5 | 3607 | 48 |
| 10 | 10013 | 2608 |
| 15 | 16489 | 23120 |
| 20 | 22751 | 21163 |
| 25 | 37188 | 47921 |
| 30 | 36046 | 59959 |
| 35 | 44805 | 58480 |
| 40 | 53862 | 65972 |
| 45 | 65391 | 95664 |
| 50 | 68646 | 104690 |
| 55 | 76353 | 89318 |
| 60 | 71479 | 121072 |
| 65 | 92068 | 104921 |
| 70 | 94952 | 151869 |
| 75 | 113578 | 299314 |
| 80 | 105691 | 180362 |
When the number of terminals is very small, the signal-strength scheme has a smaller total cost because it directly maximizes the communication quality without much consideration of load balance. However, as the number of terminals grows, the signal-strength scheme leads to severe load imbalance, and some UAVs become overloaded. The total cost increases dramatically. In contrast, the genetic algorithm maintains a balanced allocation and consistently produces a lower total cost. This demonstrates that the genetic algorithm has a significant advantage in complex environments with a large number of tasks.
5.6 Comparison of multiple movement-mode combinations
Finally, I studied the performance of different combinations of UAV movement modes and terminal movement modes. The three UAV movement modes are circular, zigzag, and linear translation. The two terminal movement modes are circular and linear motion. I evaluated the total cost of each combination in a forest fire monitoring scenario with 20 mobile terminals and 10 UAVs. The simulation was run for 30 generations, and the average total cost of 30 independent runs was recorded.
Table 8 summarizes the average total cost for each combination.
| UAV mode | Terminal mode | Average total cost |
|---|---|---|
| Zigzag | Circular | ~52 |
| Zigzag | Linear | ~58 |
| Circular | Circular | ~66 |
| Circular | Linear | ~72 |
| Linear | Circular | ~490 |
| Linear | Linear | ~560 |
The zigzag motion mode of the UAV yields the lowest total cost among the three UAV movement modes. This is because the zigzag pattern enables the UAV to cover a wider area, avoid obstacles, and maintain better communication links with mobile terminals. The circular motion mode also performs well, particularly when the terminals move in a circular pattern, because both the UAV and the terminal maintain a relatively stable distance. The linear motion mode has the highest total cost. The fixed linear path is not flexible enough to adapt to the dynamic distribution of terminals, which leads to signal blind zones, load imbalance, and high task completion time.
To further verify the scalability of the model, I also tested a larger scenario with 50 mobile terminals and 10 UAVs. The general trend remained the same. The zigzag and circular movement modes of the UAV outperformed the linear translation mode. The difference in total cost between the linear UAV mode and the other modes became even larger when the number of terminals increased, because the limitations of the linear path were amplified by the increased task density and the wider distribution of terminals.
These results provide important guidance for the deployment of UAV-assisted MEC systems in forest fire monitoring. In a complex forest terrain, the zigzag movement mode is preferred because it can flexibly traverse valleys and avoid obstacles while collecting data from mobile terminals. In a scenario where a fixed area must be monitored continuously, the circular movement mode provides stable coverage of the entire region. The linear movement mode should be avoided unless the region is simple and the terminal distribution is predictable.
6. Conclusion and Future Work
In this paper, I studied the task offloading and resource scheduling optimization problems in UAV-assisted mobile edge computing systems where both the terminal devices and the edge devices are movable. I proposed two cooperative optimization models. In the first model, mobile terminals move in circular patterns while UAVs move in parallel translation patterns. In the second model, I extended the movement modes to multiple patterns for both UAVs and terminals. An unmanned aerial vehicle can fly in circular, zigzag, or linear translation patterns, while a mobile terminal can move in circular or linear patterns.
I formulated the optimization objective as the weighted sum of the task completion time and the system energy consumption. To solve this problem, I designed a genetic algorithm that uses a three-dimensional binary encoding for task scheduling, tournament selection, partial mapped crossover, and mutation. The algorithm was validated through extensive simulations. The experimental results showed that the algorithm converges stably to a near-optimal solution, achieves a balanced allocation of computation tasks among UAVs, and significantly reduces the system cost compared with the signal-strength-based greedy approach.
The sensitivity analysis revealed that the number of mobile terminals, the number of UAVs, and the number of movement steps have a substantial impact on the system performance. Increasing the number of UAVs improves the task completion time and reduces the energy consumption, but the marginal benefit diminishes as the fleet size grows. The comparison of different movement-mode combinations indicated that the zigzag movement mode of the UAV is the most effective for complex terrain, while the circular movement mode is suitable for stable continuous monitoring. The linear movement mode is less flexible and results in a much higher system cost.
The research presented in this paper provides new ideas for the application of unmanned aerial vehicles in disaster monitoring, emergency communication, and other dynamic scenarios. In future work, I plan to investigate more sophisticated environmental sensing models that incorporate terrain features and signal propagation characteristics. I also intend to combine the genetic algorithm with other metaheuristic algorithms or deep reinforcement learning methods to reduce the computational complexity and improve the convergence speed in large-scale scenarios. Finally, I will test the proposed model in additional practical scenarios, such as intelligent logistics delivery in urban environments and emergency communication support in remote regions, to further enhance the adaptability and reliability of the system.