UAV-Enabled Maritime IoT D2D Task Offloading: A Potential Game-Accelerated Framework

Abstract

Maritime Internet of Things (IoT) with unmanned surface vessels (USVs) faces tight onboard computing and sparse wireless links. Compute-intensive vision and sensing workloads often exceed latency budgets, which undermines timely decisions. In this paper, we propose a novel distributed computation offloading framework for maritime IoT scenarios. By leveraging the limited computational resources of USVs within a device-to-device (D2D)-assisted edge network and the mobility advantages of UAV-assisted edge computing, we design a breadth-first search (BFS)-based distributed computation offloading game. Building upon this, we formulate a global latency minimization problem that jointly optimizes UAV hovering coordinates and arrival times. This problem is solved by decomposing it into subproblems addressed via a joint Alternating Direction Method of Multipliers (ADMM) and Successive Convex Approximation (SCA) approach, effectively reducing the time between UAV arrivals and hovering coordinates. Extensive simulations verify the effectiveness of our framework, demonstrating up to a 49.6% latency reduction compared with traditional offloading schemes.

1. Introduction

Shipping occupies a crucial position within the national transportation systems of various countries, delivering significant economic and social benefits [1]. With the rapid development of intelligent shipping and digitalization, maritime IoT systems have recently emerged as a key enabler for enabling real-time vessel monitoring, environmental sensing, and autonomous navigation [2,3,4]. However, unlike terrestrial IoT, maritime IoT networks face unique challenges, including sparse wireless connectivity, harsh propagation environments, and the limited onboard computation capacity of USVs [5,6]. At the same time, computation-intensive tasks such as vision-based navigation, image recognition, and safety-critical decision-making involve processing substantial volumes of raw data, and the computational latency incurred may exceed the permissible thresholds [7]. These factors highlight the necessity of task offloading networks, where USVs can offload workloads to nearby assisting vessels or UAV-assisted edge nodes to ensure efficient and timely task execution.

Mobile edge computing (MEC), built upon 5G/6G wireless communication technologies, offers a promising solution [8]. MEC addresses this challenge by pushing abundant computational resources from cloud servers to the network edge, thereby meeting the escalating computational and communication demands of USVs. However, constrained by the inherent limitations of the hardware capabilities of MEC platforms themselves, MEC systems currently cannot provide on-demand, ubiquitous temporary services within hotspot areas. Compared to traditional MEC, UAV-assisted MEC offers the capability to rapidly establish edge computing nodes in areas lacking fixed infrastructure, thereby overcoming the spatial constraints inherent in conventional edge computing deployments. Furthermore, UAVs can dynamically adjust their positions in the airspace, enabling broader coverage and enhanced proximity to task locations, which significantly improves computational efficiency and service quality.

The inherent dynamic resource scheduling capability of UAV-assisted systems allows for optimization of the computational resource distribution based on task demands, thereby enhancing system adaptability and resilience. In [9], the authors integrate bandwidth allocation and UAV positioning to minimize the task delay. In [10], the authors optimize the task offloading ratio by establishing a two-tier architecture consisting of users and UAVs. In [11], the authors formulate a UAV energy minimization problem by comprehensively considering the USVs’ task execution methods, UAV trajectories, UAV arrival times, and UAV hovering coordinates. In [12], the authors proposed approach involves a USV-UAV cooperative platform where UAVs dynamically position themselves and land on USVs with low latency to perform tasks. Another proposal introduces a UAV-assisted maritime IoT network, enabling USVs to offload computationally intensive tasks to UAVs [13]. Although UAV-assisted MEC pushes computational resources from the remote cloud towards the network edge, resource contention arises when multiple USVs simultaneously require task offloading to the edge cloud. This competition for resources directly impacts user experience.

D2D communication, enabling direct data transmission between adjacent users, has garnered significant academic interest for its potential application as an auxiliary approach to task offloading. In [14], the authors discussed the potential of D2D communication for task offloading, aiming to maximize the number of users capable of completing computational tasks through optimized D2D link establishment. However, most existing research suffers from two common limitations. Firstly, there is a prevalent assumption that stable D2D communication links are pre-established. In practice, constrained by factors such as physical distance and social ties, certain mobile users struggle to establish stable D2D links. This foundational assumption deviates from real-world scenarios, necessitating in-depth investigation into effective D2D pairing mechanisms. Secondly, existing research has predominantly focused on individual optimization dimensions, such as channel allocation, D2D pairing, and task offloading modes, ignoring the strong coupling relationships among these three aspects.

Game theory provides an effective theoretical foundation for multi-agent resource allocation, incentive mechanism design, and system-wide collaborative optimization. The construction of suitable game-theoretic models enables the capture of the evolution of each participant’s strategy under mutual influence, thereby helping the system maximize overall utility or payoff under limited resources. In [15,16], game theory is used to manage communication resources. By modeling the channel selection problem as an exact potential game (EPG), a balance between delay and energy consumption is achieved. In [17], a stochastic congestion game based on an EPG was proposed to investigate the load balancing issue in MEC, aiming to minimize the delay of task execution. In [18], an EPG is used for federated split learning. On the basis of BFS, distributed machine learning with low latency costs is realized through an EPG and resource optimization. In [19], the authors model the decision process in task offloading and resource allocation as a potential game, which achieves efficient, distributed task offloading and resource allocation with a convergence guarantee in a large-scale U-MEC network.

To integrate the aforementioned technological advantages while ensuring alignment with practical shipping application scenarios, we design an accelerated D2D distributed computing offloading framework based on EPG theory, called ADTO. This framework aims to achieve efficient task execution by leveraging the high-mobility and cluster head (CH) [20,21] characteristics of UAVs in UAV-assisted edge networks and the constrained computational resources in D2D-assisted edge networks [22]. Specifically, the proposed framework employs potential game theory to model the client clustering optimization problem as a distributed computation offloading game. This approach aims to maximize the overall offloading efficiency while simultaneously addressing communication limitations and enhancing resource utilization. Building upon this, we formulate a global latency minimization problem that jointly optimizes UAV hovering coordinates and arrival times. This problem is solved by decomposing it into subproblems addressed via a joint ADMM and SCA approach, effectively reducing the time between UAV arrivals and hovering coordinates. The main contributions of this paper can be outlined as follows:

• This paper introduces a novel edge computing architecture in maritime IoT systems to fully utilize the advantage of UAV-assisted edge computing (with UAVs serving as dynamic CHs) and D2D-assisted edge networks (with USVs cooperating in clusters), aiming to provide USVs with low-latency and reliable computing services.
• A global task offloading latency minimization model is constructed by jointly optimizing D2D link selection, UAV arrival time, and hovering coordinates. To reduce computational complexity, a heuristic solution is proposed to decompose the proposed problem into multiple subproblems and design suboptimal solutions, thereby reducing the optimization cost associated with long-term repeated optimization.
• The simulation results under simulated realistic scenarios and various system settings demonstrate that our proposed framework can effectively reduce the overall system delay while making full use of the available communication and computing resources.

The rest of this paper is organized as follows: Section 2 mathematically models the global delay issue and presents an overview of the proposed ADTO algorithm. Section 3 presents a solution to the problem mentioned in Section 2. Section 4 presents the results of the experiment. Section 5 offers a conclusion to and discussion on this essay.

