Mobility-Aware Cooperative Optimization for Task Offloading and Resource Allocation in Multi-Edge Computing

Abstract

The rapid proliferation of mobile Internet of Things (IoT) devices has introduced significant resource scheduling challenges in multi-edge computing networks, where device mobility leads to dynamic network connectivity and load imbalance, complicating task offloading and resource management. To address these issues, this paper presents a mobility-driven hierarchical optimization framework for task offloading and computation resource allocation in multi-region edge computing environments, a functionally coupled hierarchical framework that integrates mobility-aware heuristic offloading with multi-agent deep deterministic policy gradient (MADDPG)-based resource allocation. Devices are first clustered according to their mobility patterns, and offloading decisions are dynamically made based on trajectory and dwell-time characteristics. Each edge server is modeled as an autonomous agent, and an MADDPG framework is adopted to collaboratively optimize resource allocation, with the joint objective of minimizing task processing delay and system energy consumption. Experimental evaluations under diverse mobility and workload conditions show that the proposed approach achieves a 19.0% reduction in task delay compared to the Multi-Objective Gray Wolf Optimization (MOGWO) method at the largest device scale (60 devices) and maintains comparable energy efficiency. Furthermore, it exhibits stronger adaptability and scheduling performance across varying mobility group distributions. These results confirm the effectiveness of the proposed method in enhancing system performance within dynamic mobile edge computing scenarios.

1. Introduction

Digital transformation is driving rapid advancements in Internet of Things (IoT) technology and the fusion of computing and networking. A continually expanding array of terminal devices—such as in-vehicle systems, wearable electronics, and environmental sensors—is being integrated into networks, fostering the development of a highly intricate and dynamically changing ecosystem of computing and communication resources. Alongside the widespread deployment of ubiquitous mobile applications, the need for low-latency and high-efficiency computing services at the terminal side continues to grow [1]. Nevertheless, the computational capabilities of most end devices remain limited, leaving them unable to independently execute complex tasks. Moreover, due to constraints in network transmission latency and bandwidth, dependence exclusively on remote cloud servers no longer meets the stringent quality-of-service (QoS) requirements of delay-sensitive applications. To reduce the computational burden on terminals, mobile edge computing (MEC) has arisen as a new computing paradigm. By deploying computational resources near data sources at the network edge, MEC enables tasks to be processed locally or on neighboring edge servers, which effectively cuts communication latency, boosts response speed, and enhances task offloading flexibility [2]. However, the relatively restricted computing resources of edge nodes, combined with the highly dynamic mobility of devices, pose significant challenges. Thus, how to intelligently make task offloading decisions and efficiently allocate limited edge computing resources has become a central issue in current edge computing research.

In recent years, substantial research has been conducted on task offloading and resource allocation strategies in MEC scenarios. For example, reference [3] proposes a multi-objective resource allocation method for IoT applications, where ideal similarity preferences and multi-criteria decision-making techniques are used to derive offloading strategies that optimize both delay and load balancing. Reference [4] introduces a novel MEC system model incorporating three task processing mechanisms—local cached computing, local computing without cache, and edge server computing—and formulates a joint caching-computing optimization problem to minimize average bandwidth usage under delay, cache capacity, and average power constraints. Reference [5] presents a fuzzy reinforcement learning (FRL)-based task scheduling mechanism that models IoT task scheduling as a mixed-integer nonlinear programming problem; fuzzy logic is applied to prioritize tasks, after which policy-based reinforcement learning is used to reduce task service delay and fog node energy consumption. These methods, however, largely overlook the mobility of end devices. In mobile networks, device movement presents a critical challenge, often degrading the performance of traditional offloading algorithms and resulting in frequent service interruptions and user dissatisfaction [6]. The absence of a mobility-aware classification framework limits the adaptability of such approaches in dynamic IoT environments. Specifically, device mobility degrades offloading performance through several concrete mechanisms: frequent handovers between edge nodes cause task migration overhead and increased latency; short dwell times within a single edge’s coverage may render offloading infeasible, leading to task failure or forced local execution; association instability results in fluctuating wireless link quality, affecting transmission success; and cross-region load shifts create dynamic and unpredictable imbalances among edge servers, complicating global resource scheduling.

To address these limitations, a number of studies have introduced mobility awareness into optimization models. Reference [7] investigates task offloading and resource allocation in mobility-aware IoT networks with multiple MEC servers and proposes an online mobility-aware offloading and allocation algorithm based on Lyapunov optimization and semi-definite programming (SDP). Reference [8] examines multi-user offloading and resource allocation under mobility constraints and designs a heuristic mobility-aware offloading algorithm (HMOA) to obtain near-optimal solutions. Reference [9] accounts for the mobility characteristics of terminal devices, the dynamic distribution of device density, and the heterogeneous communication capabilities of MEC servers; it puts forward a probabilistic computation offloading (PCO) algorithm and solves the augmented Lagrangian form of the objective function via the alternating direction method of multipliers (ADMM). Reference [10] focuses on vehicular edge computing (VEC) and incorporates speed-aware delay tolerance, applying an improved non-dominated sorting genetic Algorithm II (NSGA-II) to obtain low-complexity Pareto-optimal solutions and selecting the final offloading strategy based on QoS trade-offs between delay and energy consumption. Although these heuristic or optimization-based methods improve offloading performance in mobile settings, they frequently require considerable computation and parameter tuning, which reduces their practicality for real-time and large-scale deployments. In contrast, deep reinforcement learning (DRL) has shown promising potential across a variety of communication and network optimization problems [11]. Reference [12] proposes a hybrid task offloading scheme based on Deep Q-Network (DQN) for urban traffic light scenarios, ensuring computational requirements while meeting task latency constraints. Reference [13] proposed a Mean-Field Multi-Agent Task Offloading (MF-MATO) algorithm for large-scale Multi-access Edge Computing (MEC) scenarios, which addresses the partial observability issue via Long Short-Term Memory (LSTM) and reduces the dimensionality of the joint action space using mean field approximation theory, achieving comparable task latency and drop rate performance to multi-agent deep deterministic policy gradient (MADDPG) while enhancing system scalability. Reference [14] proposed the MADDPG-DRTD algorithm for resource allocation in multi-UAV communication networks, which leverages global reward and local task decomposition reward under the MADDPG framework to address the challenges of balancing overall and partial system performance and achieving cooperative optimization across communication links. Yet despite their respective advancements in task offloading or resource allocation for specific scenarios, these approaches consider relatively static environments, where devices are stationary or have fixed relative positions—overlooking the dynamic changes in real-world network topologies.

