A Distributed Deadlock-Free Task Offloading Algorithm for Integrated Communication–Sensing–Computing Satellites with Data-Dependent Constraints

Abstract

Integrated communication–sensing–computing (ICSC) satellites, which integrate edge computing servers on Earth observation satellites to process collected data directly in orbit, are attracting growing attention. Nevertheless, some monitoring tasks involve sequential sub-tasks like target observation and movement prediction, leading to data dependencies. Moreover, the limited energy supply on satellites requires the sequential execution of sub-tasks. Therefore, inappropriate assignments can cause circular waiting among satellites, resulting in deadlocks. This paper formulates task offloading in ICSC satellites with data-dependent constraints as a mixed-integer linear programming (MILP) problem, aiming to minimize service latency and energy consumption simultaneously. Given the non-centrality of ICSC satellites, we propose a distributed deadlock-free task offloading (DDFTO) algorithm. DDFTO operates in parallel on each satellite, alternating between sub-task inclusion and consensus and sub-task removal until a common offloading assignment is reached. To avoid deadlocks arising from sub-task inclusion, we introduce the deadlock-free insertion mechanism (DFIM), which strategically restricts the insertion positions of sub-tasks based on interval relationships, ensuring deadlock-free assignments. Extensive experiments demonstrate the effectiveness of DFIM in avoiding deadlocks and show that the DDFTO algorithm outperforms benchmark algorithms in achieving deadlock-free offloading assignments.

1. Introduction

Earth observation satellites play an essential role in environment monitoring, geographical surveys, and situational awareness [1]. With the rapid growth of Earth observation satellites, massive amounts of observation data are generated worldwide, requiring further processing [2]. A common practice is to transmit observation data to ground stations, but this strains terrestrial–satellite network resources and exceeds the communication capabilities of satellites, causing congestion and packet loss [3,4,5]. Traditional compression methods [6,7] reduce data volume but retain task-irrelevant information. To minimize communication costs and latency, it is more efficient to transmit only task-relevant information. Inspired by mobile edge computing (MEC), some works attempt to deploy edge computing servers on Earth observation satellites to process data onboard [5,8]. These satellites, known as integrated communication–sensing–computing (ICSC) satellites, have drawn increasing attention in recent years [9,10,11,12].

In ICSC satellite networks, a group of ICSC satellites connected by inter-satellite links (ISLs) perform coordinated observations and onboard data processing for a set of monitoring tasks. Some tasks, such as military monitoring [13] and target tracking [14], require continuous target observation and target movement prediction, involving a series of observation and computation sub-tasks. Therefore, task offloading, determining where and when sub-tasks are performed, is crucial in ICSC satellite networks. However, due to data dependencies among sub-tasks and limited energy supply on satellites, which requires the sequential execution of sub-tasks, not all offloading assignments are feasible.

Specifically, on the one hand, there are data dependency constraints between the observation and computation sub-tasks. Computation sub-tasks must wait until the preceding observation sub-task completes and provides the necessary data. Similarly, observation sub-tasks must wait for preceding computation tasks to finish to obtain the predicted target location [14]. These dependencies introduce additional constraints on task execution. On the other hand, ICSC satellites have limited electricity generated by their solar panels [15], resulting in power restrictions. Then, the ICSC satellite cannot perform observation and computation sub-tasks simultaneously, and sub-tasks are executed sequentially on each satellite. Even worse, if sub-tasks are offloaded inappropriately, several satellites may need information from sub-tasks that can only be executed later by these same satellites, leading to an undesirable phenomenon called deadlock [16]. In such a deadlock, ICSC satellites are trapped in circular waiting, leading to the suspension of the entire system. Therefore, task offloading in ICSC satellites should be carefully addressed to resolve the existing conflicts.

The task offloading problem in ICSC satellites has received increasing attention recently. Recent works [5,17,18,19,20] employed heuristic and convex optimization methods to achieve offloading assignments for ICSC satellites. Additionally, considering the decentralized nature of ICSC satellites, study [21] proposed a distributed scheduling algorithm for ICSC satellite clusters. Unfortunately, some practical challenges are still neglected, such as data dependency constraints among sub-tasks, the coupling between observation and computation, and potential deadlocks. By resolving task offloading problems under these challenges, we enable ICSC satellites to achieve self-organized task assignments, autonomous task execution, and in-orbit data processing.

In this paper, we address the task offloading problem in ICSC satellites with data-dependent constraints and resolve potential deadlocks. The main contributions are summarized as follows:

• We establish a mixed-integer linear programming (MILP) model for the task offloading problem in ICSC satellites, considering data dependence constraints among sub-tasks.
• To address this problem, we introduce a decentralized PI framework. Our method, the distributed deadlock-free task offloading (DDFTO) algorithm, operates on each satellite in parallel, utilizing local communication via ISLs. It alternates between stages of sub-task inclusion and consensus and sub-task removal on each satellite, continuing until all ICSC satellites converge on a common offloading assignment.
• To resolve undesired deadlocks in offloading assignments, a deadlock-free insertion mechanism (DFIM) is integrated into DDFTO. We demonstrate its effectiveness and computational complexity in resolving deadlocks.

The rest of this article is organized as follows: Section 2 illustrates the MILP model. Section 3 outlines the problem description and formulation. Section 4 presents the proposed DDFTO algorithm, including the deadlock-free insertion mechanism. Section 5 describes and analyzes extensive numerical experiments. Section 6 discusses the parameter effects on DDFTO. Finally, conclusions are drawn in Section 7.

2. Related Works

ICSC satellites have gained attention for their fast data processing and decision-making capabilities, which are crucial for urgent tasks like disaster rescue and military surveillance. Firstly, ICSC satellites reduce data transmission, conserving valuable terrestrial–satellite communication resources. For example, Zhu et al. [22] developed a two-tier processing framework for hyperspectral images, while Mateo-Garcia et al. [23] used machine learning on the Φ-Sat-1 satellite to filter out cloudy images. Secondly, these satellites enhance efficiency in emergencies such as earthquakes and wildfires by prioritizing critical areas for data transmission. Furano et al. [24] used edge computing to focus on key areas for image transmission, and Bui et al. [25] employed onboard computing on the IRIS-B satellite to detect and predict landslides, sending only essential information to ground stations. Finally, ICSC satellites support real-time object tracking, allowing ground stations to receive precise object locations instead of large video frames. Shi et al. [26] developed a method for tracking moving aircraft using satellite video frames.

Although efficient task offloading algorithms play a significant role in ICSC satellites, little attention has been paid to this field [17,18,19,20,21]. Existing methods can be roughly classified into the following two types: centralized and distributed. Specifically, He et al. [17] developed a heuristic algorithm that schedules tasks based on the density of residual tasks. A central node manages task filtering and scheduling periods, while edge satellites use heuristic rules to schedule their own tasks. To minimize energy consumption for ICSC satellites, Leyva-Mayorga et al. [5] formulated a satellite mobile edge computing framework for Earth observation, optimizing image distribution and compression parameters. Considering ISL communication resources, Valente et al. [18] proposed two heuristic approaches with varying computational complexities to address issues related to bandwidth and computing resource allocation among ICSC satellites. Zhu et al. [19] decomposed the task offloading problem into two subproblems, devising a strategy for joint subframe allocation and task partitioning to optimize overall performance, achieving Pareto-optimal solutions. Finally, Gost et al. [20] divided the problem into two subproblems and applied convex optimization methods to obtain a trade-off between energy consumption and latency.

The aforementioned methods are centralized and straightforward to implement and operate swiftly. However, they necessitate constant communication between the decision node and all ICSC satellites, which can lead to a single point of failure [27]. Considering the non-centrality of ICSC satellites, Biswas et al. [21] proposed a distributed scheduling algorithm for ICSC satellite clusters, and the overall latency in task execution was significantly improved. Inspired by previous works [28,29], we introduce a distributed heuristic algorithm called DDFTO in this paper. DDFTO operates on each ICSC satellite in parallel, using local communication via ISLs. It alternates between two newly designed stages: sub-task inclusion and consensus and sub-task removal, until ICSC satellites converge on a common offloading assignment.

However, neglecting data dependency constraints among sub-tasks and potential deadlocks in monitoring scenarios can lead to task failures. Therefore, this paper focuses on designing a full-decentralized deadlock-free task offloading algorithm considering the above practical factors for ICSC satellites.

3. Problem Description and Formulation

As depicted in Figure 1, this paper explores the task offloading problem for ICSC satellites, in which a cluster of ICSC satellites collaboratively monitor terrestrial targets and process collected data directly in orbit. This section provides an overview of ICSC satellites, monitoring tasks, and relevant constraints. Additionally, we propose an MILP model for the considered problem. Key notations are listed in

Table 1. Notations.

Notation	Description
n	Number of ICSC satellites.
m	Number of monitoring tasks.
S	Set of ICSC satellites.
T	Set of monitoring tasks.
V	Set of sub-tasks.
Cs	Computing capacity of ICSC satellites.
G	Network topology matrix.
($𝒱$t, $ℰ$t)	Directed acyclic graph of monitoring task t, where $𝒱$t collects sub-tasks in t, and $ℰ$t denotes dependencies among them.
$𝒫$v	Predecessors of sub-task v.
$𝒮$v	Successors of sub-task v.
<ξv, ρv, dvI, dvO>	Parameter tuple characterizing each sub-task v, where ξv refers to the workload of v, ρv represents the imaging time of v, dvI refers to the input data of v, and dvO represents the output.
TWvs	Visible time windows for observation sub-task v and satellite s.
θ = {θ1, θ2, …, θn}	Offloading assignment for ICSC satellites.
$ℛ$(θ ⊖s v)	Removal impact, indicating the variation of F(θ) after removing v from θs.
$ℐ$(θ ⊕s v)	Inclusion impact, indicating the minimum variation of F(θ) after inserting t into θs.
Rs = [Rs1, Rs2, …, Rs|V|]T	Vector of removal impacts for sub-tasks on satellite s.
As = [As1, As2, …, As|V|]T	Vector of considered assigned satellite for sub-tasks on satellite s.
Es = [Es1, Es2, …, Es|V|]T	Vector tracking the time when sub-tasks are executed believed by satellite s.
Ps = [Ps1, Ps2, …, Psn]T	Vector indicating the latest timestamp of satellite s.
Γs	Pending removal tasks on satellite s.
Φs,v	Candidate insertion positions for sub-task v on satellite s.