2. System Overview and Problem Formulation

2.1. System Model

The UAV-assisted D2D edge network under consideration comprises multiple distributed USVs possessing heterogeneous computational and communication resources, multiple UAVs equipped with identical communication resources, and a single terrestrial base station (TBS) acting as an edge server with abundant computational resources. Furthermore, the TBS is equipped with a global controller capable of perceiving USV positions, UAV computational and energy states, and a priori Channel State Information (CSI). Each USV can establish D2D links with neighboring USVs. However, due to constraints imposed by geographical factors and hardware limitations, USVs cannot establish direct communication links with the TBS; consequently, UAVs act as communication relays between the TBS and USVs by establishing wireless cellular links with USVs and forming Line of Sight (LoS) connections with the TBS. Specifically, the distributed USVs are categorized into two types: task clients (TCs) and assisting clients (ACs). There are L TCs capable of participating in task offloading by contributing their local tasks, represented as $\mathcal{L}=\{1,2,\dots ,L\}$, and C ACs located near TCs that can assist TCs in task completion by providing spare computational resources, represented as $\mathcal{C}=\{1,2,\dots ,C\}$. Therefore, each TC can form a collaborative cluster with multiple ACs via D2D communication to perform task offloading, thereby overcoming bottlenecks caused by limited computational or communication resources, with the L TCs clustered into L collaborative clusters. To simplify the analysis, we assume each cluster contains exactly one TC. Without loss of generality, cluster $l\in L$ is associated with a total of $n_l$ ACs, denoted by ${\mathcal{N}}_l=\{0,1,\dots ,n_l\}$. When ${\mathcal{N}}_l=0$, it denotes the index of the TBS. Within a three-dimensional Cartesian coordinate system, UAVs are assumed to fly and hover at a fixed altitude H; when UAV l serves USV i located at coordinates $q_i=(x_i,y_i,0)$, it has a corresponding hovering coordinate $q_l=(x_l,y_l,H)$. To simplify the analysis and prevent resource sharing conflicts among ACs, we assume each AC can join at most one cluster. Let the binary variable $v_l$ indicate the association status between AC l and cluster l, where $V_l=1$ if AC l is selected by cluster l, and $V_l=0$ otherwise. Finally, we can derive

$$\sum _{l=1}^L{V}_{l,c}\le 1,\forall c\in \mathcal{C}.$$

(1)

The proposed method aims to collaboratively complete tasks by splitting a task with a linear topology into multiple subtasks within each learning cluster and assigning these subtasks to cluster members based on their computational capabilities. For simplicity, the tasks considered in this paper can be divided into up to the total number of clients within a cluster. Each task contains D segmentable layers, denoted as $D=\{1,2,\dots ,D\}$. Let the binary variable $z_{l,d}$ indicate the splitter selection status for segmentable layer $d\in D$, where $z_{l,d}=1$ signifies that segmentation layer d is selected, and $z_{l,d}=0$ otherwise. Therefore, the task allocation corresponding to cluster l can be denoted as the vector $z_l=\{z_{l,1},z_{l,2},\dots ,z_{l,D}\}$. For simplicity, each cluster member is restricted to forwarding its model execution output solely to its immediate successor within the chain. Therefore, the USV clustering and task assignment strategies should adhere to the following constraints:

$$\sum _{d=1}^D{z}_{l,d}⩽D,\forall l\in \mathcal{L}.$$

(2)

To facilitate further analysis of this scenario, we introduce the definitions as follows.

Definition 1

(Connected graph). For any graph $\mathcal{G}=(V,E)$, let $\left(V\right)$ denote the set of nodes, representing the set of USVs, and let $\left(E\right)$ denote the set of edges, representing the wireless communication links established between these nodes. If any two distinct vertices in V are connected, the graph $\mathcal{G}$ is referred to as a connected graph.

2.2. Problem Formulation

Based on the discussion in the previous section, the latency incurred by the distributed task offloading framework proposed in this paper comprises two components: intra-cluster task execution delay and UAV flight delay. This subsection provides a detailed analysis of the latency contributions from each component.

Global Task Distribution: When the computation tasks commence, the TBS broadcasts the global task to the CH of each cluster. The downlink data transfer rate from TBS to CH l in a cluster can be expressed as

$$r_l^{DL}=B_l{log}_2\left(1+{\displaystyle \frac{p{h}_{l,0}}{{\sigma }^2{d}_{0,l}^2}}\right),$$

(3)

where $B_l(0<B_l)$ denotes the radio bandwidth allocated by the TBS to the UAV serving as the CH, p denotes the transmission power of the TBS, ${\sigma }^2$ represents the noise variance, $d_{0,l}=\sqrt{\Vert q_l-q_0{\Vert }^2+H^2}$ signifies the distance between the TBS and the UAV l hovering coordinate, p is the transmit power of the TBS, and $h_{l.0}$ represents the channel power gain between the UAV and the TBS. The transmission delay from the TBS to the CH of each cluster can be expressed as

$$t_l^{DL}={\displaystyle \frac{w_l}{R_l^{DL}}},$$

(4)

where $w_l$ represents the data size of a global task, which is assumed to be identical for all clusters.

Intra-Cluster Task Processing: Intra-cluster task execution consists of three primary sub-phases: intra-cluster task distribution, the task execution process, and task collection by the CH. For analytical convenience, we discuss the process using cluster l as a representative example.

• Intra-Cluster Task Distribution: Within the cluster, the designated UAV serving as the CH acts as the communication relay. USVs access the CH via a wireless cellular link. Consequently, the intra-cluster task distribution latency from the CH to USV i can be expressed as

  $$t_{a,i}={\displaystyle \frac{w_{l,i}}{r_i}},$$

  (5)

  where $r_i=B{log}_2\left(1+{\displaystyle \frac{p{h}_{l,0}}{{\sigma }^2(\Vert q_i-q_l{\Vert }^2+H^2)}}\right)$ represents the data transmission rate between the CH and USV i, measured in bits per second, and $w_{l,i}$ denotes the size of the task processed by USV i.
• The Task Execution Process: Once intra-cluster task allocation is completed, USV i immediately executes its assigned subtask. Therefore, the task execution delay of USV i can be expressed as

  $$t_{l,i}^{comp}={\displaystyle \frac{C_i{w}_{l,i}}{f_i}},$$

  (6)

  where $C_i$ represents the number of CPU cycles required to process a data sample, and $f_i$ denotes the CPU computation frequency of USV i.
  Let $w_{l,i}^{id}$ denote the intermediate data forwarded from USV i to USV j after local computation. The corresponding communication delay is

  $$t_{l,i}^{comm}={\displaystyle \frac{w_{l,i}^{id}}{r_{i,j}}},$$

  (7)

  where $r_{i,j}$ denotes the D2D data transmission rate between USV i and USV j.
• Task Collection by the CH: Upon the completion of execution, the CH instructs the USVs within the cluster to return their processed segments for aggregation. Since the task collection process is almost identical to the intra-cluster task distribution process, the delay of model collection $t_{c,i}$ is equal to $t_{a,i}$.
  Finally, the total intra-cluster processing delay can be calculated as

  $$t_{l,i}^{TTE}=2t_{a,i}+t^{TE},$$

  (8)

  where $t^{TE}=t_{l,i}^{comm}+t_{l,i}^{comp}$.