Despite the advancements in mobility-aware offloading strategies, significant research gaps remain. Most existing approaches rely on heuristic or centralized optimization methods, which struggle to adapt to the dynamic and large-scale nature of edge networks. Furthermore, the absence of a structured grouping mechanism based on device trajectory and dwell-time characteristics hinders the design of adaptive offloading policies tailored to diverse mobility patterns. Moreover, few studies have effectively integrated such mobility-grouping strategies with multi-agent deep reinforcement learning to enable collaborative and real-time resource scheduling across distributed edge nodes.

To tackle the challenges outlined above, this paper proposes a mobility-driven task offloading and computation resource optimization allocation method. The principal contributions are as follows:

(1)

A hierarchical optimization framework is proposed for multi-region edge computing environments. The framework integrates a mobility group-driven task offloading mechanism with adaptive resource scheduling among edge servers, achieving global optimization of task assignment and resource utilization under dynamic network conditions.

(2)

In order to accommodate the heterogeneity of devices with different mobility patterns, a mobility grouping mechanism is designed based on device trajectories and stay duration. A dynamic offloading decision process is then developed to intelligently determine whether tasks should be executed locally or offloaded to the most suitable edge server, with factors such as delay estimation and regional load being taken into account.

(3)

Building on the offloading decisions, each edge server is modeled as an agent, and the MADDPG algorithm is employed to jointly optimize task delay and energy consumption. By leveraging task features and group-aware indicators, the agents learn to allocate limited computing resources efficiently, thereby enhancing the overall adaptability and scheduling performance of the system.

Finally, extensive comparative experiments are conducted against various baseline methods to verify the effectiveness of the proposed approach under diverse scenarios.

2. System Model

The system model considered in this paper is illustrated in Figure 1. The system operates on a discrete-time basis, where the system operation is divided into fixed-length time steps. The scenario comprises multiple edge nodes and various types of terminal devices. The set of edge nodes is denoted as $e=\left\{1,2,\dots ,E\right\}$. Each edge node covers a specific geographical area and possesses limited computing capability, providing nearby offloading services for devices. The set of devices is denoted as $m=\left\{1,2,\dots ,M\right\}$. These devices include vehicle terminals, portable or fixed computing terminals, environmental sensors, etc., exhibiting diverse mobility characteristics and generating different computational tasks. Task characteristics are represented as $\left\{d,c\right\}$, denoting the task data size and the computational resources required per bit of data, respectively.

2.1. Computation Model

When a task from device $m_i$ is executed locally, the local computation delay is as follows:

$$t_i^{loc}={\displaystyle \frac{d_i{c}_i}{f_i^{loc}}}$$

(1)

where $d_i$ and $c_i$ represent the data size and the computational resources required per bit of data of the task from device $m_i$ respectively. $f_i^{loc}$ denotes the computational capability of device $m_i$.

The local computation energy consumption is as follows:

$$E_i^{local}=\kappa d_i{[f_i^{loc}]}^2$$

(2)

where $\kappa$ is the energy efficiency coefficient of device $m_i$.

When a task from device $m_i$ is offloaded to edge node $e_j$ for execution, the uplink transmission rate is as follows:

$$r_{i,j}^{up}=B_{j,i}{\log }_2\left(1+{\displaystyle \frac{p_{i}h}{{\sigma }^2}}\right)$$

(3)

where $B_{j,i}$ represents the link bandwidth allocated by edge node $e_j$ for this device’s task at time t, $p_i$ denotes the device’s transmit power, $h$ represents the power gain between the device and the edge node at time t, and ${\sigma }^2$ denotes the white Gaussian noise power.

Therefore, the transmission delay during offloading is as follows:

$$t_{i,j}^{up}={\displaystyle \frac{d_i}{r_{i,j}^{up}}}$$

(4)

Since the transmit power of edge nodes is significantly higher than that of vehicles, the downlink transmission delay is much smaller than the uplink transmission delay and can be neglected in the computation process.

Edge nodes are interconnected via high-speed links. When tasks require collaborative processing or migration between different edge servers, this link is utilized for data transmission. The transmission delay for a task from device $m_i$ between edge nodes $e_j$ and $e_k$ is as follows:

$$t_{i,j,k}^{\mathrm{trans}}={\displaystyle \frac{d_i}{b}}$$

(5)

where b represents the link transmission rate between edge nodes.

The computation delay for a task from device $m_i$ on edge server $e_j$ is as follows:

$$t_{i,j}^{cal}={\displaystyle \frac{d_i\cdot c_i}{f_{j,i}}}$$

(6)

where $f_{j,i}$ is the computational resource allocated by edge node $e_j$ for this task.

Since edge servers offer a stable power supply and highly efficient computing capabilities, delivering superior performance per watt compared to mobile chips with lower effective switching capacitance. Their energy consumption per unit of computation is significantly lower than that of mobile devices. Moreover, edge nodes are typically equipped with energy-efficient hardware architectures and optimized power management mechanisms, leading to marginal energy consumption increments during task processing. Processing edge tasks under continuous operation has minimal impact on overall energy consumption. Specifically, the transmission energy consumption generated when task from device $m_i$ is offloaded to edge node $e_j$ is as follows:

$$E_{i,j}^{up}=P_i\cdot t_{i,j}^{up}$$

(7)

Binary offloading decisions are adopted for terminal device tasks. Generated tasks are either executed locally or offloaded to an edge node for processing. A binary offloading selection variable $a_{i,j}\in \{0,1\}$ is introduced to denote the execution method of the task from device $m_i$: when $a_i=0$, the task is executed locally; otherwise, it indicates the task is offloaded to edge node $e_j$. Additionally, a binary variable $b_{j,k}$ is introduced to represent the allocation relationship between the task and the edge node. If $b_{j,k}=0$, it indicates the task is processed at its current associated edge node $e_j$; otherwise, it indicates the task is transmitted to edge node $e_k$ for processing. Therefore, the task processing delay for device $m_i$ can be expressed as follows:

$$T_i^{total}=\left\{\begin{array}{c}{t}_i^{loc},a_{i,j}=0\\ t_{i,j}^{up}+t_{i,j}^{cal},a_{i,j}=1,b_{j,k}=0\\ t_{i,j}^{up}+t_{i,j,k}^{\mathrm{trans}}+t_{i,k}^{cal},a_{i,j}=1,b_{j,k}=1\end{array}\right.$$

(8)

The task processing energy consumption for device $m_i$ can be expressed as follows:

$$E_i^{total}=\left(1-a_{i,j}\right)E_i^{local}+a_{i,j}{E}_{i,j}^{up}$$

(9)

2.2. Mobility Modeling

To fully consider the differences in mobility characteristics among different types of devices, this paper employs a probability-based grid migration model to model device location [15]. This model, while a simplification of real-world movement, is widely adopted in mobile edge computing studies for its ability to abstract and parameterize the two mobility features most critical to task offloading: spatial uncertainty and temporal connection stability. It provides a controlled and scalable testbed that effectively generates the dynamic network topology and intermittent connectivity, allowing us to systematically evaluate our framework’s response to varied mobility patterns. The model assumes that device movement follows a memoryless property, meaning the device’s location at the next time step depends only on its current location. The mobility characteristics of a device consist of a mobility stability factor and directional transition probabilities. Let the current location of a device at any time step t be $l_d(t)$. Its transition probability to the next time step satisfies the following form:

$$p(l_d^{\prime }(t+1)=l^{\prime }\mid l_d(t)=l)=\left\{\begin{array}{cc}{p}^s,& l^{\prime }=l\\ p^m,& l^{\prime }\ne l\end{array}\right.$$

(10)

where $p^s$ is the mobility stability factor, representing the probability that the device remains at its current location. By adjusting $p^s$, device behavior under different mobility patterns can be simulated. $p^m$ is the directional transition probability, representing the probabilities of moving north, south, east, or west.

Based on the above modeling approach, devices are categorized into three groups according to their movement tendencies: High-Mobility Group: Set $p^s=0.1$, $p^m=0.225$. Used to simulate devices with frequent location changes, such as high-speed vehicle terminals. Medium-Mobility Group: Set $p^s=0.3$, $p^m=0.175$. Used to simulate devices with moderate migration frequency, exhibiting a relative balance between moving and stationary states, such as smart devices carried by pedestrians. Low-Mobility Group: Set $p^s=0.5$, $p^m=0.125$. Used to simulate terminals that remain stationary or move slowly most of the time, such as fixed sensors or parked devices.

2.3. Problem Formulation

Due to the diversity in device mobility and task heterogeneity, the task execution process involves the dynamic allocation of various resources, including wireless communication bandwidth and edge computing capacity. During offloading and scheduling, task delay and energy consumption often exhibit a trade-off relationship: offloading tasks can reduce the local computation burden but also introduce transmission delay and communication energy consumption. Therefore, the goal of this paper is to jointly optimize task execution delay and system energy consumption, reducing overall energy consumption while satisfying task QoS constraints. The optimization problem is formulated as follows:

$$\begin{array}{cc}\mathrm{P}1:\hfill & \min {\displaystyle \sum _{l=1}^M\left(T_i^{total}+E_i^{total}\right)}\hfill \\ s.t.\hfill & C1:{\displaystyle \sum _{i=1}^M{a}_{i,j}\le 1,\forall j\in M}\hfill \\ & C2:{\displaystyle \sum _{k=1}^N{b}_{j,k}}\le 1,\forall k\in M\hfill \\ & C3:0\le B_{j,i}\le B_j,\forall i\in e\hfill \\ & \begin{array}{l}C4:{\displaystyle \sum _{l=1}^M{B}_{j,i}}\le B_j\\ C5:0\le f_{j,i}\le F_j\\ C6:{\displaystyle \sum _{l=1}^M{f}_{j,i}}\le F_j\end{array}\hfill \end{array}$$

(11)

where $B_j$ represents the link bandwidth of edge node $e_j$, and $F_j$ represents the maximum computing capacity of the server at edge node $e_j$. Constraints C1 and C2 are uniqueness constraints, ensuring each task selects only one processing method and is processed by at most one edge node. C3 limits the upper bound of bandwidth allocated by an edge node to a single task. C4 ensures the total bandwidth allocated by each edge node does not exceed its maximum link bandwidth. Similarly, C5 limits the upper bound of computational resources allocated by an edge node to a single task. C6 ensures the total computational resources allocated by each edge node do not exceed the computing capacity of its server.

3. Mobility Group-Driven Task Offloading and Edge Resource Allocation via MADDPG

The overall optimization problem in MEC encompasses two interrelated yet distinct challenges: first, ensuring feasible task offloading under stringent and rapidly varying mobility constraints; and second, achieving efficient multi-agent resource coordination to optimize system-level objectives. To effectively address this complexity, we propose a cooperative two-tier optimization framework. The first tier consists of mobility-aware, rule-based filtering, which rapidly handles the discrete, constraint-satisfaction aspect of offloading, ensuring that only tasks with a high likelihood of successful completion are admitted into the edge network. The second tier employs MADDPG-based collaborative scheduling, focusing on the more refined, continuous problem of how multiple edge nodes should dynamically allocate resources among the admitted tasks to jointly reduce latency and energy consumption. This hierarchical decomposition allows the rule-based tier to leverage domain knowledge for system robustness, while the reinforcement learning tier explores complex cooperative strategies that are intractable for predefined heuristics.

3.1. Mobility Group-Driven Differentiated Offloading Policy

To adapt to the differences in mobility, link stability, and resource sensitivity among different types of terminals, this paper designs corresponding task offloading decision rules based on the aforementioned high, medium, and low mobility groups. These rules serve as pre-filtering logic during the online scheduling phase to reduce the global scheduling space and enhance the real-time performance and robustness of subsequent resource allocation strategies.

To transcend heuristic approaches and provide a theoretical foundation for offloading decisions, we derive optimal offloading boundaries for each mobility group based on system constraints and objective functions. For High-Mobility Group devices, the connection cycle within the edge coverage area is short, and the link volatility is strong, making it difficult to ensure the integrity of task offloading. Therefore, a strategy for determining the feasibility of offloading within a single connection cycle is adopted. Within the current connection cycle, if the following conditions are met:

$$t_{i,j}^{up}+{\displaystyle \frac{d_i\cdot c_i}{f_j/n}}<\tau$$

(12)

where $t_{i,j}^{up}$ refers to the uplink transmission delay defined in Equation (4); $f_j$ is the computing capacity of edge node $e_j$, and n is the number of device tasks in the region, then the system executes edge offloading, which offloads tasks to the edge server currently associated with the device. Otherwise, the task is retained for local processing. This equal-share form provides a conservative upper bound for per-task processing latency under concurrent execution, which is appropriate for the fast feasibility screening in the Tier-1 filter. It is important to note that this approximation is used only for the binary offloading decision at this stage and does not restrict the downstream MADDPG scheduler, which later optimizes the fine-grained resource allocation for each task.

For Medium-Mobility Group devices, connection latency and network quality are subject to fluctuations to a certain extent, and the benefits of offloading are greatly affected by network fluctuations. Therefore, a latency comparison strategy is introduced into the offloading decision to determine whether there is a significant latency advantage. If the following conditions are met:

$$t_{i,j}^{up}+{\displaystyle \frac{d_i\cdot c_i}{f_j/n}}<t_i^{loc}-\Delta t$$

(13)

where $t_i^{loc}$ refers to the local computation delay defined in Equation (1), and $\Delta t>0$ is a threshold parameter, then the system chooses to offload the task to the edge server currently associated with the device. Otherwise, the task is prioritized for local computation to avoid delay fluctuations caused by unstable edge loads.

For Low-Mobility Group devices, which have stable connections and strong coverage continuity, tasks with high computational requirements are prioritized for offloading to edge nodes with sufficient computational resources and lower scheduling pressure, thereby fully leveraging edge computing power and enhancing the system’s overall load balancing performance. The decision process operates sequentially within a single scheduling time step: offloading choices for high- and medium-mobility devices are determined first. During the selection process for offloading target nodes, the system first compiles the number of high- and medium-mobility tasks selected as target nodes for each edge node within the current cycle based on the offloading decision results from high- and medium-mobility devices in the preceding period. This data is used to construct an offloading scheduling pressure metric:

$$P_j=N_j^{(H,\mathrm{offload})}+N_j^{(M,\mathrm{offload})}$$

(14)

where $N_j^{(H,\mathrm{offload})}$ and $N_j^{(M,\mathrm{offload})}$ represent the number of times node $e_j$ was selected as the offloading target by high and medium mobility group tasks in the current scheduling cycle, respectively. The system then selects the edge node with the largest available computational resources per unit of expected scheduling pressure as the offloading target node for low-mobility tasks:

$$e_j^{\ast }=\arg \underset{j\in E}{\max }\left({\displaystyle \frac{f_j}{P_j+ϵ}}\right)$$

(15)

If the task from device $m_i$ satisfies $d_i>\Delta d$, where $\Delta d>0$ is a threshold parameter, then the system chooses to offload the task. Otherwise, the task is prioritized for local computation.

The thresholds $\tau$, $\Delta t$, and $\Delta d$ are empirically determined based on simulation trials and typical task characteristics in MEC scenarios. Specifically, $\tau$ is set to half the duration of a connection cycle to ensure offloading feasibility within that temporal window, while $\Delta t$ and $\Delta d$ are calibrated from historical task execution profiles to balance latency benefits against resource utilization.

Considering that device mobility directly affects its connection stability and link persistence, this paper also designs a mobility-group-aware weighted bandwidth allocation strategy. This strategy prioritizes ensuring the upload efficiency of high-mobility tasks to reduce the probability of offloading failure due to link interruptions, while maintaining system fairness. Specifically, let the available uplink bandwidth of edge node $e_j$ be $B_j$ and the set of devices currently connected to this node and preparing to upload tasks be $T_j$. For any device $m_i\in T_j$, a weighting factor $w_i$ is defined based on its mobility group type as follows:

$$w_i=\left\{\begin{array}{cc}1.5,\hfill & {\mathrm{m}}_i\in \mathrm{High}\text{-}\mathrm{Mobility}\mathrm{Group}\hfill \\ 1.0,\hfill & {\mathrm{m}}_i\in \mathrm{Medium}\text{-}\mathrm{Mobility}\mathrm{Group}\hfill \\ 0.5,\hfill & {\mathrm{m}}_i\in \mathrm{Low}\text{-}\mathrm{Mobility}\mathrm{Group}\hfill \end{array}\right.$$

(16)

Communication resources are allocated according to the weighting coefficients. The uplink bandwidth allocated to task from device $m_i$ is as follows:

$$b_{j,i}=B_j\cdot {\displaystyle \frac{w_i}{{\displaystyle \sum _{k\in {\mathcal{T}}_j}}{w}_k}}$$

(17)

where ${\displaystyle \sum _{k\in {\mathcal{T}}_j}}{w}_k$ represents the sum of weighting factors corresponding to all devices currently connected to edge node $e_j$, used to normalize the weight of each device. This ensures reasonable on-demand bandwidth allocation under limited total resources, avoiding issues of excessive or unfair allocation.

3.2. MADDPG-Based Computing-Network Resource Scheduling Strategy Design

The MADDPG-based resource scheduler operates on a task set that has undergone pre-filtering based on the theoretically optimal boundary described earlier. This two-tiered design—where the first tier guarantees decision optimality under mobility constraints, and the second tier learns adaptive resource allocation—forms the core of our unified co-design framework.

3.2.1. Markov Decision Process Modeling

To achieve collaborative resource scheduling among multiple edge nodes in complex dynamic environments, this paper models the computational resource allocation process of the multi-agent edge system as a stochastic game (SG), which naturally fits the essence of competitive-cooperative resource allocation among multiple agents, and further frames it as a Distributed Partially Observable Markov Decision Process (Dec-POMDP) considering partial observability of local agents. We employ the MADDPG algorithm under the Centralized Training with Decentralized Execution (CTDE) paradigm to optimize the resource allocation behavior of each edge node (agent). In this modeling framework, each edge node is treated as an independent agent: its local observation (incomplete global state) constitutes the decision basis for decentralized execution, while the global state (full system information) is used for centralized training of the critic network to address the credit assignment problem in multi-agent learning. The agents make computational resource allocation decisions based on local observations to achieve the joint optimization objective of task delay and energy consumption.

The MDP model is defined as a quintuple $\left\{\mathcal{S},\mathcal{A},\mathcal{P},\mathcal{R},\gamma \right\}$, where the elements are defined as follows:

State Space S: At discrete time slot t, the local state $o_k\left(t\right)$ observed by a single agent k is: The number of tasks N in the current scheduling cycle, along with each task’s characteristics—specifically the input data size $d_t^k=\left\{d_{t,1}^k,d_{t,2}^k,\cdots ,d_{t,N}^k\right\}$, the CPU frequency $C_t^k=\left\{C_{t,1}^k,C_{t,2}^k,\cdots ,C_{t,N}^k\right\}$ required for processing each task, and the task’s group category; the resource status of the current edge node, including link bandwidth, remaining computational capacity, and other metrics. The global state is defined as the set of states of each agent: $S_t=\left\{o_1\left(t\right),o_2\left(t\right),\cdots ,o_K\left(t\right)\right\}$.

Action Space A: The action of an edge node agent is to allocate a certain proportion of computational resources to each task in its accessed task set: $A_t^k=\left\{{\varphi }_{t,1}^k,{\varphi }_{t,2}^k,\cdots ,{\varphi }_{t,N}^k\right\}$, where ${\varphi }_{t,i}^k\ge 0,{\displaystyle {\sum }_N{\varphi }_{t,i}^k=1}$. The raw output of the MADDPG actor (unbounded range) is first compressed to (−1, 1) via tanh activation, then mapped to the feasible range [0, 1] as the resource allocation ratio, the mapped values are further normalized by dividing by their sum, ensuring the total allocation proportion across all tasks equals 1.

Reward R: The reward function is designed to guide the agents towards the dual objective of minimizing both total task processing delay and system energy consumption. Specifically, the total task processing delay is the sum of offloaded task delay and local task delay across all devices; the system energy consumption aggregates the energy of offloaded tasks and local tasks across all devices. The reward is calculated episodically at the end of each time slot t. The reward calculation formula is as follows:

$$R_t=\lambda {\displaystyle \frac{1}{{\displaystyle \sum _{l=1}^M\omega T_i^{total}}}}+\left(1-\lambda \right){\displaystyle \frac{1}{{\displaystyle \sum _{l=1}^M{E}_i^{total}}}}$$

(18)

where $\lambda$ represents the weighting parameter for the delay and energy consumption dimensions, with a value range of [0, 1], serving as the adjustment factor for task rewards in reinforcement learning, and $\omega$ is a scaling factor that adjusts the results of capital delay and energy consumption to the same order of magnitude; M represents the total number of devices.

State Transition Function P: Represents the probability distribution of the system transitioning from the current state $s_t$ to the next state $s_{t+1}$. Due to the randomness inherent in task arrival, execution, and the environment dynamics are implicit in the simulator and treated as model-free, with P unknown but sampled via interaction.

Discount Factor $\gamma$: Used to weigh the importance of future rewards against immediate rewards, $\gamma \in [0,1)$.

3.2.2. MADDPG Algorithm Training

In highly dynamic environments, centralized reinforcement learning relies on global state collection, leading to high communication overhead. Fully distributed training, lacking global coordination mechanisms, is prone to policy oscillations or convergence difficulties. Moreover, existing methods largely neglect explicit optimization of training efficiency [16]. Therefore, this paper adopts a multi-agent deep deterministic policy gradient approach based on centralized training and distributed execution [17]. The MADDPG algorithm for policy training, as illustrated in Figure 2. The framework consists of K agents, each implemented based on the deep deterministic policy gradient (DDPG) algorithm. Each agent maintains its own actor network, which generates continuous actions—i.e., resource allocation decisions—based on the observed local state. The critic network takes as input the concatenated global state and the joint actions of all agents to estimate the Q-value, thereby guiding policy improvement. Experience tuples are stored in each agent’s replay buffer and are sampled for mini-batch gradient updates.

The MADDPG algorithm training process is shown in Algorithm 1. In each training episode, the system generates a set of devices with random trajectories and assigns mobility groups according to a set ratio. Each device determines whether to offload its task based on its trajectory and mobility characteristics. If conditions are met, the task is assigned to a designated edge node; otherwise, it is executed locally. Subsequently, for each agent: Agent k perceives the current state $s_t^k$ and outputs a resource allocation action $a_t^k$. The environment updates the task execution results accordingly, calculates the system total delay and energy consumption, and generates a global reward feedback R_t. The agent obtains a new state $s_{t+1}^k$. If the number of experiences stored in the replay buffer is less than B, the current $\left\{S_t^{all},A_t^{all},R_t,S_{t+1}^{all}\right\}$ is stored in the replay buffer. Otherwise, the earliest stored experience is replaced with $\left\{S_t^{all},A_t^{all},R_t,S_{t+1}^{all}\right\}$. Training is triggered after 50 initial exploration episodes (only experience collection in the first 50 episodes). From episode 51 onwards, gradient updates are executed in every environment step: a mini-batch of samples is sampled from each agent’s buffer for training, and the Critic network updates its parameters by minimizing the loss function:

$$L({\theta }_k^Q)=\mathbb{E}\left[{\left(R_t+\gamma Q_{k^{\prime }}\left(S_{t+1}^{all},A_{t+1}^{all}|{\theta }_k^{Q^{\prime }}\right)-Q_k\left(S_t^{\mathrm{all}},A_t^{all}|{\theta }_k^Q\right)\right)}^2\right]$$

(19)

where $Q_k^{\prime }\left(\cdot \right)$ is the action-state value function of the target network. When $L\left({\theta }_k^Q\right)$ is continuously differentiable, $L\left({\theta }_k^Q\right)$ can be adjusted according to the gradient of the loss function.

Subsequently, the Actor evaluation network parameters are updated by maximizing the policy objective function, as shown in Equation (20):

$$J\left({\theta }_k^{\mathrm{\mu }}\right)=E\left[Q_k\left(s_t^k,a_t^k\right)|A^k=\mathrm{\mu }\left(s_t^k\right)\right]$$

(20)

As the evaluation network parameters ${\theta }_k^{\mathrm{\mu }}$ and ${\theta }_k^Q$ are continuously updated, the target network parameters ${\theta }_k^{{\mathrm{\mu }}^{\prime }}$ and ${\theta }_k^{Q\prime }$ are updated using a soft update method:

$${\theta }_k^{{\mathrm{\mu }}^{\prime }}=\mathrm{\tau }{\theta }_k^{\mathrm{\mu }}+\left(1-\mathrm{\tau }\right){\theta }_k^{{\mathrm{\mu }}^{\prime }}$$

(21)

$${\theta }_k^{Q^{\prime }}=\mathrm{\tau }{\theta }_k^Q+\left(1-\mathrm{\tau }\right){\theta }_k^{Q^{\prime }}$$

(22)

where $\mathrm{\tau }$ is the soft update coefficient, $\mathrm{\tau }<<1$, a positive constant close to 0.

Algorithm 1: MADDPG-Based Resource Allocation

Input: number of devices, mobility group ratio, training episodes Max-Episode, Training step length per episode Training-Step, size of replay buffer B Output: optimal resource allocation policy for each edge server agent k 1: Initialize all agents’ Actor and Critic networks, and corresponding target networks 2: Initialize experience replay buffer Replay-Buffer for each agent 3: for episode = 1 to Max-Episode do 4:   Generate random vehicle trajectories trajs 5:   Assign mobility groups to vehicles based on Ratio 6:   for each vehicle m do 7:     According to mobility group[m] and traj[m], decide offloading: 8:     if offloading condition satisfied then 9:       Assign task to the designated edge server 10:     else 11:       Mark task as locally executed 12:   end for 13:   for step = 1 to Training-Step do 14:     for each agent i = 1 to K do//K equals the number of edge nodes 15:       Construct state $s_t^i$ 16:       Select action $a_t^i$ ← ${\pi }_t^i$ ($s_t^i$) + exploration_noise, where noise is sampled from an Ornstein-Uhlenbeck (OU) process 17:     end for 18:     Execute actions $A_t^{all}$, environment updates the task execution state 19:     Compute global reward Rt 20:     if replay buffer size < B then 21:       Store $\left\{S_t^{all},A_t^{all},R_t,S_{t+1}^{all}\right\}$ into each agent’s replay buffer 22     else 23:       Replace the earliest stored experience with $\left\{S_t^{all},A_t^{all},R_t,S_{t+1}^{all}\right\}$ 24:     end if 25:     if episode > 50 then 26:       Sample a mini-batch from replay buffer for training 27:       Update Actor and Critic using centralized training 28:       Soft update target networks 29:     end if 30:   end for 31: end for 32: Return the final learned policy for each agent

4. Experiment and Results

4.1. Experimental Environment Setup

The simulation experiments are implemented in Python 3.7, utilizing TensorFlow 1.14.0 as the deep learning framework to train the MADDPG-based multi-agent model. The key parameters for the simulation and training are summarized in

Table 1. Key simulation and training hyperparameters.

Category	Parameter	Value	Unit/Notes
Simulation Environment	Grid Size	3 × 3	/
	Edge Server Compute Capacity	8	GHz
	Local Device Compute Capacity	1	GHz
	Energy Consumption Coefficient	1 × 10−26	/
	Simulation Time Step	0.02	s
	Data Size	[0.3, 0.5]	MB
	Computational Intensity	40	CPU cycles/bit
	Uplink Bandwidth	20	MHz
	Transmit Power	0.5	W
	Channel Gain	100	Linear (corresponds to 20 dB)
	Noise Power	1 × 10−13	W
MADDPG Training	Number of Agents	9	/
	Training Episodes	400	/
	Replay Buffer Capacity	50,000	/
	Mini-batch Size	2000	/
	Actor Network Learning Rate	10−5	/
	Critic Network Learning Rate	10−4	/

. The simulation environment considers a 3 × 3 grid-based area, where each region is covered by an edge server with a computational capacity of 8 GHz. The local computing resource on the device side is set to 1 GHz, and the energy consumption coefficient is set as K = 1 × 10⁻²⁶. The wireless bandwidth is 20 MHz, the transmit power is 0.5 W, the channel gain is 20 dB, and the noise power is 1 × 10⁻¹³ W [12]. The experiment considers three types of terminal devices with typical mobility characteristics: high-mobility, medium-mobility, and low-mobility, in a ratio of 3:4:3. Each device follows a fixed-length trajectory of 3 steps, simulating its access to different regional servers. Each device generates one computation task, where both input and output data sizes are uniformly sampled between 0.3 MB and 0.5 MB, with a computational intensity of 40 CPU cycles per bit. In the offloading decision parameters, $\tau$ is set as the simulation time step, $\Delta t$ is set to 0.5 times the simulation time step, and $\Delta d$ represents the average task size. Or the MADDPG algorithm, the number of agents is set to 9, with 400 training episodes, each lasting 1 s, and a simulation time step of 0.02 s, matching the typical device mobility cycle and task execution duration to cover complete scheduling processes. The maximum capacity of the experience replay buffer is set to 50,000, this size stores sufficient diverse state-action samples to avoid overfitting while ensuring stable gradient updates, verified to balance convergence speed and optimization performance, and 2000 samples are drawn per training step. The learning rate of the Actor network is set to 10⁻⁵, and that of the Critic network is 10⁻⁴.

To validate the effectiveness of the proposed mobility-aware task offloading and network-computing resource optimization method, a series of comparative experiments were conducted using various baseline strategies. The selected methods cover a range of schemes from traditional static strategies to heuristic optimization approaches, specifically including: Local-Only Computing (LOC), all tasks are executed locally on the device without any offloading; Random Resource Allocation (RRA), All tasks are offloaded to edge servers, with computational resources randomly allocated among tasks; Task Data Size-based Resource Allocation (TDS-RA), Tasks are fully offloaded, and edge resources are distributed proportionally based on the size of each task’s input data. Multi-Objective Gray Wolf Optimization (MOGWO) [18], constructs a multi-objective optimization model with the goal of minimizing overall delay and load balancing. Through task priority classification, queue scheduling, and first-in-first-out processing strategies, the multi-objective gray wolf algorithm is used to solve the offloading decision problem. And finally, the Proposed Method (PM), which integrates a mobility-aware offloading decision framework with a multi-agent deep reinforcement learning architecture to achieve dynamic and fine-grained resource allocation under varying mobility patterns.

4.2. Training Results

Figure 3 depicts the evolution of the system reward throughout the training process. The corresponding experimental setup features 50 devices, a reward weight set to λ = 0.5, an episode length of 1 s, 50 discrete time steps and a total of 400 training episodes. The plot presents the mean reward curve aggregated across 5 independent runs. Each of these runs is initialized with a distinct random seed. A shaded region surrounds the mean curve in the plot. It can be observed that the reward curve initially exhibits a declining trend, paired with a relatively wide shaded region in the early episodes, followed by a gradual increase and eventual stabilization. This is mainly attributed to the instability during the exploration phase and the non-smooth nature of the reward structure, both of which are reflected in the broad spread of the shaded region early in training. In the early stages of training, the agents have not yet learned effective task offloading and resource allocation strategies, and their actions are relatively random. This results in significant fluctuations in overall system delay and energy consumption, leading to a drop in the computed system reward. These random actions drive inconsistent performance across the 5 independent runs, which explains the wide standard deviation (and thus broad shaded region) observed in the first 200 episodes. Moreover, when the reward function adopts a weighted reciprocal form, it becomes difficult for the initial policy to optimize both objectives simultaneously. Efforts to reduce one metric may cause significant degradation in the other, further amplifying reward volatility. This dual-objective trade-off exacerbates the variability across runs, widening the shaded region even further in the early training stage. As training progresses, the agents gradually accumulate experience through continuous interaction and feedback from the environment. Their policies converge and become more capable of effectively balancing delay and energy consumption. As a result, the reward values steadily increase and eventually stabilize. The final stabilized reward (last 100 episodes) has a mean of 272.40 and a variance of 10.81, confirming low post-convergence variability. This trend demonstrates that the proposed training mechanism exhibits good convergence and can effectively guide agents to learn robust and efficient scheduling strategies under dynamic and complex conditions.

4.3. Comparative Experiment

4.3.1. Impact of Different Device Scales on Total Task Processing Delay

Figure 4 illustrates the performance of different methods in terms of total task processing delay under varying device scales. The results presented are the mean values over 100 independent Monte Carlo runs. As the number of devices increases, the overall system load becomes heavier and resource contention intensifies, leading to a noticeable rise in delay across all methods. Among them, the baseline strategies LOC and RRA exhibit the most significant increase. Notably, RRA reaches a total delay of 1.0085 s when the number of devices reaches 60, significantly higher than the other methods. This result highlights the inefficiency of resource utilization in the absence of intelligent scheduling mechanisms. TDS-RA, a simple strategy that allocates resources proportional to task data size, performs relatively well under small and medium scales. However, its performance deteriorates as task intensity increases, falling behind the optimization-based approaches. MOGWO, which employs a heuristic swarm intelligence algorithm, demonstrates better resource coordination and achieves lower delays than the baseline methods. The proposed method, PM, consistently achieves the lowest total delay across all device scales. In the scenario with 60 devices, PM records a total delay of 0.5755 s, which is 42.9% lower than LOC’s 0.9599 s, and 24.4% and 19.0% lower than TDS-RA’s 0.7617 s and MOGWO’s 0.7105 s, respectively. This significant delay reduction is primarily driven by the MADDPG-based dynamic resource allocation mechanism in PM: MADDPG adaptively adjusts resource distribution ratios based on real-time task attributes and edge load conditions and dynamically increasing computing resource quotas for compute-intensive tasks to accelerate processing. Meanwhile, the mobility-aware heuristic offloading pre-filters infeasible task-edge mappings, enabling MADDPG to focus on core resource optimization rather than filtering invalid options, thus achieving more efficient resource utilization and lower overall delay. These results indicate that the proposed multi-agent joint optimization strategy exhibits stronger adaptability and efficiency in handling complex and dynamic workloads.

4.3.2. Impact of Different Device Scales on Energy Consumption

Figure 5 shows the total energy consumption results for task processing using different methods across various device scales. The results indicate that as the number of devices increases, the total energy consumption of system tasks shows an upward trend. Since local processing energy consumption is directly related to task data volume and local computing power, the LOC method achieves an energy consumption of 0.24 J when the number of devices is 60, significantly higher than other methods. In contrast, the remaining methods primarily rely on edge offloading, with energy consumption calculations involving only the transmission energy consumption during the task upload process, resulting in significantly lower overall energy consumption levels. Notably, RRA, TDS-RA, and PM all adopt the heuristic offloading strategy proposed in this paper, so their energy consumption values are similar across different device scales and remain at a low level. MOGWO improves resource utilization efficiency through a swarm search strategy, achieving an energy consumption of 0.0425 J When the number of devices is 60, PM’s total energy consumption is 0.044 J, which is significantly lower than LOC’s 0.24 J, representing an 81.7% reduction in energy usage. In addition, PM performs similarly to TDS-RA’s 0.0472 J and RRA ’s 0.045 J, and its overall energy consumption is also comparable to the heuristic-based MOGWO method ’s 0.0425 J. Thus, the primary energy-related advantage of PM is not a reduction in absolute consumption compared to other offloading methods, but rather its ability to achieve significantly lower latency while maintaining comparable transmission energy efficiency.

The energy consumption under varying mobility group ratios further substantiates the argument regarding energy-model dominance. As detailed in Figure 6 the total energy of offloading-based methods remains tightly clustered across all tested distributions (e.g., 0.0364–0.0488 J for PM, versus 0.0367–0.0485 J for RRA). This consistent parity, regardless of whether the scenario is balanced (3:4:3), low-mobility dominated (1:3:6), or high-mobility dominated (6:3:1), confirms that the near-equivalence in energy consumption between PM and other offloading baselines is not an artifact of a single parameter setting, but a robust outcome of the shared underlying energy model where uplink transmission is the primary cost. Crucially, this result reinforces our primary claim: the distinct advantage of PM lies not in reducing absolute energy consumption below that of simple offloading strategies, but in its ability to achieve significantly lower task processing delays, as demonstrated in Section 4.3.1, while maintaining comparable energy efficiency. The stability of this energy-performance trade-off across diverse mobility patterns highlights the adaptability and reliability of our integrated offloading and scheduling framework.

4.3.3. Impact of Energy-Delay Trade-Off Weights on System Reward

Figure 7 shows the comparison results of various methods in terms of system reward metrics under different reward weight parameters λ, with the number of devices set to 50. As λ increases gradually from 0.2 to 0.8, the weight of task processing latency in the optimization objective continues to rise. The energy values presented are the mean over 100 independent Monte Carlo runs. Except for RRA, the system reward values of most methods show an overall upward trend. However, the RRA method, due to the instability caused by random resource allocation, is prone to significant increases in task processing latency, leading to a decrease in system reward as λ increases. Under λ = 0.2, the system rewards of methods such as LOC and RRA are relatively low, with LOC reaching only 0.4465, indicating poor performance in a target function dominated by energy consumption. TDS-RA and MOGWO consistently maintain relatively high reward values, indicating their stability and adaptability. However, compared to others, the PM method achieves the highest system reward values under all weight settings, demonstrating stronger robustness and comprehensive optimization capabilities. To elucidate the physical performance underpinning these rewards, the total delay and total energy at the representative weighting of λ = 0.6 are: LOC (0.8111 s, 0.2001 J), RRA (0.8997 s, 0.0385 J), TDS-RA (0.5951 s, 0.0407 J), MOGWO (0.5621 s, 0.0368 J), and PM (0.4896 s, 0.038 J). This demonstrates that PM’s reward advantage primarily stems from achieving the lowest delay while maintaining energy consumption on par with other offloading baselines. Especially when λ = 0.8, it reaches 1.9849, significantly outperforming TDS-RA’s 1.6719 and MOGWO’s 1.7856, with improvements of 18.7% and 11.16%, respectively. This superiority originates from the dynamic adaptation capability of MADDPG in PM, as the multi-agent reinforcement learning system continuously learns shifts in the reward function’s priorities and adjusts resource allocation strategies in real time, with this adaptive performance made possible by the inherent synergy between heuristic offloading and MADDPG: heuristic offloading ensures the feasibility of task-edge mappings, while MADDPG specializes in dynamic trade-off optimization between delay and energy consumption, and such real-time, priority-aware adjustment is fundamentally unattainable for static heuristic methods, thus allowing PM to sustain optimal balance across all weight scenarios. This indicates that it maintains a good balance in the energy consumption dimension while also demonstrating a clear advantage in delay optimization. The stability of PM’s superiority indicates that the normalization of delay and energy terms is effective, preventing either term from arbitrarily dominating the optimization process.

4.3.4. Impact of Different Mobility Group Ratios on System Reward

Figure 8 illustrates the system rewards of various methods under different mobile device group ratios, where the reward weight λ is set to 0.5 and the number of devices is 50.

Table 2. Total delay and total energy for each method at each mobility ratio.

Mobility Ratio	Method	Total Delay (s)	Total Energy (J)
3:4:3	LOC	0.8111	0.2001
	RRA	0.8997	0.0385
	TDS-RA	0.5951	0.0407
	MOGWO	0.5621	0.0368
	PM	0.4896	0.038
1:3:6	LOC	0.8044	0.1964
	RRA	0.8957	0.0439
	TDS-RA	0.6146	0.043
	MOGWO	0.5858	0.03999
	PM	0.5139	0.0435
entry 3	LOC	0.8006	0.199
	RRA	1.1772	0.0485
	TDS-RA	0.6621	0.0478
	MOGWO	0.6041	0.0446
	PM	0.5332	0.0488
entry 4	LOC	0.8206	0.2051
	RRA	0.8611	0.0367
	TDS-RA	0.6307	0.037
	MOGWO	0.5816	0.0349
	PM	0.4962	0.0364

presents the corresponding total delay and total energy for each method under different mobility group ratios, providing the physical performance basis for the reward comparison in Figure 8, and the results presented are the mean values over 100 independent Monte Carlo runs. In this analysis, the MADDPG agents are trained on a mixture of episodes with randomly generated mobility group ratios. This exposes the policy to a diverse range of mobility patterns during training. For evaluation, policies are then assessed under fixed, predetermined mobility ratios. The results indicate that in scenarios dominated by either high or low mobility ratios, the system rewards of most methods show a declining trend. This is because, compared to other mobile devices, high-mobility devices may introduce additional transmission latency if edge processing is not properly handled, thereby reducing system rewards; conversely, when the proportion of low-mobility devices increases, the proportion of local computation tasks may rise, and although communication overhead decreases, the higher energy consumption of local computation also leads to an increase in system rewards. Methods such as RRA and TDS-RA exhibit strong sensitivity to changes in mobility distribution, highlighting their limitations in adapting to mobility-aware resource allocation requirements. Notably, MOGWO—despite its heuristic optimization logic—also struggles to maintain stable performance in extreme mobility scenarios, as its pre-calibrated resource coordination rules are designed for balanced mobility distributions and lack the flexibility to adjust to sudden surges in high-mobility or low-mobility tasks. The PM method consistently achieves the highest system reward values across all tested mobility distributions. In the 3:4:3 scenario with a relatively balanced mobility distribution, PM’s system reward is 1.8984, which is 14.41% and 5.74% higher than TDS-RA and MOGWO, respectively. This advantage becomes more pronounced when mobility shifts toward extremely high or low groups, at which point static or heuristic baselines like LOC and RRA cannot effectively adapt. Moreover, as Table 2 confirms, PM achieves this superior reward by consistently delivering the lowest total delay across all distributions (e.g., 0.4896 s at 3:4:3, 0.5332 s at 6:3:1) while maintaining total energy consumption comparable to other offloading baselines. This demonstrates its effective trade-off management. This superiority stems from the targeted synergy of PM’s mobility-aware framework, overall, PM dynamically adapts to different mobility scenarios through its multi-agent joint optimization strategy, ensuring the stability and robustness of system performance.

5. Conclusions

This paper proposes a mobility group-driven task offloading and resource allocation method for MEC scenarios, addressing joint optimization of task offloading and computation resource scheduling across edge nodes. Compared to baseline and state-of-the-art heuristic schemes, our method delivers an average task processing latency reduction of 19.0% at the largest device scale, while maintaining comparable energy efficiency. And it should be noted that our energy evaluation primarily reflects device-side uplink transmission energy, with edge-side computation energy neglected. Furthermore, the latency reduction becomes more pronounced with increasing device counts or in scenarios with higher proportions of highly mobile devices. Future work will investigate partial offloading granularity, which involves modeling tasks as partitionable units, introducing additional decision variables for data segmentation, and revising offloading feasibility tests under mobility constraints to manage finer-grained workload distribution. Furthermore, validating the proposed framework with real-world mobility datasets and more sophisticated mobility models will be pursued to strengthen its practical applicability in specific deployment scenarios.