.

3.1. ICSC Satellites

Let S = {1, 2, 3, …, n} be the set of n ICSC satellites. Each ICSC satellite s ∈ S not only serves as an Earth observation satellite but also deploys an MEC server with computing capacity C_s for in-orbit image processing. Every satellite s ∈ S is connected to four neighboring satellites via ISLs, and the network topology is represented by an n × n matrix G, where G[s, k] = l_s,k if satellite s and k can exchange information via ISL with distance l_s,k; otherwise G[s, k] = ∞.

3.2. Monitoring Tasks and Sub-Tasks

Let T = {1, 2, 3, …, m} denote the monitoring tasks for m targets. According to the collaborative observation method for tracking moving targets [30], each monitoring process involves a sequence of target observation and movement prediction subprocesses. Consequently, each monitoring task t ∈ T can be divided into multiple observation and computation sub-tasks. Figure 2 illustrates an example of this monitoring process.

Therefore, each monitoring task t ∈ T can be formally represented by a directed acyclic graph (DAG) t = ($𝒱$_t, $ℰ$_t), where vertex set $𝒱$_t collects all |$𝒱$_t| sub-tasks in t, and edge set $ℰ$_t denotes the dependencies among them. Specifically, an edge (u, v) ∈ $ℰ$_t indicates that sub-task v depends on the results of its predecessor sub-tasks u (u, v ∈ $𝒱$_t); thus, sub-task v can be performed only when predecessor u has completed and received the necessary results. Then, we let $𝒫$_v (resp. $𝒮$_v) collect all predecessors (resp. successors) of v, and V = {v ∈ $𝒱$_t | t ∈ T} denotes the set of all sub-tasks across all monitoring tasks.

Moreover, let parameter tuple <ξ_v, ρ_v, d_v^I, d_v^O> characterize each sub-task v ∈ V, where ξ_v refers to the workload of v, ρ_v represents the imaging time of v, d_v^I refers to the input data of v, and d_v^O represents the output. Since sub-task v requires the results of all its predecessors in $𝒫$_v, we have d_v^I = Σ_u∈$𝒫$vd_u^O. Additionally, there is ξ_v = ∅ for observation sub-tasks and ρ_v = ∅ for computation sub-tasks.

3.3. Basic Constraints

We first introduce the observation constraints of ICSC satellites. Based on satellite movement and camera parameters [17], observation sub-tasks can only be performed by satellites under specific time windows. Let TW_vs = {tw_vs1, tw_vs2, …, tw_vs|TWvs|} represents the set of visible time windows for observation sub-task v ∈ V and satellite s ∈ S. Each entry tw_vsg = [twb_vsg, twe_vsg] denotes the visible time window for v on s at g-th opportunity, where twb_vsg and twe_vsg are the begin and end time of tw_vsg, respectively.

For observation sub-task v with imaging time ρ_v, which is going to be observed by satellite s at g-th opportunity. The start observation time $𝒯$_v^E must be satisfied by the following conditions:

$${\mathcal{T}}_v^E\ge tw{b}_{vsg}$$

(1)

$${\mathcal{T}}_v^E+{\mathsf{\rho }}_v\le tw{e}_{vsg}$$

(2)

According to the characteristics of Earth observation satellites [1], the ICSC satellite needs to adjust its attitude to align with the target before performing observation sub-task v. Thus, if there exists a preceding observation sub-task u ∈ V assigned to the same satellite s, an angle transition time is required. Assuming that sub-task u is performed by s at its h-th opportunity, according to the time-dependent angle transition model [31], the required transition time can be given as follows:

$${\mathcal{T}}_{uv,s}^{angle}=trans({\mathsf{\Psi }}_{ush},{\mathsf{\Psi }}_{vsg})$$

(3)

where Ψ_ush and Ψ_vsg are look angles of satellite s for observing sub-task u and v, and trans(•) denotes the calculation function of transition time in [31]. Herein, let $𝒯$_u^E be the executing time of sub-task u; the following satellite maneuvering constraint needs to be satisfied:

$${\mathcal{T}}_u^E+{\mathsf{\rho }}_u+{\mathcal{T}}_{uv,s}^{angle}\le {\mathcal{T}}_v^E$$

(4)

After observing the target, the collected data need to be transmitted via ISLs to the assigned satellites of successor computation sub-tasks. The communication latency consists of propagation latency and transmission latency [32]. Let R_ISL be the rate of ISLs, which is a constant in this paper. Then, communication latency for transmitting data $d_v^O$ of sub-task v from satellite s to k can be expressed as follows:

$${\mathcal{T}}_{v,sk}^{comm}={\displaystyle \frac{l_{s,k}}{c}}+{\displaystyle \frac{d_v^O}{R_{ISL}}}$$

(5)

where l_s,k is the length of the shortest route between satellite s and k, which can be obtained based on the network topology matrix G, and c is the speed of light.

After receiving the required data, the computation sub-task v ∈ V with input data d_v^I and workload ξ_v can be performed. Then, the computational latency of v on assigned satellite s is as follows:

$${\mathcal{T}}_{v,s}^{comp}={\displaystyle \frac{d_v^I{\xi }_v}{C_s}}$$

(6)

3.4. Latency Model

Considering the restricted power supply in satellites [15], the observation and computation process, which consumes huge energy, cannot be performed in a stimulatory fashion on a specific satellite. That means that when there are multiple sub-tasks are assigned to one satellite, we need to consider the queue delay required for performing sub-tasks.

Then we let θ = {θ₁, θ₂, …, θ_n} be an offloading assignment for ICSC satellites, where θ_s represents the sub-task sequence on satellite s ∈ S. Thus, for a specific sub-task v ∈ V, several time parameters are defined as follows:

(1)

$𝒯$_v^R: The time when all results of predecessors $𝒫$_v are received by the assigned satellite of v.

(2)

$𝒯$_v^C: The time when the assigned satellite has completed the previous sub-task v.

(3)

$𝒯$_v^A: The time the assigned satellite turns to the required angle if v is an observation sub-task.

(4)

$𝒯$_v^E: The time when sub-task v is executed.

(5)

$𝒯$_v^F: The finish time of sub-task v.

First, we let u ∈ $𝒫$_v be a predecessor sub-task of v according to DAG. After u is completed, the result of u is transmitted to the assigned satellite of v via ISLs. After receiving all results of $𝒫$_v, sub-task v can be performed, and then we have the following:

$${\mathcal{T}}_v^R=\underset{u\in {\mathcal{P}}_v}{\max }\{{\mathcal{T}}_u^F+{\mathcal{T}}_{u,ks}^{comm}\}$$

(7)

Then, we let ω(v) ∈ V be the preceding sub-task of v from sub-task sequence θ_s. If v is the first sub-task in θ_s, we set ω(v) = ∅; otherwise, v cannot be performed until sub-task ω(v) is completed.