Local Subtask Uploading: Upon task completion, the CH uploads the aggregated result to the TBS. The transmission rate from the CH to the TBS can be calculated as

$$r_l^{UL}=B_l{log}_2\left(1+{\displaystyle \frac{p_l{h}_l}{{\sigma }^2{d}_{l,0}^2}}\right),$$

(9)

where $p_l$ denotes the transmission power of the CH. The corresponding task upload delay from the CH to the TBS can be expressed as

$$t_l^{UL}={\displaystyle \frac{w_l}{r_l^{UL}}}.$$

(10)

Finally, under the USV clustering strategy and task allocation strategy, the overall delay of the cluster can be expressed as

$$T_l=t_l^{DL}+t_{l,i}^{TTE}+t_l^{UL}.$$

(11)

The UAV Time Cost Model: We assume the propulsion power of each UAV is independent of external factors and solely dependent on its flight velocity $v_l$. The time consumed for a UAV to travel between any two hovering coordinates associated with USVs can be derived as

$$t_{l(i,j)}^f={\displaystyle \frac{\Vert q_j-q_i\Vert }{v_l}}.$$

(12)

Let the binary variable ${\rho }_{l(i,j)}$ indicate whether UAV l travels from hovering coordinate i to hovering coordinate j, where ${\rho }_{l(i,j)}=1$ signifies that UAV l flies from point i to point j, and ${\rho }_{l(i,j)}=1$ otherwise. When $i=0$ or $j=0$, it denotes the index of the TBS. Given that UAV l must depart from the TBS and ultimately return to it, we derive the following constraints:

$$\sum _{i=0}^{n_l}{\rho }_{l(0,i)}=\sum _{g=0}^{n_l}{\rho }_{l(j,0)}=1,\forall l\in \mathcal{L}.$$

(13)

Due to the sequential dependency of D2D computation offloading subtasks, UAV l can serve USV j if and only if it has successfully completed service to USV i. Thus, the constraint can be derived as follows:

$$\sum _{i=0}^{n_l}{\rho }_{l(i,j)}=\sum _{g=0}^{n_l}{\rho }_{l(j,g)}=1,\forall l\in \mathcal{L},g\ne i,j.$$

(14)

It is noteworthy that UAV l must remain in a hovering state until USV i completes the execution of its allocated subtask. This requirement leads to the following constraint

$$t_{l,i}^a+T_l+t_{l(i,j)}^f\le t_{l,j}^a,i,j\in {\mathcal{N}}_l,l\in \mathcal{L},$$

(15)

where $t_{l,i}^a$ is the time when UAV l reaches the hovering coordinates of USV i.

Subject to the maximum battery capacity $E_l^{max}$ of the UAV, let $T_l^{max}$ denote its maximum allowable service time. This imposes the following constraint:

$$\sum _{i=0}^{n_l}\sum _{j=0}^{n_l}{\rho }_{l(i,j)}(T_l+t_{l(i,j)}^f)\le t_l^{max}.$$

(16)

Considering the limited computational resources of the USVs and the limited communication resources of the TBS, this paper globally optimizes the USV clustering scheme, the task allocation strategy, and the arrival time and hovering coordinates of each UAV to minimize the total delay cost of each TC. The problem can be formulated as a total latency cost minimization problem, with the objective and constraints described as follows:

$$\begin{array}{cc}\hfill \underset{\{n_l,s_l,t,q_l\}}{min}:& T=\sum _{l=1}^L\sum _{i=0}^{n_l}\sum _{j=0}^{n_l}{\rho }_{l(i,j)}(T_l+t_{l(i,j)}^f)\hfill \\ \hfill \mathrm{s}.\mathrm{t}.& \left(1\right),\left(2\right),\left(13\right)–\left(16\right).\hfill \end{array}$$

(17)

3. Problem Decomposition and Proposed Method

The problem formulated in the preceding section involves three tightly coupled subproblems: the USV clustering strategy, the task allocation strategy, UAV arrival time optimization, and hovering coordinate optimization. For instance, the task allocation strategy inherently depends on the established client clustering strategy. This tight coupling results in the exponential complexity evident in (17), substantially increasing the computational costs. To address this challenge, as shown in Figure 1, we first propose a client clustering game based on BFS and EPG theory. Subsequently, we efficiently optimize the task allocation strategy and UAV hovering coordinate problem utilizing a greedy algorithm combined with the ADMM. When the TBS receives the current environment state as a global controller, the current optimal UAV flight trajectory and the optimal D2D offloading decision are calculated by running the proposed scheme and fed back to the USV and UAV in the environment.

3.1. BFS-Based Distributed Game Clustering

Each learning cluster seeks a local strategy that minimizes its own latency. Accordingly, the client-clustering task is modeled as a multi-player game in which L clusters serve as players. The strategy of cluster l is denoted by $s_l$, with its feasible strategy set represented by $S_l$. Here, we generate the game’s strategy space by applying BFS. Specifically, as depicted in Figure 2, starting from the origin TC, BFS prioritizes exploring all neighboring ACs before proceeding to explore ACs at the next level further away, proceeding level by level until the target is found or all reachable ACs have been traversed.

We assume that communication state variations within each time window are relatively stable. Under this distributed game framework, each agent considers not only its own latency but also the impact of its actions on the overall network state. Specifically, for each TC, a clustering strategy $s_l$ can be determined. The joint strategy of L clusters can then be represented as $s=\{s_1,s_2,\dots ,s_L\}$. Notably, $s_{-l}$ denotes the clustering strategies of all clusters except cluster l. Within this context, we employ marginal utility theory [23,24] to evaluate the overall impact of a strategy. Furthermore, aligning with the optimization objective in (17), the utility function for a cluster is defined as