$${\mathcal{T}}_v^C=\left\{\begin{array}{cc}0,\hfill & \hfill if\mathsf{\omega }(v)=\varnothing \hfill \\ {\mathcal{T}}_{\mathsf{\omega }(v)}^F,\hfill & \hfill otherwise\hfill \end{array}\right.$$

(8)

Furthermore, if v is an observation sub-task, v can be performed only when the required lo angle is satisfied. According to (4), if there is a previous observation sub-task δ(v) in θ_s, then the lo angle ready time $𝒯$_v^A is as follows:

$${\mathcal{T}}_v^A=\left\{\begin{array}{cc}0,\hfill & \hfill if\mathsf{\delta }(v)=\varnothing \hfill \\ {\mathcal{T}}_{\mathsf{\delta }(v)}^E+{\mathsf{\rho }}_{\mathsf{\delta }(v)}+{\mathcal{T}}_{\mathsf{\delta }(v)v,s}^{angle},\hfill & \hfill otherwise\hfill \end{array}\right.$$

(9)

Obviously, $𝒯$_v^E ≥ $𝒯$_v^R, $𝒯$_v^E ≥ $𝒯$_v^C, and $𝒯$_v^E ≥ $𝒯$_v^A exist, and then we can give the calculation formula of $𝒯$_v^E as follows:

$${\mathcal{T}}_v^E=\max \{{\mathcal{T}}_v^R,{\mathcal{T}}_v^C,{\mathcal{T}}_v^A\}$$

(10)

Especially for observation sub-task v ∈ V, constraints (1) and (2) need to be satisfied, and then we have $𝒯$_v^E = max{$𝒯$_v^R, $𝒯$_v^C, $𝒯$_v^A, twb_vsg}, where $𝒯$_v^E + ρ_v ≤ twe_vsg holds for [twb_vsg, twe_vsg] ∈ TW_vs.

Finally, the completion time of sub-task v is as follows:

$${\mathcal{T}}_v^F=\left\{\begin{array}{cc}{\mathcal{T}}_v^E{+\mathsf{\rho }}_v,\hfill & \hfill ifvisobservation\\ {\mathcal{T}}_v^E+{\mathcal{T}}_{v,s}^{comp},\hfill & \hfill otherwise\end{array}\right.$$

(11)

Based on the above analysis, given an assignment solution θ, we can calculate ${\mathcal{T}}_v^R$, ${\mathcal{T}}_v^C$, ${\mathcal{T}}_v^A$, ${\mathcal{T}}_v^E$, and ${\mathcal{T}}_v^F$ for each v ∈ V sequentially using (7), (8), (9), (10), and (11), respectively.

3.5. Problem Formulation

Two decision variables are employed to represent sub-task assignment solution θ. Let x_sv be the decision variable where x_sv = 1 if sub-task v is assigned to satellite s, and otherwise, x_sv = 0. Another variable, y_svu = 1 if satellite s needs to perform sub-task v before sub-task u, and y_svu = 0 otherwise.

In this paper, service latency and energy consumption are considered performance indices for evaluating offloading assignment θ. In particular, the service latency is the maximum completion time of all sub-tasks v ∈ V, as follows:

$$F_1=\underset{v\in V}{\max }{\mathcal{T}}_v^F$$

(12)

The energy consumption of ICSC satellites consists of the following four components: transmission, computation, angle transition, and observation. Let η_x, η_a, and η_o be the power of transmission, angle transition, and observation, respectively. For computation, we use a widely adopted model in which energy consumption per commuting cycle is κC_s² [33]. Therefore, the total energy consumption is given as follows:

$$F_2={\displaystyle \sum _{v\in \mathit{V}}{\displaystyle \sum _{u\in {\mathcal{P}}_v}{\displaystyle \sum _{s\in \mathit{S}}{\displaystyle \sum _{k\in \mathit{S}}{\eta }_x{\mathcal{T}}_{u,sk}^{comm}{x}_{su}{x}_{kv}}}}}+{\displaystyle \sum _{v\in \mathit{V}}{\displaystyle \sum _{s\in \mathit{S}}\kappa C_s^3{\mathcal{T}}_{v,s}^{comp}{x}_{sv}}}+{\displaystyle \sum _{v\in \mathit{V}}{\displaystyle \sum _{s\in \mathit{S}}{\eta }_a{\mathcal{T}}_{\mathsf{\delta }(v)v,s}^{angle}{x}_{sv}}}+{\displaystyle \sum _{v\in \mathit{V}}{\displaystyle \sum _{s\in \mathit{S}}{\eta }_o{\mathsf{\rho }}_v{x}_{sv}}}$$

(13)

Then, we formulate the task offloading problem in ICSC satellites to minimize service latency and energy consumption.

$$F(\mathsf{\theta })=\underset{x_{sv},y_{svu}}{\min }\{F_1\cdot F_2\}$$

(14)

$${\displaystyle \sum _{s\in \mathit{S}}{x}_{sv}}=1,\forall v\in \mathit{V}$$

(15)

$${\displaystyle \sum _{u\in \mathit{V}}{y}_{svu}{x}_{sv}}\le 1,\forall s\in \mathit{S},\forall v\in \mathit{V}$$

(16)

$${\displaystyle \sum _{v\in \mathit{V}}{y}_{svu}{x}_{su}}\le 1,\forall s\in \mathit{S},\forall u\in \mathit{V}$$

(17)

$$y_{svu}({\mathcal{T}}_u^E-{\mathcal{T}}_v^F)\ge 0,\forall s\in \mathit{S},\forall u,v\in \mathit{V}$$

(18)

$${\mathcal{T}}_v^E-\underset{u\in {\mathcal{P}}_v}{\max }\{{\mathcal{T}}_u^F\}\ge 0,\forall v\in \mathit{V}$$

(19)

where x_sv and y_svu are binary decision variables. The objective function in (14) aims to minimize both service latency and energy consumption. The fitness of an offloading assignment can also represented as the sum of F₁ and F₂, i.e., F(θ) = min_xsvysvu{F₁ + F₂}. However, this formulation is sensitive to the differing scales of F₁ and F₂. If one cost is significantly larger than the other, minimizing the total cost becomes difficult. For example, if F₂ has much larger values than F₁, even a slight increase in F₂ can overshadow any improvements made in optimizing F₁. Specially, when unexpectable sub-tasks exist in θ, we set F(θ) = ∞ due to system stagnation. Equation (15) ensures that each sub-task can be offloaded to at most one specific ICSC satellite. Equations (16) and (17) state that each sub-task v ∈ θ_s can have at most one preceding and one following sub-task in its sequence θ_s. Equation (18) describes the temporal relationships between sub-tasks assigned to the same satellite. Equation (19) outlines the temporal relations among sub-tasks with data dependencies.

4. The Distributed Deadlock-Free Task Offloading Algorithm

Inspired by PITO [29], this article develops the DDFTO algorithm to address the task offloading problem in ICSC satellites with data-dependent constraints. DDFTO operates on each satellite in parallel, relying on local communication via ISLs. Two newly designed stages, sub-task inclusion and consensus and sub-task removal, perform alternately, ensuring that DDFTO generates deadlock-free offloading assignments.

4.1. Basic Concept

In DDFTO, each satellite s ∈ S iteratively modifies its sub-task sequence θ_s by adding or removing sub-tasks, aiming to minimize the global objective F(θ) using information from neighboring satellites via ISLs.

To achieve this, we first introduce two indicators, removal impact and inclusion impact, designed for each sub-task v ∈ V concerning satellite s ∈ S.

(1)

Removal impact: for sub-task v ∈ θ_s, the removal impact $ℛ$(θ ⊖_s v) indicates the variation of F(θ) after removing v from θ_s, and then we have the following:

$$\mathcal{R}(\mathsf{\theta }{\ominus }_{s}v)=F(\mathsf{\theta })-F(\mathsf{\theta }{\ominus }_{s}v)$$

(20)

where θ ⊖_s v represents the removal of sub-task v from θ_s ∈ θ. For any v ∉ θ_s, we let $ℛ$(θ ⊖_s v) = ∞.

(2)

Inclusion impact: for sub-task v ∉ θ_s, the inclusion impact $ℐ$(θ ⊕_s v) represents the minimum variation of F(θ) after inserting t into θ_s, and then we have the following:

$$\mathcal{I}(\mathsf{\theta }{\oplus }_{s}v)=\underset{p\in \{1,2,\dots ,\left|{\mathsf{\theta }}_s\right|+1\}}{\min }\{F(\mathsf{\theta }{\oplus }_{s,p}v)-F(\mathsf{\theta })\}$$

(21)

where θ ⊕_s,p v indicates the inclusion of sub-task v into p-th position of θ_s. Similarly, we set $ℐ$(θ ⊕_s v) = ∞ when sub-task v already exists in θ_s.

Notably, these indicators differ from those in [29] because of data dependencies among sub-tasks. Inserting or removing any sub-task v ∈ V from θ_s impacts the execution of all subsequent sub-tasks across all satellites, thereby altering F(θ).

Using these two indicators, given an offloading assignment θ = {θ₁, θ₂, …, θ_n} and two satellites s, k ∈ S connected by ISL (i.e., G[s, k] ≠ ∞), transferring a sub-task v ∈ V from satellite s to k will decrease the global fitness F(θ) as long as Condition (22) satisfies the following:

$$\mathcal{R}(\mathsf{\theta }{\ominus }_{s}v)>\mathcal{I}(\mathsf{\theta }{\oplus }_{k}v)$$

(22)

Let θ, θ′, and θ″ represent the task assignment when sub-task v is in θ_s, removed, and in θ_k, respectively. According to Equations (20) and (21), we have $ℛ$(θ ⊖_s v) = F(θ) − F(θ′) and $ℐ$(θ ⊕_s v) = F(θ″) − F(θ′). Thus, we have the new assignment θ″ with a lower F(θ″), i.e., F(θ″) < F(θ), only if $ℐ$(θ ⊕_k v) < $ℛ$(θ ⊖_s v).

Since distributed algorithms often become stuck in local optima when making greedy choices based on local communications [29], DDFTO employs five vectors, R_s, A_s, E_s, and P_s, when each satellite s ∈ S communicates with its neighbors via ISLs.

(1)

R_s = [R_s1, R_s2, …, R_s|V|]^T records the latest removal impacts for sub-tasks in V. Initially, R_sv is set to $ℛ$(θ ⊖_s v) for ∀ v ∈ θ_s, and R_sv = ∞ otherwise.

(2)

A_s = [A_s1, A_s2, …, A_s|V|]^T records the assigned satellite of sub-tasks in V as believed by s. Initially, A_sv = v for ∀ v ∈ θ_s, and A_sv = ∅ otherwise.

(3)

E_s = [E_s1, E_s2, …, E_s|V|]^T tracks the time when sub-tasks are executed by the assigned satellites as believed by s. Initially, E_sv = ${\mathcal{T}}_v^E$ for ∀ v ∈ θ_s, and E_sv = ∅ otherwise.

(4)

P_s = [P_s1, P_s2, …, P_sn]^T is a vector where entry P_sk is the timestamp that satellite s believes it received the latest information from satellite k. Initially, P_sk = 0 for ∀ k ∈ S. During communication, P_sk ∈ P_s is updated by the following rules:

$$P_{sk}=\left\{\begin{array}{cc}{\mathcal{T}}_{sk},\hfill & \hfill ifG[s,k]\ne \infty \\ {\max }_{l\in S\wedge G[s,l]\ne \infty }{P}_{lk}\hfill & \hfill otherwise\end{array}\right.$$

(23)

where $𝒯$_sk is the time when s received information from k via ISL.

Based on these vectors, we begin introducing DDFTO with its first stage, sub-task inclusion.

4.2. Sub-Task Inclusion

During the sub-task inclusion stage, each satellite s ∈ S independently adds sub-tasks to its sequence θ_s based on its local information.

Due to data dependencies among sub-tasks, any changes in θ_s will impact the execution of sub-tasks on other satellites, thereby affecting F(θ). Additionally, since only local communication is adopted, satellites cannot access the latest assignment θ. Therefore, we first employ Algorithm 1 to establish a local assignment θ^∗, leveraging the local vectors A_s and E_s of satellite s ∈ S.

Algorithm 1: Local Assignment Construction

Input: Sub-task sequence θs, vectors As = [As1, As2, …, As|V|]T and Es = [Es1, Es2, …, Es|V|]T. Output: Local assignment θ∗. 1: Initialize θ∗ = {θ1∗, θ2∗, …, θn∗} where θs∗ = ∅ for ∀ s ∈ S; 2: Let θs∗ = θs; 3: Let Πs be a sequence that sorts sub-tasks v ∈ {V/θs} in ascending order by Esv; 4: for each sub-task v in Πs 5: Let θk∗ = θk∗ ∪ v when Asv = k; 6: end 7: Output local assignment θ∗.

In Algorithm 1, after initializing θ^∗ in Line 1, we begin by setting θ_s^∗ = θ_s in Line 2 since satellite s retains its latest assignment θ_s. Subsequently, all sub-tasks v ∈ {V/θ_s} are sorted in ascending order of E_sv in Line 3. Tasks v where E_sv = ∅ are excluded from this sorting as they either have not been assigned or cannot be executed. Lines 4–6 handle the assignment of each sub-task v ∈ Π_s according to A_sv. Once all sub-tasks are assigned, the local assignment θ^∗ is finalized.

Using local assignment θ^∗, the inclusion impact vector I_s = [I_s1, I_s2, …, I_s|V|]^T is established using Equation (21), where I_sv = $ℐ$(θ^∗ ⊕_s v) for ∀ v ∈ V. Subsequently, each element of I_s is compared with the vector R_s = [R_s1, R_s2, …, R_s|V|]^T. A task v ∈ V will be inserted into θ_s if Condition (24) is satisfied:

$$\underset{v\in V}{\max }\{R_{sv}-I_{sv}\}>0$$

(24)

According to (22), when Condition (24) holds, it implies there exists a sub-task v′ = argmax_v∈V{R_sv − I_sv} whose insertion into θ_s can decrease the objective value F(θ). Sub-task v′ is then inserted into p′-th position of θ_s, where p′ = argmax_{p∈{1,2,…,|θs|+1}}{F(θ^∗ ⊕_s,pv′)− F(θ^∗)}). Next, a new θ^∗ is obtained, and vectors R_s, A_s, and E_s are updated as follows: R_sv′ = I_sv′, A_sv′ = s; the elements in E_s are refreshed using θ^∗. Subsequently, vector I_s is recalculated, and Condition (24) is checked again. This inclusion process repeats until there are no remaining sub-tasks in V/θ_s or Condition (24) is no longer satisfied. Finally, a new R_s is derived based on updated θ_s and θ^∗.

However, due to data dependencies among sub-tasks, inappropriately adding sub-tasks to satellites can result in an undesired phenomenon called deadlock. In a deadlock, multiple satellites engaged in sub-tasks become stuck in a circular waiting pattern, resulting in the entire system being suspended. Example 1 illustrates an instance of deadlock.

Example 1. 

Consider the monitoring tasks T = {t₁, t₂} in Figure 3, which are processed by two ICSC satellites S = {s₁, s₂} with assignmentθ= {θ₁, θ₂}. Here, θ₁ = {1, 3, 6, 8} and θ₂ = {5, 7, 2, 4}. For clarity, the sub-task sequences for satellites s₁ and s₂ are indicated by blue and red arcs, respectively, as shown in Figure 3. According to Figure 3, Sub-task 7 is performed before Sub-task 2, Sub-task 6 is the predecessor of Sub-task 7, and Sub-task 3 is before Sub-task 6; Consequently, Sub-task 3 must be performed prior to Sub-task 2, which contradicts the data dependence constraints that Sub-task 2 is the predecessor of Sub-task 3. Thus, a deadlock occurs inθ, with vertexes {2, 3, 6, 7} forming a cycle.

To resolve these deadlocks, a deadlock-free insertion mechanism is proposed in Section 4.3.

4.3. Deadlock-Free Insertion Mechanism

In this section, we introduce a deadlock-free insertion mechanism (DFIM) that ensures data dependencies between any consecutive sub-tasks by restricting their candidate insertion positions. The DFIM procedure is as follows:

First, using the vector E_s = [E_s1, E_s2, …, E_s|V|]^T, a local executing sequence Γ_s is created by sorting all assigned sub-tasks v ∈ V in ascending order of E_sv. As established in Section 3.2, a sub-task v can be processed only after all its predecessors $𝒫$_v have been completed, and its successors $𝒮$_v can begin execution once v is finished. Thus, the following conditions, (25) and (26), must be satisfied for each sub-task v ∈ V:

$$\underset{u\in {\mathcal{P}}_v}{\max }{\mathcal{T}}_u^E\le {\mathcal{T}}_v^E$$

(25)

$${\mathcal{T}}_v^E\le \underset{u\in {\mathcal{S}}_v}{\min }{\mathcal{T}}_u^E$$

(26)

In other words, within sequence Γ_s, the index of the inserted sub-task v must be greater than all predecessors $𝒫$_v and less than all successors $𝒮$_v simultaneously. Let (α_v^L, α_v^R) be the constraint index interval for v based on these data dependencies, where α_v^L and α_v^R are the maximum and minimum indices of sub-tasks in $𝒫$_v and $𝒮$_v, respectively. If $𝒫$_v ∩ Γ_s = ∅ (or $𝒮$_v ∩ Γ_s = ∅), we have α_v^L = −∞ (or α_v^R = ∞).

To ensure deadlock-free assignments, the index of each sub-task v ∈ θ_s within Γ_s is determined. For a potential inclusion position p ∈ {1, 2, …, |θ_s|+1}, let (β_p^L, β_p^R) denote the position index interval after inserting a sub-task into the p-th position of θ_s. Here, β_p^L and β_p^R represent the indices of the preceding sub-task θ_s[p − 1] and the following sub-task θ_s[p], respectively. Specifically, when p = 1 (or p = |θ_s| + 1), we have β_p^L = −∞ (or β_p^R = ∞).

To ensure assignment θ is deadlock-free, Proposition 1 must be satisfied.

Proposition 1. 

An assignment θ with the corresponding executing sequence Γ is deadlock-free if every sub-task v ∈ V is executed between sub-tasks γ_L(v) and γ_R(v), which have the maximum and minimum index in Γ among predecessors $𝒫$_v and successors S_v, respectively.

Proof. 

Since Γ is determined by the executing time of sub-tasks, γ_L(v) and γ_R(v) are the latest executed sub-task in $𝒫$_v and the earliest in $𝒮$_v. Thus, $𝒯$_γL(v)^E = max_u∈$𝒫$v$𝒯$_u^E and $𝒯$_γR(v)^E = min_u∈$𝒮$v$𝒯$_u^E. If v is executed between γ_L(v) and γ_R(v), it implies that $𝒯$_v^E ≥ $𝒯$_γL(v)^E = max_u∈$𝒫$v$𝒯$_u^E and $𝒯$_v^E ≤ $𝒯$_γR(v)^E = min_u∈$𝒮$v$𝒯$_u^E exist, satisfying Conditions (25) and (26), fulfilling the data dependence constraints involving v. Therefore, if every sub-task v ∈ V is executed exactly between sub-tasks γ_L(v) and γ_R(v), all data dependence constraints are satisfied, ensuring that assignment θ is deadlock-free. □

Given a sub-task v ∈ V/θ_s and inclusion position p ∈ {1, 2, …, |θ_s| + 1}, the constraint index interval (α_v^L, α_v^R) and position index interval (β_p^L, β_p^R) are recalled. If (α_v^L, α_v^R) ∩ (β_p^L, β_p^R) ≠ ∅, there is at least one valid index for inserting v into the p-th position of θ_s, ensuring that v is executed between γ_L(v) and γ_R(v). According to Proposition 1, this guarantees that the data dependence constraints involving v are satisfied. By verifying each inserted sub-task, all constraints are met, ensuring a deadlock-free assignment θ_s. Hence, avoiding deadlock in θ equates to determining the intersection between (α_v^L, α_v^R) and (β_p^L, β_p^R) for each sub-task v and position p.

Based on the above analysis, we developed the DFIM (Algorithm 2) to resolve the deadlock problem in assignment θ.

Algorithm 2: Deadlock-Free Insertion Mechanism (DFIM)

Input: Sub-task sequence θs, vectors Es, candidate sub-task v. Output: Candidate insertion positions Φs,v. 1: Initialize Φs,v = ∅; 2: Obtain local executing sequence Γs based on Es; 3: Obtain predecessors $𝒫$v and successors $𝒮$v of v; 4: Obtain constraint index interval (αvL, αvR) using $𝒫$v, $𝒮$v, and Γs; 5: for each position p ∈ {1, 2, …, |θs|+1} 6: Determine position index interval (βpL, βpR) using θs and Γs; 7: if αvL < βpR and βpL < αvR // i.e., (αvL, αvR) ∩ (βpL, βpR) ≠ ∅ 8: Φs,v = Φs,v ∪ {p}; 9: end 10: end 11: Output candidate insertion positions Φs,v.

In DFIM, we first generate local executing sequence Γ_s using vector E_s and then identify the predecessors $𝒫$_v and successors $𝒮$_v of sub-task v (Lines 1–3). Next, we calculate the constraint index interval (α_v^L, α_v^R) using $𝒫$_v, $𝒮$_v, and Γ_s in Line 4. After that, each candidate insertion position p ∈ {1, 2, …, |θ_s| + 1} is checked (Lines 5–10). For position p, we determine the position index interval (β_p^L, β_p^R) in Line 6. If the condition α_v^L < β_p^R and β_p^L < α_v^R (Line 7) is met, indicating an intersection between (α_v^L, α_v^R) and (β_p^L, β_p^R), we add position p into Φ_s,v. The loop continues until all positions are checked. Finally, we obtain the candidate insertion positions Φ_s,v. Example 2 illustrates the process of applying DFIM.

Example 2. 

Figure 4 illustrates the application of DFIM to find candidate insertion positions for Sub-task 7 in satellite s₂, based on the scenario in Figure 3. Here, the task offloading assignment is θ = {θ₁, θ₂}, where θ₁ = {1, 3, 6, 8} and θ₂ = {5, 2, 4}. First, Figure 4a shows the local executing sequence Γ₂ = {5, 1, 2, 3, 6, 4, 8} for s₂. The data-dependent constraints for Sub-task 7 are $𝒫$₇ = {6} and $𝒮$₇ = {8}, resulting in the constraint index interval (α₇^L, α₇^R) = (5, 7), shown in Figure 4b. Next, for |θ₂| = 3, we evaluate each possible insertion position p ∈ {1, 2, …, 4}. When position p = 1 (i.e., inserting Sub-task 7 before Sub-task 5), the position index interval (β₁^L, β₁^R) = (−∞, 1). Since (5, 7) ∩ (−∞, 1) = ∅, position p = 1 is rejected (Figure 4c). When position p = 2 (i.e., inserting Sub-task 7 between Sub-tasks 5 and 2), the interval (β₂^L, β₂^R) = (1, 3). Since (5, 7) ∩ (1, 3) = ∅, position p = 2 is also rejected (Figure 4d). When position p = 3 (i.e., inserting Sub-task 7 between Sub-tasks 2 and 4), the interval (β₃^L, β₃^R) = (3, 6). Since (5, 7) ∩ (3, 6) = (5, 6), this position is valid, meaning Sub-task 7 can be placed between Sub-tasks 6 and 4. Thus, position p = 3 is added to Φ_2,7 (Figure 4e). When position p = 4 (i.e., inserting Sub-task 7 after Sub-task 4), the interval (β₄^L, β₄^R) = (6, +∞). Since (5, 7) ∩ (6, +∞) = (6, 7), this position is also valid, allowing Sub-task 7 to be placed between Sub-tasks 4 and 8. Thus, position p = 4 is added to Φ_2,7 (Figure 4f). Thus, the candidate insertion positions for inserting Sub-task 7 in satellite s₂ are Φ_2,7 = {3, 4}.

Proposition 2. 

DFIM has polynomial time complexity and ensures deadlock-free assignments.

Proof. 

For sequence θ_s and sub-task v ∈ V/θ_s, a total of (|θ_s| + 1) candidate positions are evaluated, meaning the check in Line 7 repeats (|θ_s| + 1) times. Since θ_s has at most (|V| − 1) sub-tasks before inserting v, we have |θ_s| ≤ |V| − 1. Therefore, the complexity of DFIM is O(|V|), and DFIM is polynomial.

According to Proposition 1, if all sub-tasks v ∈ V are executed between γ_L(v) and γ_R(v), assignment θ is deadlock-free. For a sequence θ_s and a sub-task v ∈ V/θ_s, DFIM identifies candidate insertion positions Φ_s,v. Any position p in Φ_s,v ensures that inserting sub-task v into the p-th position of θ_s guarantees v is executed between γ_L(v) and γ_R(v), satisfying data dependence constraints. Therefore, inserting sub-task v ∈ V/θ_s into positions Φ_s,v identified by DFIM ensures deadlock-free assignments. □

By using DFIM to obtain deadlock-free insertion positions for each sub-task, the entire sub-task inclusion stage is summarized as follows:

In Algorithm 3, we start by determining local assignment θ^∗ and initialize inclusion impact vector I_s for satellite s (Lines 1–2). Then, in Lines 3–6, we use DFIM to identify deadlock-free insertion positions for each sub-task v ∈ V / θ_s within task sequence θ_s. We record the minimum insertion impact value for each sub-task v in I_sv, thus obtaining the insertion impact vector I_s. Next, in Lines 5–9, we use Condition (24) to identify the sub-task v′ and its insertion position p′ that provides the maximum reduction in F(θ) and perform the insertion. After updating vectors R_s, A_s, and E_s, and solution θ^∗, we recalculate vector I_s (Lines 2–6), and recheck Condition (24) for the remaining sub-tasks. The sub-task inclusion stage ends when there are no remaining tasks or when Condition (24) is no longer met. This means that no further adjustments to the current task sequence will reduce F(θ), so the algorithm outputs sequence θ_s′.

Algorithm 3: Sub-task inclusion

Input: Sub-task set V, sequence θs, vectors Rs, As, and Es. Output: New sequence θs′, new vectors Rs′, As′, and Es′. 1: Obtain local assignment θ∗ by Algorithm 1; 2: Initialize inclusion impact vector Is = [Is1, Is2, …, Is|V|]T; 3: for each sub-task v ∈ V/θs 4: Obtain candidate insertion positions Φs,v using DFIM in Algorithm 2; 5: $\mathrm{Let}{I}_{sv}=\arg {\min }_{p\in {\mathsf{\Phi }}_{s,v}}\{F({\mathsf{\theta }}^{\ast }{\oplus }_{s,p}v)-F({\mathsf{\theta }}^{\ast })\}$; 6: end 7: while {V/θs} ≠ ∅ and maxv∈V{Rsv − Isv} > 0 8: Obtain sub-task v′ = maxv∈V{Rsv − Isv} and corresponding position p′ in θs; 9: Insert sub-task v′ into p′-th position of θs; 10: Update θ∗, Rs, and As by setting θs∗ = θs, Rsv′ = Isv′, and Asv′ = s; 11: Recalculate Es according to θ∗; 12: Recalculate Is using Lines 2–6; 13: end 14: Recalculate Rs according to θ∗; 15: Let θs′ = θs, Rs′ = Rs, As′ = As, and Es′ = Es; 16: Output θs′, Rs′, As′, and Es′.

4.4. Consensus and Sub-Task Removal

The consensus and sub-task removal stage involves the following two key processes: the consensus process and the task removal process. During the consensus process, each satellite s ∈ S uses local communications via ISLs to agree on common R_s, A_s, and E_s. In the task removal process, any conflicting tasks (those assigned to multiple satellites) are removed from the satellite sequences.

4.4.1. Consensus

The consensus process involves the following steps. First, each satellite k ∈ S broadcasts its vectors R_k, A_k, E_k, and P_k to neighboring satellites s (with G[k, s] ≠ ∞) via ISL. Upon receiving this information, each satellite s ∈ S updates its vectors R_s, A_s, and E_s using a consensus rule, modified by [34], to ensure uniform values across all satellites.

At time $𝒯$_ks, vectors R_k = [R_k1, R_s2, …, R_k|V|]^T, A_k = [A_k1, A_k2, …, A_k|V|]^T, E_k = [E_k1, E_k2, …, E_k|V|]^T, and P_k = [P_k1, P_k2, …, P_kn]^T are transmitted from sending satellite k to satellite s via ISL. Satellite s then updates its timestamp vector P_s based on time $𝒯$_ks and vector P_k using Equation (23). For each sub-task v ∈ V, elements R_sv, A_sv, and E_sv of vectors R_s, A_s, and E_s are updated according to

Table 2. Action rules for satellite k after receiving information from satellite s.

Value of Akv in Sending Satellite k	Value of Asv in Receiving Satellite s	Actions Adopted by s
k	s	if Rkv < Rsv → Update
	k	Update
	a ∉ {k, s}	if Pka > Psa or Rkv < Rsv → Update
	∅	Update
s	s	Maintain
	k	Reset
	a ∉ {k, s}	if Pka > Psa → Reset
	∅	Maintain
a ∉ {k, s}	s	if Pka > Psa and Rkv < Rsv → Update
	k	if Pka > Psa → Update else → Reset
	a	Pka > Psa → Update
	b ∉ {k, s, a}	if Pka > Psa and Pkb > Psb → Update if Pka > Psa and Rkv < Rsv → Update if Pkb > Psb and Pka < Psa → Reset
	∅	if Pka > Psa → Update
∅	s	Maintain
	k	Update
	a ∉ {k, s}	if Pka > Psa → Update
	∅	Maintain

, which specifies three possible actions for satellite s, with Maintain being the default, as follows:

(1)

Update: Set R_sv = R_kv, A_sv = A_kv, and E_sv = E_kv.

(2)

Maintain: Set R_sv = R_sv, A_sv = A_sv, and E_sv = E_sv.

(3)

Reset: Swr R_sv = ∞, A_sv = ∅, and E_sv = ∅.

The consensus process continues until all satellites s ∈ S agree on common values for R_s, A_s, and E_s. This process is essential to prevent R_s and E_s from converging to non-existent values, which could occur if these values were broadcast directly to all satellites [29].

4.4.2. Sub-Task Removal

After reaching a consensus on the common R_s, A_s, and E_s values, each satellite performs a modified sub-task removal process independently. This process involves removing conflicting tasks from its own assignment θ_s.

For each satellite s ∈ S, we first create local assignment θ^∗ using the common vectors R_s, A_s, and E_s with Algorithm 1. Based on θ^∗, we identify the pending removal tasks Γ_s = {v ∈ θ_s|A_sv ≠ s}. These tasks are present in θ_s but should not be offloaded to s according to the consensus A_s. We then compute the local removal impact vector R_s^• = [R_s1^•, R_s2^•, …, R_s|V|^•]^T based on θ^∗, where R_sv^• = $ℛ$(θ^∗ ⊕_s v) for ∀v ∈ θ_s^∗, and R_sv^• = 0 otherwise. A sub-task v ∈ Γ_s will be removed from θ_s if it meets the criterion defined in Equation (27).

$$\underset{v\in {\mathsf{\Gamma }}_s}{\max }\{R_{sv}^{•}-R_{sv}\}>0$$

(27)

when Criterion (27) is satisfied, it means there is a sub-task v ∈ Γ_s whose removal impact value R_sv^• is higher than consensus results R_sv. This indicates that the assignment of v in θ_s is worse. Therefore, we remove the sub-task v′ = argmax_{v ∈ Γs}{R_sv^• − R_sv} from both θ^∗ and Γ_s. After removing the sub-task, we update θ^∗ and R_s^•, then re-evaluate the criterion. This process continues until Γ_s = ∅ or no sub-task meets Criterion (27). Finally, the remaining sub-tasks in Γ_s are retained in θ_s. We update R_sv = $ℛ$(θ^∗ ⊕_s v) and A_sv = s for each v ∈ Γ_s and recalculate the vector E_s based on θ^∗. Algorithm 4 outlines the entire sub-task removal process.

Algorithm 4: Sub-task removal

Input: sequence θs, vectors Rs, As, and Es. Output: new sequence θs′, new vectors Rs′, As′, and Es′. 1: Obtain local assignment θ∗ using Algorithm 1; 2: Identify pending removal sub-tasks Γs = {v ∈ θs | Asv ≠ s} by θ∗ and As; 3: Calculate local removal impact vector Rs• = [Rs1•, Rs2•, …, Rs|V|•]T by θ∗; 4: while Γs ≠ ∅ and (27) is satisfied 5: $\mathrm{Obtain}\mathrm{sub}\text{-}\mathrm{task}{v}^{\prime }=\arg {\max }_{v\in {\mathsf{\Gamma }}_s}\{R_{sv}^{•}-R_{sv}\}$; 6: Remove v′ from both θs∗ and Γs; 7: Update θ∗ and Rs•; 8: end 9: for each remaining sub-tasks v ∈ Γs 10: Set Rsv = R(θ ⊕s v) and Asv = s; 11: end 12: Update Es based on θ∗; 13: Let θs′ = θs∗, Rs′ = Rs, As′ = As and Es′ = Es; 14: Output θs′, Rs′, As′, and Es′.

4.5. Framework of DDFTO

The proposed DDFTO algorithm combines the two abovementioned stages and operates as follows:

DDFTO runs in parallel across each satellite, alternating between the sub-task inclusion stage and the consensus and sub-task removal stage. During the task inclusion stage, each satellite s ∈ S independently integrates sub-tasks. The DFIM is used to limit the positions where sub-tasks can be inserted, thereby avoiding deadlocks. After that, the consensus and sub-task removal stage is performed. In the consensus process, common vectors R_s, A_s, and E_s are established among all satellites. In the sub-task removal process, satellites eliminate conflicting sub-tasks from their sequences. The algorithm terminates when there are no further changes in θ across all satellites. A summary of the entire DDFTO process is provided in Algorithm 5 and Figure 5.

Algorithm 5: Distributed Deadlock-Free Task Offloading (DDFTO)

Input: satellites S, monitoring tasks T, network topology matrix G. Output: task assignment θ. 1: Obtain sub-task set V according to T; 2: Initialize θ = {θs | s ∈ S} with θs = ∅ for all satellites s ∈ S; 3: Initialize Rs, As, Es, and Ps for each satellite s ∈ S; 4: Set converged to false; 5: while converged is false do // Sub-task inclusion stage 6: Use Algorithm 3 to include sub-tasks for each satellite s ∈ S; // Consensus process 7: Send vectors Rk, Ak, Ek, and Pk from each satellite k ∈ S to its neighbors s   where G[k, s] ≠ ∞; 8: Update Ps for each s ∈ S based on received information; 9: Perform the consensus process (refer to Table 2) for each s ∈ S until a common Rs,    As, Es is reached;    // Sub-task removal process 10: Use Algorithm 4 to remove sub-tasks for each satellite s ∈ S; 11: Check convergence and update converged; 12: end 13: Output assignment θ.

4.6. Convergence and Complexity Analysis

We begin by analyzing the convergence of DDFTO. Similar to the methods in [28,29], each satellite s ∈ S iteratively adjusts its task sequence θ_s by adding or removing tasks to optimize F(θ). As stated in Equation (24), modifications to θ_s are only made if they reduce F(θ). To avoid deadlocks, DFIM is integrated into DDFTO to restrict inappropriate positions for sub-task insertion. Inserting sub-tasks into these restricted positions can cause deadlocks, impacting their execution and resulting in F(θ) = ∞. Therefore, using DFIM does not hinder DDFTO’s ability to achieve a better F(θ) value and allows it to optimize F(θ) effectively. Based on this analysis, DDFTO converges when no further changes to θ occur during iterations, indicating that no sub-task adjustments can further improve F(θ).

Next, we discuss the complexity of DDFTO. There are n ICSC satellites and m monitoring tasks, consisting of |V| sub-tasks. DDFTO alternates between the sub-task inclusion stage and the consensus and sub-task removal stage. During the sub-task inclusion stage, each of n ICSC satellites independently includes up to |V| sub-tasks in their task sequence. To avoid deadlocks, DFIM is used to restrict candidate insertion positions for each sub-task on each satellite. This results in a task inclusion stage complexity of O(n|V|²). In the consensus process, each of n ICSC satellites updates its vectors for |V| sub-tasks based on information from up to four neighboring satellites. The complexity for this stage is O(4n|V|). In the task removal process, each of the n ICSC satellites independently removes up to |V| conflicting sub-tasks from their task sequences, resulting in a complexity of O(n|V|). Therefore, the computational complexity for each iteration of DDFTO is O(n|V|²) + O(4n|V|) + O(n|V|) = O(n(|V|²+5|V|)). Assuming K is the number of iterations required for DDFTO to converge, the total computational complexity of DDFTO is O(nK(|V|²+5|V|)). Thus, DDFTO has a polynomial computational complexity.

5. Computational Experiments

In this section, extensive computation experiments are conducted to evaluate the performance of the proposed DDFTO.

5.1. Experimental Setup

We set up an ICSC simulation environment in Python, similar to previous works [33,35,36]. This simulation uses six Walker Delta constellations A–F, as described in

Table 3. Satellite constellations.

Constellation	Altitude (km)	Inclination (deg)	Planes	Satellites (n)
A	5000	138.58	2	6
B	5000	138.58	3	9
C	3000	112.42	4	16
D	480	97.33	3	24
E	550	97.59	6	36
F	780	98.52	6	66

, each with different orbital altitudes and numbers of satellites, but all positioned in sun-synchronous orbits to meet the demands of Earth observation. The simulation period spans from [1 July 2024 00:00:00.000 UTCG] to [7 July 2024 00:00:00.000 UTCG]. Satellite coordinates and time windows TW_vs for each sub-task v ∈ V and satellite s ∈ S are obtained from the Satellite Tool Kit (STK). Figure 6 shows the process for determining these time windows.

The experiments are organized into three groups, small, medium, and large, creating a total of 3 × 12 = 36 combinations, with parameter sizes detailed in

Table 4. Parameter size for each instance type.

Instance Type	Constellations	Target Number	Target Density	Combination Number
Small	A, B	3, 5, 8	high, low	2 × 3 × 2 = 12
Medium	C, D	10, 12, 15	high, low	2 × 3 × 2 = 12
Large	E, F	20, 25, 30	high, low	2 × 3 × 2 = 12

. Each combination includes ten test instances. In each instance, monitoring target positions are randomly generated, with average distances of about 100 km for high-density scenarios and 1000 km for low-density scenarios. We use the same parameters as in works [33,37], and additional parameters used in the experiments are detailed in

Table 5. Simulation parameters.

Parameters	Default Values
Computing capacity of satellites Cs	3~5 GHz
Number of sub-tasks |Vt|	2~4
Workload of sub-tasks ξv	1~1.5 Kcycle/bit
Imaging time of sub-tasks ρv	10~20 s
Input data size of sub-tasks dvI	50~100 Mbit
Output data size of sub-tasks dvO	50~100 Mbit
Rate of ISL RISL	100 Mbps
Transition power ηx	1 w
Angle transition power ηa	0.2 w
Observation power ηo	1 w
Effective capacitance coefficient κ	10−28

.

Then, we implement our DDFTO algorithm and compare it with three benchmark algorithms as follows:

(1)

DALEOS [21]: A distributed algorithm that uses heuristics to select a controller satellite for each monitoring task and a flooding mechanism to assign satellites for each sub-task. This competitor retains its original design but adopts DFIM to handle deadlocks.

(2)

Local Execution: Each monitoring task is performed by the nearest visible ICSC satellite without any inter-satellite coordination.

(3)

Random Offloading: Sub-tasks are sorted based on their data dependencies, and ICSC satellites are randomly selected for them.

In our experiments, we use the following three performance indicators:

• Relative Percent Value (RPV): This measures the relative percentage value of F(θ) compared to other algorithms.

  $$RPV={\displaystyle \frac{F(\mathsf{\theta })-F_{best}}{F_{worst}-F_{best}}}$$

  (28)

  Here, F(θ) is the fitness of an algorithm for a test instance, while F_worst and F_best are the worst and best fitness values obtained using all algorithms for the same instance. A lower RPV indicates better performance, eliminating the influence of different test instances.
• Service Latency (SL): This refers to the performance index F₁, which is the maximum completion time for all tasks and is calculated using Formula (12).
• Energy Consumption (EC): This refers to the performance index F₂, which is the energy consumption for performing all sub-tasks and is calculated using Equation (13).

To reduce randomness, each algorithm is independently run 10 times for every test instance. The average values of the performance indicators (aRPV, aSL, and aEC) are then used to evaluate each algorithm. All algorithms are coded in Python and run on a PC with an Intel Core i7-14700k [email protected] GHz and 64 GB of RAM in the 64-bit Windows 11 operating system.

5.2. Deadlock Statistics

To evaluate the necessity and effectiveness of the proposed DFIM algorithm in avoiding deadlocks, we conducted two rounds of experiments.

First, we statistically evaluated the deadlock rate in randomly generated individuals to emphasize the importance of avoiding deadlocks. Using the instance types from Section 5.1, we generated 10 test instances for each combination. In each test instance, 1000 offloading assignments were randomly generated, resulting in a total of 10,000 assignments per instance type. We recorded the number of deadlock-free assignments and the deadlock rate for each combination in

Table 6. Statistical results of deadlock in small-scale instances.

Instance Type	Total Assignment Number	Deadlock-Free Assignments	Deadlock Rate	Deadlock-Free Assignments (Using DFIM)	Deadlock Rate (Using DFIM)
{A, 3, high}	10,000	4363	56.37%	10,000	0%
{A, 3, low}	10,000	5464	45.36%	10,000	0%
{A, 5, high}	10,000	2544	74.56%	10,000	0%
{A, 5, low}	10,000	2108	78.92%	10,000	0%
{A, 8, high}	10,000	510	94.90%	10,000	0%
{A, 8, low}	10,000	786	92.14%	10,000	0%
{B, 3, high}	10,000	6488	35.12%	10,000	0%
{B, 3, low}	10,000	6431	35.69%	10,000	0%
{B, 5, high}	10,000	4656	53.44%	10,000	0%
{B, 5, low}	10,000	3660	63.40%	10,000	0%
{B, 8, high}	10,000	1995	80.05%	10,000	0%
{B, 8, low}	10,000	1760	82.40%	10,000	0%

,

Table 7. Statistical results of deadlock in medium-scale instances.

Instance Type	Total Assignment Number	Deadlock-Free Assignments	Deadlock Rate	Deadlock-Free Assignments (Using DFIM)	Deadlock Rate (Using DFIM)
{C, 10, high}	10,000	2248	77.52%	10,000	0%
{C, 10, low}	10,000	2782	72.18%	10,000	0%
{C, 12, high}	10,000	1780	82.20%	10,000	0%
{C, 12, low}	10,000	1887	81.13%	10,000	0%
{C, 15, high}	10,000	1117	88.83%	10,000	0%
{C, 15, low}	10,000	1244	87.56%	10,000	0%
{D, 10, high}	10,000	4703	52.97%	10,000	0%
{D, 10, low}	10,000	4489	55.11%	10,000	0%
{D, 12, high}	10,000	3738	62.62%	10,000	0%
{D, 12, low}	10,000	3768	62.32%	10,000	0%
{D, 15, high}	10,000	2680	73.20%	10,000	0%
{D, 15, low}	10,000	3000	70.00%	10,000	0%

and

Table 8. Statistical results of deadlock in large-scale instances.

Instance Type	Total Assignment Number	Deadlock-Free Assignments	Deadlock Rate	Deadlock-Free Assignments (Using DFIM)	Deadlock Rate (Using DFIM)
{E, 20, high}	10,000	3009	69.91%	10,000	0%
{E, 20, low}	10,000	2340	76.60%	10,000	0%
{E, 25, high}	10,000	1866	81.34%	10,000	0%
{E, 25, low}	10,000	1753	82.47%	10,000	0%
{E, 30, high}	10,000	816	91.84%	10,000	0%
{E, 30, low}	10,000	659	93.41%	10,000	0%
{F, 20, high}	10,000	5616	43.84%	10,000	0%
{F, 20, low}	10,000	5385	46.15%	10,000	0%
{F, 25, high}	10,000	4902	50.98%	10,000	0%
{F, 25, low}	10,000	4940	50.60%	10,000	0%
{F, 30, high}	10,000	3803	61.97%	10,000	0%
{F, 30, low}	10,000	3853	61.47%	10,000	0%

, and the results indicated that deadlocks occur in all combinations. Notably, instances with a high m/n ratio, in which fewer ICSC satellites must perform more monitoring tasks, were more likely to violate dependent constraints increasing the deadlock rates. Figure 7 further illustrates the variation in deadlock rates across different instance types. For instances with the same monitoring tasks, more satellites provided sub-tasks with more options, leading to fewer constraint violations and a lower deadlock rate. Conversely, instances with the same constellation but more monitoring tasks resulted in each satellite executing more sub-tasks, increasing constraint violations and deadlock rates. Specifically, for instances of types {A, 8, high}, {A, 8, low}, {E, 30, high}, and {E, 30, low}, the deadlock rate exceeds 90%, underscoring the necessity of proposed DFIM.

Next, we reused these test instances and generated individuals using DFIM. The number of deadlock-free assignments and deadlock rates are still recorded in Table 6. The results show that all obtained assignments are deadlock-free, demonstrating the effectiveness of the proposed DFIM.

5.3. Comparison with Existing Algorithms

In this section, we conduct a comparative analysis of the proposed DDFTO algorithm against three benchmark algorithms, local execution, random offloading, and DALEOS [21], as described in Section 5.1. The comparison results for small-scale, medium-scale, and large-scale instances are presented in

Table 9. Comparison results for small-scale instances.

Instance Type	Local Execution			Random Offloading			DALEOS			DDFTO
	aRPV	aSL	aEC	aRPV	aSL	aEC	aRPV	aSL	aEC	aRPV	aSL	aEC
{A, 3, high}	0.4282	435.53	888.45	0.6311	8924.26	938.27	0.0662	101.23	767.55	0.0025	44.75	932.11
{A, 3, low}	0.2010	1146.07	819.03	0.9022	9147.02	788.91	0.0235	517.16	632.49	0.0000	45.16	756.99
{A, 5, high}	0.1660	1071.96	1461.31	0.9083	16,785.53	1482.37	0.1040	145.40	1194.32	0.0000	66.24	1414.82
{A, 5, low}	0.0870	433.65	1400.80	1.0000	25,363.96	1452.15	0.0158	159.80	1220.32	0.0000	64.13	1427.90
{A, 8, high}	0.0486	2061.53	2219.58	1.0000	34,354.58	2361.44	0.1075	4550.04	1903.00	8.1 × 10−4	232.85	2283.35
{A, 8, low}	0.0360	892.74	2201.61	1.0000	21,941.94	2453.22	0.0185	579.46	1836.03	0.0000	117.04	2348.60
{B, 3, high}	0.6890	198.44	680.42	0.5524	3956.77	866.58	0.1950	93.53	625.64	0.0000	48.76	704.52
{B, 3, low}	0.7997	176.54	787.17	0.3899	565.41	897.56	0.2479	81.41	692.39	0.0000	46.87	753.15
{B, 5, high}	0.2380	392.66	1332.97	0.8181	14,630.02	1524.08	0.0905	155.81	1120.63	0.0000	64.01	1349.24
{B, 5, low}	0.1228	505.25	1377.86	0.9132	19,065.12	1507.31	0.0082	147.77	1121.28	0.0000	62.97	1313.57
{B, 8, high}	0.0192	435.63	2090.45	1.0000	27,635.11	2491.37	0.0035	212.63	1762.70	0.0000	117.98	2143.24
{B, 8, low}	0.1189	349.83	2234.25	0.8306	18,097.47	2436.95	0.2047	225.83	1795.80	0.0448	93.68	2175.48
OVAR	0%	0%	0%	0%	0%	0%	0%	0%	100%	100%	100%	0%

,

Table 10. Comparison results for medium-scale instances.

Instance Type	Local Execution			Random Offloading			DALEOS			DDFTO
	aRPV	aSL	aEC	aRPV	aSL	aEC	aRPV	aSL	aEC	aRPV	aSL	aEC
{C, 10, high}	0.0076	160.70	2866.59	1.0000	13,253.09	3145.13	0.0100	231.07	2311.41	0.0000	97.37	2658.69
{C, 10, low}	0.0037	138.73	2707.94	1.0000	15,278.85	2993.54	0.0065	190.14	2242.34	0.0000	104.50	2496.39
{C, 12, high}	0.0054	180.89	3352.48	1.0000	17,310.71	3599.32	0.0631	1968.20	2685.99	0.0000	119.96	3039.99
{C, 12, low}	0.0057	171.26	3068.45	1.0000	15,403.01	3393.81	0.0129	293.63	2456.52	1.3 × 10−4	116.07	2785.90
{C, 15, high}	0.0025	168.08	4125.30	1.0000	21,064.08	4473.35	0.0085	356.05	3211.75	7.5 × 10−4	151.28	4059.67
{C, 15, low}	0.0027	202.87	4017.56	1.0000	18,305.66	4436.20	0.0057	295.03	3242.79	1.4 × 10−5	147.95	3793.53
{D, 10, high}	0.0894	2167.18	2386.86	1.0000	24,468.14	2921.72	0.0021	149.65	2185.80	0.0000	88.99	2240.79
{D, 10, low}	0.0687	1804.67	2728.45	1.0000	26,929.55	3141.48	0.0030	171.68	2285.22	0.0000	72.20	2625.68
{D, 12, high}	0.1266	2395.76	3061.00	1.0000	33,719.68	3408.30	0.0035	178.00	2647.14	0.0000	95.45	2919.24
{D, 12, low}	0.2057	2999.81	2886.58	0.9000	30,512.77	3469.72	0.0164	651.31	2629.05	0.0010	111.54	2887.50
{D, 15, high}	0.0782	3096.26	3642.95	1.0000	38,568.15	4123.19	0.0115	659.70	3188.66	0.0000	111.95	3375.34
{D, 15, low}	0.1809	2845.50	3469.26	0.9353	27,362.24	4148.23	0.0042	218.99	2989.42	0.0000	116.30	3461.84
OVAR	0%	0%	0%	0%	0%	0%	0%	0%	100%	100%	100%	0%

and

Table 11. Comparison results for large-scale instances.

Instance Type	Local Execution			Random Offloading			DALEOS			DDFTO
	aRPV	aSL	aEC	aRPV	aSL	aEC	aRPV	aSL	aEC	aRPV	aSL	aEC
{E, 20, high}	0.0050	318.10	5006.04	1.0000	36,845.37	5539.21	0.0013	213.55	4341.25	0.0000	147.74	4351.55
{E, 20, low}	0.0060	318.60	5128.57	1.0000	33,922.07	6008.57	0.0018	230.05	4355.02	0.0000	142.95	4642.19
{E, 25, high}	0.0055	379.18	6477.22	1.0000	38,514.60	7572.58	0.0134	743.56	5324.09	0.0000	146.19	6060.81
{E, 25, low}	0.0047	342.66	6439.91	1.0000	36,048.58	7386.28	0.0357	1953.49	5495.79	2.7 × 10−4	177.61	6345.95
{E, 30, high}	0.0050	414.72	7626.81	1.0000	40,356.60	8644.88	0.0411	2181.07	6340.72	0.0000	214.89	7198.28
{E, 30, low}	0.0045	435.62	7726.61	1.0000	47,409.99	8695.02	0.0132	1296.27	6416.82	0.0000	226.90	7361.69
{F, 20, high}	0.0098	154.74	4957.87	1.0000	25,687.84	5922.47	0.0052	186.22	4507.42	9.5 × 10−6	111.55	4479.23
{F, 20, low}	0.0014	131.13	4802.05	1.0000	19,089.41	5877.35	0.0112	221.64	4301.81	0.0042	140.55	4510.62
{F, 25, high}	5.3 × 10−4	141.83	6319.60	1.0000	31,898.81	7375.91	0.0159	742.02	5516.96	2.6 × 10−4	153.17	5668.86
{F, 25, low}	7.8 × 10−4	143.23	5953.34	1.0000	21,702.09	7201.70	0.0036	236.78	5331.03	0.0014	162.01	5549.13
{F, 30, high}	1.5 × 10−4	130.86	7986.29	1.0000	29,388.36	8764.14	0.1245	3857.84	6733.56	0.0031	232.95	7153.58
{F, 30, low}	4.5 × 10−4	158.90	7555.69	1.0000	33,801.74	8636.41	0.0994	6797.18	6515.08	3.8 × 10−4	176.34	6733.99
OVAR	25%	41.67%	0%	0%	0%	0%	0%	0%	91.66%	75%	58.33%	8.33%

, respectively. In these tables, the optimal values for each metric within the same instance type are highlighted in bold, and optimal value achievement rates (OVARs) are calculated.

From Table 9, Table 10 and Table 11, it is evident that the performance of these algorithms varies significantly in terms of aRPV, aSL, and aEC. The DDFTO algorithm achieved the optimal aRPV and aSL values in most instances. Although DALEOS obtained more optimal aEC values, its disadvantages in service latency resulted in a lower overall aRPV compared to the proposed DDFTO. To further illustrate the variations of three metrics for each algorithm across different instances, we have plotted line charts, as shown in Figure 8, Figure 9 and Figure 10.

Figure 8 illustrates the variation of aRPV values for different algorithms. Smaller aRPV values indicate obtained assignments with better objective F(θ) values. The DDFTO algorithm achieves the optimal aRPV values in nearly all instances. For example, in instances of type {A, 3}, the aRPV values achieved by DDFTO are reduced by 99.58% (≈(0.3146–0.0013)/0.3146), 99.83% (≈(0.7666–0.0013)/0.7666), and 97.10% (≈(0.0449–0.0013)/0.0449) compared to local execution, random offloading, and DALEOS, respectively. This demonstrates the effectiveness of DDFTO in obtaining optimal offloading assignments. Additionally, DDFTO consistently obtained smaller aRPV values than DALEOS. This is because DALEOS uses a flooding mechanism [21] that relies on direct neighbor information and is more easily trapped into local optima [28], affecting the quality of the offloading assignments. In contrast, DDFTO employs a consensus process [34], in which satellites share information with their neighbors using vectors, allowing it to escape local optima and achieve better results [29]. Furthermore, for instances of type {F, 25} and {F, 30}, local execution shows a slight advantage in aRPV values. This is because, for larger-scale instances, the DDFTO offloading assignments require satellite cooperation, leading to data transmission delays and increased service latency. In contrast, local execution keeps all sub-tasks of a task on a single satellite, eliminating data transmission and resulting in lower service latency.

Figure 9 illustrates the trends in aSL values for various algorithms across different instances. A lower aSL value indicates reduced service latency. DDFTO consistently achieves the lowest aSL values in nearly all instances. For example, in instances of type {E, 30}, the aSL of DDFTO is decreased by 48.04% (≈(425.17–220.89)/425.17), 97.45% (≈(8669.95–220.89)/8669.95), and 87.29% (≈(1738.67–220.89)/1738.67) compared with local execution, random offloading, and DALEOS, respectively. This highlights the effectiveness of DDFTO’s consensus process in minimizing service latency. In contrast, random offloading consistently shows higher aSL values than other algorithms, with a significant increase as instance size grows, underscoring the importance of effective offloading strategies.

Figure 10 shows the aEC trends of different algorithms across various instances. Smaller aEC values indicate lower energy consumption for performing tasks. As instance size increases, the aEC values for all algorithms also increase. Despite this, the performance ranking of the four algorithms remains consistent. DALEOS achieves the lowest aEC values in most cases, demonstrating the effectiveness of its heuristic-based control agent selection strategy. Although the proposed DDFTO achieves slightly higher aEC values, its outstanding performance in reducing service latency results in the best overall F(θ) values in most instances.

6. Discussion

Finally, we explore how instance parameters (satellite constellations and the number of monitoring tasks m) affect DDFTO and other benchmark algorithms. Our experiments are categorized into two groups.

In the first group, we investigate the impact of different satellite constellations while keeping task number m = 20. We utilize constellations A–F from Section V.A., with low target density, resulting in six instance combinations. For each combination, we generate 10 test instances and execute each algorithm independently, 10 times per instance. The statistical results for aNS, aHV, and aDR are shown in

Table 12. Statistical results for algorithms under different constellations.

Instance Type	Local Execution			Random Offloading			DALEOS			DDFTO
	aRPV	aSL	aEC	aRPV	aSL	aEC	aRPV	aSL	aEC	aRPV	aSL	aEC
{A, 15, low}	0.0138	1318.22	4436.11	1.0000	49,211.48	4803.42	0.0557	4164.82	3415.79	5.1 × 10−4	344.87	469.89
{B, 15, low}	0.0211	954.01	3969.16	1.0000	36,736.82	4343.96	0.0475	2728.17	3165.18	0.0000	254.59	3981.18
{C, 15, low}	0.0040	190.32	3804.91	1.0000	22,411.34	4074.59	0.0044	251.90	3113.46	0.0000	121.91	3489.86
{D, 15, low}	0.1199	2850.99	3713.90	1.0000	30,349.57	4168.34	0.0615	3387.67	3228.45	0.0000	123.16	3771.09
{E, 15, low}	0.0085	310.55	3785.44	1.0000	32,505.32	4288.40	0.0020	139.21	3275.27	0.0000	99.92	3262.42
{F, 15, low}	0.0030	132.61	3598.91	1.0000	19,458.29	4307.39	0.0186	689.76	3287.60	0.0000	93.20	3367.35
OVAR	0%	41.67%	0%	0%	0%	0%	0%	0%	83.33%	100%	100%	16.67%

, with optimal values highlighted in bold, and OVARs are calculated.

From Table 12, DDFTO consistently achieves optimal values for aNS, aHV, and aDR metrics. To analyze performance trends, we plot line graphs displaying these metrics for each algorithm across different constellations, as shown in Figure 11. In Figure 11a, DDFTO consistently exhibits the best aPRV values across various constellation instances, demonstrating its statistical effectiveness. Figure 11b illustrates a decreasing trend in aSL for all algorithms as constellation size increases, attributed to increased satellite availability for task execution, thus reducing latency. Nevertheless, DDFTO maintains superior aSL values across various instances. For example, in instances like {F, 15, low}, DDFTO reduces aSL by 29.71% (≈(132.61–93.20)/132.61) compared to local execution and by 86.48% (≈(689.76–93.20)/689.76) compared to DALEOS. Figure 11c presents aEC values for all algorithms, whereas DDFTO slightly trails DALEOS in this metric.

In another group, we investigate how the number of tasks affects algorithm performance while maintaining satellite constellation C. The tasks range from 2 to 30, with consistently low target density, creating a total of 15 different instance combinations. For each combination, we still generate 10 test instances and execute each algorithm independently, 10 times per instance. The statistical results for aNS, aHV, and aDR are recorded in

Table 13. Statistical results for algorithms under different numbers of tasks.

Instance Type	Local Execution			Random Offloading			DALEOS			DDFTO
	aRPV	aSL	aEC	aRPV	aSL	aEC	aRPV	aSL	aEC	aRPV	aSL	aEC
{C, 2, low}	0.8632	118.71	537.51	0.3027	567.60	609.03	0.2512	66.26	486.84	0.0000	38.04	549.19
{C, 4, low}	0.4479	106.64	1001.55	0.6366	4477.50	1041.43	0.2032	83.02	854.51	0.0000	44.26	860.44
{C, 6, low}	0.2080	148.62	1404.25	0.8714	9274.55	1679.38	0.0948	127.34	1185.29	0.0000	53.44	1421.18
{C, 8, low}	0.1095	127.26	1953.01	0.9378	10,267.03	2185.59	0.0652	162.51	1570.33	4.1 × 10−5	85.29	1878.07
{C, 10, low}	0.0059	148.71	2777.45	1.0000	13,353.12	3054.30	0.0420	972.52	2339.67	0.0000	94.85	2692.88
{C, 12, low}	0.0037	158.46	3221.83	1.0000	13,061.91	3522.47	0.0101	268.96	2631.71	7.6 × 10−4	110.89	3188.37
{C, 14, low}	0.0046	164.22	3864.22	1.0000	21,333.83	4270.94	0.0108	326.01	3157.89	0.0000	125.00	3434.52
{C, 16, low}	0.0021	178.32	4296.15	1.0000	29,990.68	4524.43	0.0048	329.91	3282.43	1.3 × 10−4	150.01	3967.27
{C, 18, low}	0.0025	196.32	4875.38	1.0000	31,174.33	5301.99	0.0912	5380.43	3809.38	3.2 × 10−4	152.35	4610.90
{C, 20, low}	0.0012	204.49	5506.41	1.0000	30,025.85	5831.97	0.0207	1031.62	4359.45	0.0019	208.68	5161.47
{C, 22, low}	0.0012	241.70	5882.84	1.0000	36,929.39	6457.77	0.0304	1904.91	4672.92	8.3 × 10−4	220.60	5828.34
{C, 24, low}	8.2 × 10−4	240.26	6915.95	1.0000	37,058.53	7195.91	0.0982	4744.11	5508.89	0.0022	261.36	6813.02
{C, 26, low}	2.6 × 10−4	254.90	7399.23	1.0000	33,985.64	7937.18	0.0589	2845.19	5413.30	0.0197	1192.96	6471.63
{C, 28, low}	8.7 × 10−4	262.29	7620.08	1.0000	40,233.24	8204.79	0.0576	2930.33	6217.39	0.0040	415.83	6882.54
{C, 30, low}	4.4 × 10−4	251.48	8348.84	1.0000	42,611.64	8630.32	0.0420	2169.42	6162.36	4.9 × 10−4	279.29	7747.13
OVAR	33.33%	33.33%	0%	0%	0%	0%	0%	0%	100%	66.67%	66.67%	0%

, with optimal values are in bold, and OVARs are included.

Table 13 shows that DDFTO achieves the best aRPV and aSL values in most instances. However, when the number of tasks exceeds 24, local execution provides lower service latency and outperforms DDFTO. Similarly, DALEOS achieves the best aEC value but has higher service latency. Figure 12 further illustrates the performance trends of different algorithms with varying task numbers.

In Figure 12a, the aRPV value for random offloading increases, while the other algorithms generally show a decreasing trend. DDFTO achieves the best aRPV when the number of tasks m ≤ 18, but local execution, due to its minimal service latency, becomes optimal when m ≥ 24. In Figure 12b, all algorithms show increasing aSL values as the number of tasks grows. DDFTO achieves the best aSL in most instances, but local execution excels when m is large. Dividing these tasks into several smaller groups [38] can effectively resolve these performance differences. Figure 12c shows that all algorithms exhibit increasing aEC values with more tasks, and the performance ranking of these algorithms remains consistent regardless of the number of tasks. Although DDFTO has a slightly worse aEC value compared to DALEOS, its advantage in service latency enables it to achieve the optimal overall F(θ) values.

Although DDFTO shows performance degradation in instances with more than 20 tasks, this can be mitigated by grouping or clustering tasks [38]. Future work will focus on enhancing DDFTO to manage larger and more complex task scenarios.

7. Conclusions

This paper addresses the task offloading problem in ICSC satellites with data-dependent constraints, in which a monitoring task can be divided into multiple observation and computation sub-tasks. Considering data-dependent constraints among sub-tasks, we introduce a MINP model that aims to minimize both service latency and energy consumption simultaneously. Based on this model, we present a distributed algorithm called DDFTO for resolving the task offloading problem. DDFTO operates on each satellite in parallel, alternating between stages of sub-task inclusion and consensus and sub-task removal, until a common offloading assignment is reached. To handle undesired deadlocks arising from sub-task inclusion, we propose the DFIM method. DFIM strategically restricts the insertion positions of sub-tasks based on interval relationships, thereby ensuring deadlock-free assignments. Finally, extensive experiments underscore the necessity of deadlock avoidance, with DFIM effectively preventing deadlocks in offloading assignments. DDFTO demonstrates superior performance compared to benchmark algorithms such as DALEOS [21], local execution, and random offloading. An analysis of parameter impacts further validates DDFTO’s effectiveness in optimizing offloading assignments. In future work, we plan to extend DDFTO to address other scenarios in ICSC satellites, including multi-source satellite cooperative observation.