$$A_l(s_l,s_{-l})=-{\varphi }_l(s_l,s_{-l})+\sum _{j\ne l}[(-{\varphi }_j(s_j,s_{-j})+{\varphi }_j(s_j,s_{-j\setminus l})],$$

(18)

where $-{\varphi }_j(s_j,s_{-j\setminus l})$ denotes the utility of cluster j under the condition that cluster l does not take any action. Therefore, ${\sum }_{j\ne l}[(-{\varphi }_j(s_j,s_{-j})+{\varphi }_j(s_j,s_{-j\setminus l})]$ signifies the change in the aggregate utility of the other clusters induced by the strategic action of cluster l.

The objective of the distributed clustering game is to minimize cluster conflicts and maximize each cluster’s utility, which critically depends on the existence of a Nash Equilibrium (NE) within this distributed clustering game framework.

Definition 2

(Nash Equilibrium [25]). A joint strategy $s^{*}=\{s_1^{*},\dots ,s_L^{*}\}$ is called an NE of the formulated game if and only if, holding all other clusters’ strategies fixed, no single cluster can improve its utility by unilaterally altering its own strategy. In other words,

$$A_l(s_l^{*},s_{-l}^{*})\ge A_l(s_l,s_{-l}^{*}),\forall l\in \mathcal{L},s_l\in S_l.$$

(19)

To ensure that the proposed game-based method possesses an NE and achieves convergence, we introduce the concept of the EPG and further explore the existence of an NE under its theoretical framework.

Definition 3

(EPG [26]). If an exact potential function $\psi (s_l,s_{-l})$ exists that satisfies the following conditions, then the game is called an EPG:

$$A_l(s_l^{\prime },s_{-l})-A_l(s_l,s_{-l})=\psi (s_l^{\prime },s_{-l})-\psi (s_l,s_{-l}),$$

(20)

where $s_l^{\prime },s_{-l}\in S_l$.

Theorem 1. 

A distributed USV clustering game is an EPG if and only if at least one pure-strategy NE point exists.

Proof. 

Based on the optimization problem, we can define an exact potential function that satisfies the following conditions:

$$\mu (s_l,s_{-l})=\sum _{l=1}^L-{\psi }_l(s_l,s_{-l}).$$

(21)

The potential function is essentially the sum of all groups’ payoffs across the entire network. Suppose that the decision of group l changes from $s_l$ to $s_l^{\prime }$. The change in its utility function is presented in (22).

$$\begin{array}{cc}\hfill & A_l(s_l^{\prime },s_{-l})-A_l(s_l,s_{-l})\hfill \\ \hfill & =-{\varphi }_l(s_l^{\prime },s_{-l})+\sum _{j\ne l}(-{\varphi }_j(s_j,s_{-j}^{\prime })+{\varphi }_j(s_j,s_{-j\setminus l}^{\prime }))-\left(-{\varphi }_l(s_l,s_{-l})+\sum _{j\ne l}(-{\varphi }_j(s_j,s_{-j})+{\varphi }_j(s_j,s_{-j\setminus l}))\right)\hfill \\ \hfill & =-{\varphi }_l(s_l^{\prime },s_{-l})+{\varphi }_l(s_l,s_{-l})+\sum _{j\ne l}(-{\varphi }_j(s_j,s_{-j}^{\prime })+{\varphi }_j(s_j,s_{-j}))-\sum _{j\ne l}(-{\varphi }_j(s_j,s_{-j\setminus l})+{\varphi }_j(s_j,s_{-j\setminus l}^{\prime }))\hfill \end{array}$$

(22)

Although the behavior of cluster l has changed, if cluster l abandons its decision while other clusters maintain their own decisions, the absence of cluster l’s action would have the same impact on the other clusters (i.e., ${\psi }_j(s_j,s_{-j\setminus l})={\psi }_j(s_j,s_{-j\setminus l}^{\prime })$). Thus, we can ignore the third term in (18) and reorganize the above expression, as shown in (23).

$$\begin{array}{cc}\hfill A_l(s_l^{\prime },s_{-l})-A_l(s_l,s_{-l})& =-{\varphi }_l(s_l^{\prime },s_{-l})+{\varphi }_l(s_l,s_{-l})+\sum _{j\ne l}(-{\varphi }_j(s_j,s_{-j}^{\prime })+{\varphi }_j(s_j,s_{-j}))\hfill \\ \hfill & =-{\varphi }_l(s_l^{\prime },s_{-l})+\sum _{j\ne l}-{\varphi }_j(s_j,s_{-j}^{\prime })-\left(-{\varphi }_l(s_l,s_{-l})+\sum _{j\ne l}-{\varphi }_j(s_j,s_{-j})\right)\hfill \\ \hfill & =\psi (s_l^{\prime },s_{-l})-\psi (s_l,s_{-l})\hfill \end{array}$$

(23)

Therefore, any unilateral change in a cluster’s decision results in an identical variation in both its individual utility and the potential function, confirming that the proposed distributed task offloading game is an EPG. According to the fundamental properties of an EPG, at least one pure-strategy NE exists, thus completing the proof of Theorem 1. □

3.2. Optimizing the Task Allocation for a Given Clustering Strategy

We propose a greedy-based heuristic algorithm that proportionally assigns computational loads based on each USV’s resources. UAVs within clusters execute a zero-workload virtual segment, ensuring feasibility of task allocation. The detailed procedure is presented in Algorithm 1.

Algorithm 1 Task offloading algorithm for given clustering strategy.

Input: Clustering strategy: $s_l$; computing capability of each USV: $\{f_1,f_2,\dots ,f_{n_l+1}\}$; transmission rates between nodes: $\{r_{1,2},r_{2,3},\dots ,r_{n_l,n_l+1}\}$; computational workload of all D layers: $\{w_1,w_2,\dots ,w_D\}$; transmitted intermediate data size between corresponding M layers: $\{w_{1,2}^{id},w_{2,3}^{id},\dots ,w_{D-1,D}^{id}\}$. Output: Task splitting and allocation strategy: $z_l$; 1: Initialize the last selected split layer $d=0$; 2: Initialize the computation workload of each USV i as $w_i={\displaystyle \frac{f_i{\sum }_{d=1}^D{w}_d}{{\sum }_{i=1}^{n_l+1}{f}_i}}$; 3: Initialize the initial communication cost of each USV i as $com{m}_i={\displaystyle \frac{w_{d,d+1}^{id}}{r_{i,i+1}}},i\in {\mathcal{N}}_l,d\in D$; 4: for each USV $i=1,\dots ,n_l$ do 5:    Calculate computational workload from d to $d^{\prime }$; 6:    while ${\sum }_d^{d^{\prime }}{w}_d\approx w_i$ do 7:       Update $d=d^{\prime }$, $k_{l,m}\leftarrow 1$; 8:       Update $com{m}_i$; 9:    end while 10: end for

3.3. Optimizing UAV Arrival Times and Hoverings Coordinate for a Given Clustering Strategy

To address the problem of optimizing UAV arrival times and hovering coordinates given fixed client clustering and task allocation strategies, we decouple and reformulate the problem into dedicated subproblems for optimization.

Optimizing UAV Arrival Time t: For any feasible $q_l$, (17) can be reduced to

$$\begin{array}{cc}\hfill \underset{\left\{t\right\}}{min}:& T=\sum _{l=1}^L\sum _{i=0}^{n_l}\sum _{j=0}^{n_l}{\rho }_{l(i,j)}(T_l+t_{l(i,j)}^f)\hfill \\ \hfill \mathrm{s}.\mathrm{t}.& \left(15\right),\left(16\right).\hfill \end{array}$$

(24)

Obviously, (24) constitutes a convex optimization problem with respect to the arrival time t. Consequently, we can efficiently solve it using the method of Lagrange multipliers. Having determined when the UAV arrives at the task point, the uncertainty surrounding its hovering coordinate $q_l$ is reduced, thereby simplifying subsequent optimization stages.

Optimizing UAV Hovering Coordinates $q_l$: After obtaining a feasible solution for the UAV arrival time according to (24), the optimization problem for UAV hovering coordinates can be expressed as follows.

$$\begin{array}{cc}\hfill \underset{\left\{q_l\right\}}{min}:& T=\sum _{l=1}^L\sum _{i=0}^{n_l}\sum _{j=0}^{n_l}{\rho }_{l(i,j)}(T_l+t_{l(i,j)}^f)\hfill \\ \hfill \mathrm{s}.\mathrm{t}.& \left(15\right),\left(16\right).\hfill \end{array}$$

(25)

Due to the nonlinear relationship between $T_l$, $t_{l(i,j)}^f$, and the UAV hovering coordinate $q_l$, (25) is rendered a non-convex problem. To address this, we employ the ADMM for its solution. Specifically, we first reformulate 25 into an ADMM-compliant form and then decompose it into a set of subproblems that can be efficiently solved in parallel. To render (25) separable, we introduce the following two auxiliary variables, namely $q_l^{*}$ and $q_l^{\prime }$, such that

$$q_l^{*}=q_l,q_l^{\prime }=q_l.$$

(26)

Building upon (25), constraints (15) and (16) can be reformulated, after substituting $q_l$, as

$$t_{l,i}^a+T_l^{*}+t_{l(i,j)}^{*f}\le t_{l,j}^a,i,j\in {\mathcal{N}}_l,l\in \mathcal{L},$$

(27)

$$\sum _{i=0}^{n_l}\sum _{j=0}^{n_l}{\rho }_{l(i,j)}(T_l^{\prime }+t_{l(i,j)}^{\prime f})\le t_l^{max}.$$

(28)

Therefore, (25) can be reformulated in the equivalent ADMM form as follows:

$$\begin{array}{cc}\hfill \underset{\{q_l,q_l^{*},q_l^{\prime }\}}{min}:& T=\sum _{l=1}^L\sum _{i=0}^{n_l}\sum _{j=0}^{n_l}{\rho }_{l(i,j)}(T_l+t_{l(i,j)}^f)\hfill \\ \hfill \mathrm{s}.\mathrm{t}.& \left(26\right)–\left(28\right).\hfill \end{array}$$

(29)

Through the introduction of auxiliary variables, constraints (27) and (28) are decoupled, enabling the problem to be decomposed. Following decoupling, the application of the ADMM allows each subproblem to be computed in parallel, thereby enhancing the computational efficiency. Here, we construct the augmented Lagrangian function with an additional quadratic penalty term to accelerate the convergence and improve the numerical stability, as follows:

$$\begin{array}{cc}\hfill & \mathcal{L}(q_l,q_l^{*},q_l^{\prime },{\omega }_1,{\omega }_2)=\sum _{l=1}^L\sum _{i=0}^{n_l}\sum _{j=0}^{n_l}{\rho }_{l(i,j)}(T_l+t_{l(i,j)}^f)\hfill \\ \hfill & +{\displaystyle \frac{{\upsilon }_1}{2}}\Vert q_l^{*}-q_l+{\omega }_1{\Vert }^2+{\displaystyle \frac{{\upsilon }_2}{2}}{\Vert q_l^{\prime }-q_l+{\omega }_2\Vert }^2,\hfill \end{array}$$

(30)

where ${\omega }_1$ and ${\omega }_2$ are the error variables corresponding to (27) and (28), respectively, which function as Lagrange multipliers during the ADMM iterative process; ${\upsilon }_1$ and ${\upsilon }_2$ are the penalty factors. Regarding the primal variables $\{q_l,q_l^{*},q_l^{\prime }\}$, they can be partitioned into two distinct groups, namely $q_l$ and the set $\{q_l^{*},q_l^{\prime }\}$. Based on this partitioning, the augmented Lagrangian function is also separable. Consequently, (29) can be solved by iteratively updating these two groups of optimization variables. The associated ADMM algorithm procedure primarily consists of the following three steps:

• Update$\{q_l^{*},q_l^{\prime }\}$: Based on the aforementioned definitions of the variables $\{q_l^{*},q_l^{\prime }\}$, their optimization can be processed separately and independently. The optimization procedure for each parameter can be formulated as

  $$\begin{array}{cc}& \underset{\left\{q_l^{*}\right\}}{min}{\displaystyle \frac{{\upsilon }_1}{2}}{\Vert q_l^{*}-q_l^n+{\omega }_1^n\Vert }^2\hfill \\ & \mathrm{s}.\mathrm{t}.t_{l,i}^a+T_l^{*}+t_{l(i,j)}^{*f}\le t_{l,j}^a,i,j\in {\mathcal{N}}_l,l\in \mathcal{L},\hfill \end{array}$$

  (31)

  $$\begin{array}{cc}& \underset{\left\{q_l\right\}}{min}{\displaystyle \frac{{\upsilon }_2}{2}}{\Vert q_l^{\prime }-q_l^n+{\omega }_2^n\Vert }^2\hfill \\ & \mathrm{s}.\mathrm{t}.\sum _{i=0}^{n_l}\sum _{j=0}^{n_l}{\rho }_{l(i,j)}(T_l^{\prime }+t_{l,(i,j)}^{\prime f})\le t_l^{\max }.\hfill \end{array}$$

  (32)

  where $q_l^n$, ${\omega }_1^n$, ${\omega }_2^n$ represent the solutions obtained after the n-th iteration. Due to the influence of constraints, (31) constitutes a non-convex problem. To resolve this issue, we introduce auxiliary variables ${\delta }_1=\{{\delta }_l^{DL},l\in \mathcal{L}\}$, ${\delta }_2=\{{\delta }_i,i\in n_l+1\}$, and ${\delta }_3=\{{\delta }_l^{UL},l\in L\}$, corresponding to the transmission rates $r_l^{DL}$, $r_i$, and $r_l^{UL}$, respectively. Thus, (31) can be reformulated as

  $$\begin{array}{cc}\hfill \underset{\{q_l^{*},{\delta }_1,{\delta }_2,{\delta }_3\}}{min}& {\displaystyle \frac{{\upsilon }_1}{2}}{\parallel q_l^{*}-q_l^n+{\omega }_1^n\parallel }^2\hfill \\ \hfill \mathrm{s}.\mathrm{t}.& t_{l,i}^a+T_l^{*}+t_{l(i,j)}^{*f}\le t_{l,j}^a,i,j\in {\mathcal{N}}_l,l\in \mathcal{L},\hfill \\ & {\delta }_l^{DL}\le r_l^{D{L}^{*}},l\in \mathcal{L},\hfill \\ & {\delta }_i\le r_i^{*},i\in {\mathcal{N}}_l,\hfill \\ & {\delta }_l^{UL}\le r_l^{U{L}^{*}},l\in \mathcal{L},\hfill \end{array}$$

  (33)

  where $r_l^{D{L}^{*}}$, $r_i^{*}$, and $r_l^{U{L}^{*}}$ represent the transmission rates after substituting $q_l$. However, since $r_l^{D{L}^{*}}$, $r_i^{*}$, and $r_l^{U{L}^{*}}$ remain non-convex with respect to $q_l^{*}$, (33) is still intractable for direct solution. Notably, $r_l^{D{L}^{*}}$ and $r_l^{U{L}^{*}}$ exhibit convexity with respect to $\Vert q_l^{*}-q_0{\Vert }^2$, while $r_i^{*}$ is convex with respect to $\Vert q_l^{*}-q_i{\Vert }^2$. To address this, we seek convex lower bounds for $R_l^{D{L}^{*}}$, $R_i^{*}$, and $R_l^{U{L}^{*}}$ to replace the original non-convex functions, thereby transforming the optimization problem into a convex problem. Assuming the current iteration point is $q_l^{\ast n}$, the convex lower bounds for $r_l^{D{L}^{*}}$, $r_i^{*}$, and $r_l^{U{L}^{*}}$ obtained via first-order Taylor expansion at $q_l^{\ast n}$ can be expressed as

  $$\begin{array}{cc}\hfill & r_l^{D{L}^{\ast }}\ge B_l{log}_2\left(1+{\displaystyle \frac{p{h}_{l,0}}{{\sigma }^2(\Vert q_l^{\ast n}-q_0{\Vert }^2+H^2)}}\right)\hfill \\ \hfill & -{\displaystyle \frac{B_{l}p{h}_{l,0}(\Vert q_l^{\ast }-q_0{\Vert }^2-\Vert q_l^{\ast n}-q_0{\Vert }^2)}{ln\left(2\right)(\Vert q_l^{\ast n}-q_0{\Vert }^2+H^2)\left({\sigma }^2(\Vert q_l^{\ast n}-q_0{\Vert }^2+H^2)+p{h}_{l,0}\right)}},\hfill \end{array}$$

  (34)

  $$\begin{array}{cc}\hfill & r_i^{*}\ge B{log}_2\left(1+{\displaystyle \frac{p_l{h}_{l,i}}{{\sigma }^2(\Vert q_l^{\ast n}-q_i{\Vert }^2+H^2)}}\right)\hfill \\ \hfill & -{\displaystyle \frac{B{p}_l{h}_{l,i}(\Vert q_l^{\ast }-q_i{\Vert }^2-\Vert q_l^{\ast n}-q_i{\Vert }^2)}{ln\left(2\right)(\Vert q_l^{\ast n}-q_i{\Vert }^2+H^2)\left({\sigma }^2(\Vert q_l^{\ast n}-q_i{\Vert }^2+H^2)+p{h}_{l,i}\right)}},\hfill \end{array}$$

  (35)

  $$\begin{array}{cc}\hfill & r_l^{U{L}^{*}}\ge B_l{log}_2\left(1+{\displaystyle \frac{p_l{h}_{l,0}}{{\sigma }^2(\Vert q_l^{\ast n}-q_0{\Vert }^2+H^2)}}\right)\hfill \\ \hfill & -{\displaystyle \frac{B_l{p}_l{h}_{l,0}(\Vert q_l^{\ast }-q_0{\Vert }^2-\Vert q_l^{\ast n}-q_0{\Vert }^2)}{ln\left(2\right)(\Vert q_l^{\ast n}-q_0{\Vert }^2+H^2)\left({\sigma }^2(\Vert q_l^{\ast n}-q_0{\Vert }^2+H^2)+p{h}_{l,0}\right)}},\hfill \end{array}$$

  (36)
  Substituting (34)–(36) into (33) transforms the latter into a convex optimization problem, which can be efficiently solved using conventional convex optimization methods. Similarly, (32) can be solved following an analogous procedure, the details of which are omitted here for brevity.
• Update $q_l$: The optimization procedure for $q_l$ can be formulated as

  $$\begin{array}{cc}\hfill & \underset{q_l}{min}\sum _{l=1}^L\sum _{i=0}^{n_l}\sum _{j=0}^{n_l}{\rho }_{l(i,j)}(T_l+t_{l(i,j)}^f)\hfill \\ \hfill & +{\displaystyle \frac{{\upsilon }_1}{2}}\Vert q_l^{*n+1}-q_l+{\omega }_1^n{\Vert }^2+{\displaystyle \frac{{\upsilon }_2}{2}}{\Vert q_l^{\prime n+1}-q_l+{\omega }_2^n\Vert }^2,\hfill \end{array}$$

  (37)
  Following the same solution approach applied to (31), we introduce auxiliary variables ${\zeta }_1=\{{\zeta }_l^{DL},l\in \mathcal{L}\}$, ${\zeta }_2=\{{\zeta }_i,i\in {\mathcal{N}}_l\}$, and ${\zeta }_3=\{{\zeta }_l^{UL},l\in \mathcal{L}\}$ corresponding to the transmission rates $r_l^{DL}$, $r_i$, and $r_l^{UL}$, respectively. Thus, (37) can be reformulated as

  $$\begin{array}{cc}\hfill \underset{q_l,{\zeta }_1,{\zeta }_2,{\zeta }_3}{min}& \sum _{l=1}^L\sum _{i=0}^{n_l}\sum _{j=0}^{n_l}{\rho }_{l(i,j)}(T_l+t_{l(i,j)}^f)\hfill \\ \hfill & +{\displaystyle \frac{{\upsilon }_1}{2}}\Vert q_l^{*n+1}-q_l+{\omega }_1^n{\Vert }^2+{\displaystyle \frac{{\upsilon }_2}{2}}{\Vert q_l^{\prime n+1}-q_l+{\omega }_2^n\Vert }^2,\hfill \\ \hfill s.t.& {\zeta }_l^{DL}\le r_l^{D{L}^{\prime }},l\in \mathcal{L},\hfill \\ \hfill & {\zeta }_i\le r_i^{\prime },i\in {\mathcal{N}}_l,\hfill \\ \hfill & {\zeta }_l^{UL}\le r_l^{U{L}^{\prime }},l\in \mathcal{L}.\hfill \end{array}$$

  (38)
  The analytical approach for $r_l^{D{L}^{\prime }}$, $r_i^{\prime }$, and $r_l^{U{L}^{\prime }}$ follows the same methodology applied to $r_l^{D{L}^{*}}$, $r_i^{*}$, and $r_l^{U{L}^{*}}$ and thus will not be reiterated here. After this reformulation, (38) becomes a convex optimization problem that can be efficiently solved using standard convex optimization techniques.
• Updating the Lagrange multiplier: The optimization procedure for the Lagrange multiplier can be formulated as

  $${\omega }_1^{n+1}={\omega }_1^n+q_l^{*n+1}-q_l^{n+1},$$

  (39)

  $${\omega }_2^{n+1}={\omega }_2^n+q_l^{\prime n+1}-q_l^{n+1}.$$

  (40)
  The detailed procedure of addressing the problem of optimizing the UAV arrival times and hovering coordinates given fixed client clustering and task allocation strategies is presented in Algorithm 2.

Algorithm 2 ADMM-based UAV optimization algorithm for a given clustering strategy.

Input: The joint strategy of the L clusters: $s=\{s_1,s_2,\dots ,s_L\}$; B, $B_l$; Output: Optimal UAV arrival time t and hovering coordinates $q_l$; 1: Initialize the Lagrange multiplier ${\omega }_1=0$, ${\omega }_2=0$; 2: Initialize the iteration index $I=0$; 3: Initialize the inner-iteration index $n=0$; 4: Repeat iteration 5: for each cluster $l\in \mathcal{L}$ do 6:    Optimize the UAV arrival time t by solving (24); 7:    Introduce two auxiliary variables $q_l^{*}$, $q_l^{\prime }$ and reformulate (15), (16) as (27),(28); 8:    Reformulate (25) into the equivalent ADMM form; 9:    while $n<n_{set}$ do 10:      $n=n+1$ 11:      Obtain $\{q_l^{\ast n},q_l^{\prime n}\}$ by solving (31)–(33); 12:      Obtain $\left\{q_l\right\}$ by solving (37); 13:      Update the Lagrange multiplier ${\omega }_1^n$, ${\omega }_2^n$ by calling (39), (40); 14:    end while 15: end for 16: $q_l^I\leftarrow q_l^{n_{set}}$; 17: $I=I+1$; 18: until $I=I_{set}$ 19: return Optimal UAV arrival time t and hovering coordinates $q_l$

3.4. Overview of Clustering-Based Distributed Task Offloading Algorithms

Based on the optimization objective in (17), the utility of cluster l can be defined as follows:

$${\varphi }_l(s_l,s_{-l})=\alpha T_l+(1-\alpha )t_l^f,$$

(41)

where $t_l^f={\sum }_{i=0}^{n_l}{\sum }_{j=0}^{n_l}{\rho }_{l(i,j)}{t}_{l(i,j)}^f$ denotes the flight time of UAV l under the current offloading link. $\alpha$ denotes the penalty factor. Considering the other clusters’ policy profiles $s_{-l}$, each cluster updates its policy by selecting policy $s_l^{\prime }$ in order to

$$s_l^{\prime }={\mathrm{argmax}}_{s_l^{\prime }\in S_l}{A}_l(s_l^{\prime },s_{-l}).$$

(42)

The algorithm begins by initializing a network consisting of L TCs, C ACs, L UAVs, and a TBS. Initially, each cluster selects a clustering strategy $s_l$ through BFS-based game clustering before evaluating its utility $A_l(s_l,s_{-l})$. Next, each cluster chooses a best response strategy [27] to maximize its utility. If the newly chosen strategy provides higher utility than the existing one, it will replace the existing strategy. These steps are repeated until no cluster can improve its utility by updating its strategy. The detailed procedure is presented in Algorithm 3.

Algorithm 3 Overview of clustering-based distributed task offloading algorithms.

Input: Clustering strategy: $s_l$; Output: Optimal global latency T; 1: Initialize the last selected split layer $m=0$; 2: Initialize the iteration index $k=0$; 3: Initialize the decision-making process for each TC by assigning each user a randomly selected strategy from the available strategy space; 4: Repeat iteration 5: for each cluster $l\in \mathcal{L}$ do 6:    Calculate the global utility as negative reward by calling Algorithms 1 and 2; 7:    if $A_l(s_l,s_{-l})<A_l(s_l^{\prime },s_{-l})$ then 8:      Let $s_l(k+1)=s_l$; 9:    else 10:      Let $s_l(k+1)=s_l\left(k\right)$ 11:    end if 12: end for

3.5. Convergence and Complexity Analysis

In this subsection, we conduct a brief convergence and computational complexity analysis of the proposed ADTO framework during the training process. The solution obtained from NE is not necessarily optimal. We use the Price of Anarchy (PoA) to quantify the worst-case scenario of NE. As described in Definition 2, let $s^{*}=\{s_1^{*},\dots ,s_L^{*}\}$ be an NE strategy profile and $A_l(s_l^{*},s_{-l}^{*})$ denote maximizing the utility; then, the PoA can be expressed as

$$PoA={\displaystyle \frac{ma{x}_{s_l^{*}\in s^{*}}{\sum }_{l\in \mathcal{L}}{A}_l(s_l^{*},s_{-l}^{*})}{mi{n}_{s_l\in S_l}{\sum }_{l\in \mathcal{L}}{A}_l(s_l,s_{-l})}}.$$

(43)

Theorem 2.

The maximum value of the PoA for the distributed USV clustering game is

$${\displaystyle \frac{{\sum }_{l\in \mathcal{L}}(t_l^{DL}+t_l^{local}+t_l^{UL}+t_l^f)}{{\sum }_{l\in \mathcal{L}}min(T_l^{local},T_l^{D2D})}}.$$

(44)

Proof. 

Under the NE, the overall delay for each TC l to complete the global task $Q_l$ is at most $t_l^{DL}+t_l^{local}+t_l^{UL}+t_l^f$, corresponding to the strategy in which the TC always executes its computation tasks locally. Hence, we obtain

$$\begin{array}{cc}\hfill \sum _{l\in \mathcal{L}}{A}_l(s_l^{*},s_{-l}^{*})& \le A_l^{local}(s_l,s_{-l})\hfill \\ & =-\sum _{l\in \mathcal{L}}(t_l^{DL}+t_l^{local}+t_l^{UL}+t_l^f).\hfill \end{array}$$

(45)

$$\begin{array}{cc}\hfill \sum _{l\in \mathcal{L}}{A}_l(s_l,s_{-l})& \ge min(A_l^{local},A_l^{D2D})\hfill \\ & =min(-T_l^{local}+t_{l,local}^f,-T_l^{D2D}+t_{l,D2D}^f).\hfill \end{array}$$

(46)

According to (45) and (46), we can derive the upper bound of the PoA:

$$PoA\le {\displaystyle \frac{{\sum }_{l\in \mathcal{L}}(t_l^{DL}+t_l^{local}+t_l^{UL}+t_l^f)}{{\sum }_{l\in \mathcal{L}}min(T_l^{local}+t_{l,local}^f,T_l^{D2D}+t_{l,D2D}^f)}}.$$

(47)

□

Theorem 2 establishes that even if the algorithm converges to the worst NE, the overall optimization objective does not deteriorate arbitrarily. Crucially, even in the worst-case scenario, its performance remains consistently within a constant factor of the centralized optimal solution.

The computational complexity of BFS-based distributed game clustering primarily depends on the number of edges E and nodes V in the graph. Thus, the computational complexity of BFS-based distributed game clustering can be expressed as $\mathcal{O}\left(\right|V|+|E\left|\right)$. The computational complexity of Algorithm 1 is denoted as $\mathcal{O}\left(n_l\right)$, while the computational complexity of Algorithm 2 is denoted as $\mathcal{O}(I·L·n_{set}·n_l)$, where I represents the number of iterations in Algorithm 2. After omitting constant terms, the overall complexity of ADTO is derived as $T\left(\right|V|+|E|+n_l+I·L·n_{set}·n_l)$. After omitting the constant term, the overall computational complexity can be expressed as $T\left(\right|V|+|E|+L·n_l)$. In summary, the computational complexity of ADTO is acceptable, and this design is well suited to scenarios with high real-time performance requirements and limited resources.

4. Experimental Results and Analysis

In this section, we implement simulations of the proposed framework using Python 3.9 and PyTorch 11.3. Meaningful results from extensive experiments are presented to validate the effectiveness of the developed solution.

4.1. Parameter Settings

We consider a sector-shaped area centered at the TBS, which defines the free flight area of the UAVs. This area contains multiple ACs and TCs, totaling 12 nodes. Since each UAV acts as a CH, the number of UAVs equals the number of TCs. The sector radius is 500 m, and thus, the coordinates of the TBS and the UAV charging station are $q_0=(0,0)$. For D2D communication links between clients i and j, we configure all clients with an identical transmission power of 24 dBm. The noise variance ${\sigma }^2=-110$ dBm and the channel power gain is −60 dB, which are constant in all phases. The flying altitude H of the UAV is set to 100 m, and the flight speed is set to 20 m/s. For each TC, the global task data size is 15 Mbits. For all USVs, the required CPU cycles per bit are uniformly distributed in [1500, 2000] cycles/bit. The computing resources for the TC and AC are configured as $f_t\in [0.5,2]\times {10}^9$ CPU cycles/s and $f_a\in [6,10]\times {10}^9$ CPU cycles/s, respectively [23]. For the TBS, its transmit power P is 46 dBm, the default communication bandwidth is 5 MHz, and the computing capability is $f_{tbs}=40\times {10}^9$ CPU cycles/s. The penalty factor $\alpha =0.9$.

4.2. Convergence Behavior

We first analyze the convergence properties of the ADTO algorithm under a configuration of 6 TCs and 6 ACs. As illustrated in Figure 3, 500 independent trials were conducted under identical topological conditions. Consistent with theoretical expectations, the global utility increased with iteration count and converged after approximately 38 iterations. When combined with the theoretical analyses of Theorems 1 and 2, these experimental results confirm that ADTO exhibits robust convergence behavior and attains stable solutions within finite iterations. The penalty factor $\alpha$ is set to 0.9.

4.3. Task Execution Latency Comparison

4.3.1. Local Offloading Mechanisms

We selected several advanced local offloading algorithms for comparison with ADTO, and the details of the selected algorithms are described below.

Random offloading: The random offloading approach randomly assigns the size of subtasks to the USVs within the cluster. This methodology fails to ensure optimal task assignment to the most suitable nodes, consequently inducing suboptimal system performance.

Greedy: The greedy approach offloads the entire task to the nearest and most computationally powerful AC without task splitting.

MAC-L: This approach models complex computation tasks as “task flows” with dependencies and employs the multi-actors-critic (MAC)-based MARL approach. For the purpose of comparison, only the local latency is considered here.

Figure 4 compares the ADTO algorithm against three intra-cluster offloading schemes. As the number of TCs increases, the greedy method is only marginally affected, whereas the other three methods exhibit a clear upward trend in the delay. Nevertheless, despite its relative insensitivity to TC count, the greedy approach consistently incurs the highest latency among the four. In contrast, ADTO delivers the lowest delay across all tested TC levels.

Figure 5 depicts the performance of the three schemes as the number of ACs grows, with the number of TCs held constant at 6. Because the greedy algorithm simply offloads the entire task to the nearest AC with the greatest computational capacity, increasing the number of ACs does not significantly improve its overall performance. The random offload approach is further hampered by resource conflicts and thus underperforms relative to ADTO. Furthermore, MAC-L is the method among the three that has the closest performance to that of ADTO. This is because as the number of ACs increases, the impact of resource conflicts on the task scheduling of MAC-L gradually diminishes. Therefore, ADTO remains the most performant method among the four.

4.3.2. Global Offloading Mechanisms

Next, we selected several advanced local offloading algorithms for comparison with ADTO, and the details of the selected algorithms are described below.

Global local computing (GLC): After receiving the TBS task transmitted via the UAV, each TC selects to execute the task locally.

Global edge offloading (GEO): Based on Algorithm 1, when the local TC receives the TBS task transmitted via the UAV, it decides to offload part of the task to the TBS for execution.

MAC-L: The MAC-L method takes into account the communication delay while remaining the same as the previous method.

We conducted a comparative evaluation of the ADTO algorithm against three other global offloading mechanisms. As shown in Figure 6, the average latency of all four schemes increases as the number of TCs grows. However, the GEO algorithm’s latency rises sharply due to its sensitivity to constrained communication resources. In contrast, the GLC scheme exhibits relatively minor fluctuations but registers the highest average delay when fewer than four TCs are present. As a scheduling algorithm, MAC-L exhibits increasing latency when the number of TCs rises and the number of ACs relatively decreases. This degradation stems from exacerbated scheduling complexity when allocating TC tasks across diminished computational resources. In contrast, ADTO consistently outperforms all three baseline methods, maintaining the lowest observed latency across all evaluated conditions.

Figure 7 illustrates a global performance comparison of the three mechanisms as the number of ACs varies. Because the performance of both GEO and GLC is independent of AC count, their curves appear as horizontal lines. In contrast, the total latency under ADTO decreases with an increasing number of ACs. This declining trend does not continue indefinitely as AC numbers grow since a balance point will be reached where the intra-cluster communication and computing overhead offsets the benefit gained from adding more ACs.

4.4. UAV Time Cost Comparison

Finally, we compare the latency performance of four schemes: (1) our proposed D2D offloading method, integrating Algorithms 1 and 2, denoted by ADTO; (2) the ADTO method which uses UAV-assisted computation offloading and where the UAV undertakes the computation task, denoted by ADTO-U; (3) the ADTO method with the UAV hover coordinates fixed at the horizontal coordinates of the served USV, denoted by ADTO-F; and (4) the ADTO method with tasks partially and randomly offloaded to neighboring USVs, denoted by ADTO-R.

Figure 8 presents the variations in UAV flight time for different schemes as the number of TCs increases. It can be observed that across all schemes, UAV flight time correspondingly rises with an increasing number of TCs. Under the same number of TCs, ADTO consistently achieves the shortest flight time. Specifically, for ADTO-F, its hovering coordinates are fixed, which results in a longer flight distance compared to that of ADTO. Regarding ADTO-U, the UAV is required to perform local computational tasks, necessitating closer proximity to the TCs. Additionally, it is constrained by battery capacity, leading to frequent travel between the TBS and TCs. Finally, although ADTO-R is the closest scheme to ADTO and has a relatively shorter flight time compared to that of the other two schemes, the introduction of randomness prevents it from guaranteeing an optimal UAV flight trajectory.

5. Conclusions

A novel distributed computation offloading framework for maritime IoT systems has been proposed in this paper. Considering practical communication constraints and real-world application demands in shipping operations, the proposed framework employs potential game theory to model the client clustering optimization problem as a distributed computation offloading game. This approach aims to maximize the overall offloading efficiency while simultaneously addressing communication limitations and enhancing resource utilization. Building upon this, we formulate a global latency minimization problem that jointly optimizes UAV hovering coordinates and arrival times. This problem is solved by decomposing it into subproblems addressed via a joint ADMM and SCA approach, effectively reducing the time between UAV arrivals and hovering coordinates. Extensive simulation results validate that the framework can effectively reduce the overall system delay while making full use of the available computing resources.

Although the distributed computational offloading framework proposed in this paper demonstrates significant effectiveness and outperforms several prevalent schemes in reducing global latency, there remain opportunities for further improvements. Firstly, as the number of TCs increases, the performance of ADTO exhibits a declining trend. Introducing Digital Twin (DT) technology can provide a novel approach to ensuring quality of service in regions with high-density data centers and efficiently offloading complex tasks [28]. Secondly, considering the movement characteristics of USVs, future research directions could include advanced positioning techniques such as particle filter-based Received Signal Strength (RSS) localization, multi-agent Q-learning methods for trajectory tracking [29], and multi-agent reinforcement learning (MARL) methods for dynamic resource allocation [30]. Furthermore, the trustworthiness of D2D computational offloading has become a critical research area. While offloading tasks from TCs to adjacent ACs alleviates computational deficits of individual TCs, it simultaneously introduces risks of erroneous computations or malicious interference from untrusted nodes. The Fuzzy Comprehensive Trust Evaluation (FCTE) algorithm, which has proven effective in vehicular edge computing scenarios, represents a viable solution for enhancing offloading security and could serve as a potential approach to improving overall offloading safety [31].