Multi-Satellite Task Parallelism via Priority-Aware Decomposition and Dynamic Resource Mapping

Abstract

Multi-satellite collaborative computing has achieved task decomposition and collaborative execution through inter-satellite links (ISLs), which has significantly improved the efficiency of task execution and system responsiveness. However, existing methods focus on single-task execution and lack multi-task parallel processing capability. Most methods ignore task priorities and dependencies, leading to excessive waiting times and poor scheduling results. To address these problems, this paper proposes a task decomposition and resource mapping method based on task priorities and resource constraints. First, we introduce a graph theoretic model to represent the task dependency and priority relationships explicitly, combined with a novel algorithm for task decomposition. Meanwhile, we construct a resource allocation model based on game theory and combine it with deep reinforcement learning to achieve resource mapping in a dynamic environment. Finally, we adopt the theory of temporal logic to formalize the execution order and time constraints of tasks and solve the dynamic scheduling problem through mixed-integer nonlinear programming to ensure the optimality and real-time updating of the scheduling scheme. The experimental results demonstrate that the proposed method improves resource utilization by up to about 24% and reduces overall execution time by up to about 42.6% in large-scale scenarios.

1. Introduction

With the rapid development of satellite communication and networking technologies, satellite networks have become a crucial part of the global information infrastructure, supporting applications in communications, navigation, and remote sensing [1,2]. In particular, the deployment of large Low Earth Orbit (LEO) satellite constellations in recent years has further underscored the vital role of satellite networks in worldwide connectivity and Earth observation [3]. Traditional satellite task processing methods rely on ground stations for centralized mission planning and single-satellite execution [4]. This paradigm requires frequent satellite–ground communications and has limited real-time responsiveness [5]. Recent advances in integrated space–ground network architectures enable resource sharing and cooperative processing directly between satellites [6,7]. Consequently, multi-satellite cooperative computing has emerged as a new research focus, wherein multiple satellites interact via inter-satellite links to distribute and execute computational tasks collaboratively, essentially forming a “space-based cloud” computing environment [8,9,10]. By decomposing complex missions and distributing subtasks across satellites for parallel execution, multi-satellite cooperation markedly reduces the burden on any single satellite and diminishes reliance on ground control, thereby significantly improving real-time responsiveness [11]. Therefore, incorporating multi-satellite cooperative computing for task decomposition and resource allocation has become a key avenue to meet the demands of future large-scale and complex space missions [12].

With the rapid development of satellite communication and networking technologies, satellite networks have become a crucial part of the global information infrastructure, supporting applications in communications, navigation, and remote sensing [1]. However, efficient multi-satellite cooperative computing is challenging regarding task decomposition, resource allocation, and real-time scheduling [13,14]. First, determining how to partition a complex mission into subtasks and assign them to different satellites is a complicated decision problem that must account for heterogeneous satellite resources and inter-task dependencies [15]. Second, the multi-satellite network environment is highly dynamic: satellite positions and link conditions change over time, and task requests may arrive unpredictably. This dynamism demands that scheduling strategies adapt rapidly [16]; otherwise, a precomputed plan can quickly become suboptimal or invalid. In addition, the joint optimization problem of multi-satellite collaboration is typically non-convex, involving discrete task assignment and continuous resource allocation variables, which makes it exceptionally computationally complex. Indeed, the complexity of typical multi-satellite scheduling grows exponentially with the number of satellites and tasks, rendering it an NP-hard problem. This complexity hampers the ability to obtain exact optimal solutions within real-time constraints.

In response to the above challenges, researchers have proposed various heuristic and meta-heuristic algorithms (e.g., genetic algorithms [17], tabu search [18], multi-objective evolutionary algorithms [19,20]) to tackle non-convex task allocation challenges. These algorithms have achieved specific progress in computational efficiency. However, most such studies rely on simplified assumptions and static scenarios without adequately accounting for real-time changes in satellite states and task demands. As a result, their scheduling strategies may perform suboptimally in actual dynamic environments and often focus on optimizing only a single performance metric (e.g., minimizing task completion time) without considering other objectives such as energy consumption. Overall, current methods still exhibit shortcomings in aspects like real-time responsiveness, solving complex non-convex optimizations, and cross-system collaboration. On one hand, many algorithms have high computational complexity and struggle to meet immediate response requirements. On the other hand, most research has been confined to cooperation within satellite networks alone, lacking consideration of integrated satellite–ground computing, which limits their applicability to broader collaborative scenarios.

In response to the abovementioned challenges, we introduce a comprehensive approach that integrates three main layers to achieve efficient task decomposition and allocation. The task decomposition layer utilizes a graph-theoretical model to represent complex task dependency and priority relationships. Then, it is addressed by mathematical tools such as Integer Linear Programming to derive optimal or near-optimal task decomposition solutions. The resource mapping and allocation layer models the heterogeneous resource competition within the multi-satellite system as a game-theoretic process by combining game theory with Deep Reinforcement Learning (DRL), gradually converging toward Nash equilibrium. Finally, the dynamic scheduling and temporal constraints layer formalizes task execution order and time constraints using Temporal Logic theory. It solves the dynamic scheduling problem to ensure feasibility and optimality during execution. The proposed method effectively overcomes the challenges of real-time dynamic environments and complex non-convex optimizations.

The main contributions of this paper are as follows:

1.

The task dependencies and priorities are explicitly represented through a directed acyclic graph (DAG) model based on graph theory, and the NP-hard decomposition problem caused by task dependencies and resource constraints is solved by integer linear programming. This method can reasonably allocate subtasks among multiple heterogeneous satellites, effectively reduce the overall execution time, and ensure the optimization of task decomposition.

2.

We propose a model based on game theory to construct a resource competition game between satellites. We combine this with a Deep Q-Learning Network (DQN), and the Nash equilibrium of the game is gradually approximated through the dynamic learning of intelligence, thus achieving the efficient adaptive allocation of resources. This method can adapt to changes in system resources in real time and optimize resource utilization efficiency.

3.

We introduce an LTL-based model to formally describe the dependencies and timeframes of tasks, and the dynamic scheduling problem can be solved through a mixed integer nonlinear programming (MINLP) model, which incorporates real-time feedback for online updating of the scheduling scheme, which adapts to environmental changes and resource fluctuations in the execution process, ensuring the optimality of task scheduling.

2. Related Work

Driven by the demand for multi-satellite collaboration, satellite networks have become the core platform for achieving broad area observation and efficient computing. In recent years, research on complex task decomposition, allocation, and resource mapping has mainly focused on static task scheduling and single-satellite resource optimization. However, existing methods generally lack dynamic multi-tasking parallel processing capabilities, neglect the joint optimization of priority and dependency relationships, and have rigid resource mapping mechanisms, leading to prominent issues of system response delay and resource fragmentation, making it difficult to adapt to high real-time and heterogeneous satellite collaboration scenarios.

2.1. Dynamic Decomposition and Hierarchical Optimization

To address the challenges of high-dimensional task conflicts and dynamic scheduling in the complex task decomposition of satellite networks, researchers have proposed a dynamic decomposition and hierarchical optimization strategy that reduces the complexity of the problem through decoupling in the spatiotemporal dimension [21,22,23,24,25,26].

For instance, Wang et al. [21] dynamically decomposes the target area into candidate observation bands and optimizes the combination using the adaptive genetic algorithm. Moreover, Yao et al. [24] adopts a hierarchical structure of task allocation merging and utilizes dynamic programming to reduce task conflicts. Liu et al. [25] proposed a dynamic task decomposition and resource allocation optimization method based on the MILP algorithm, which improves the efficiency and real-time performance of complex task scheduling and resource mapping in satellite networks through spatiotemporal decoupling and multi-level optimization strategies. Also, Bittencourt et al. [26] utilized a lookahead-based variant of HEFT (HEFT-LA) to dynamically adjust task scheduling in satellite networks, improving task execution efficiency by anticipating future resource demands. However, such methods still face the problems of insufficient task conflict handling and scheduling flexibility, and require exploration of more precise resource allocation and scheduling strategies.

2.2. Intelligent Optimization and Collaborative Scheduling

In addition to traditional optimization methods, researchers have combined intelligent computational methods to solve the problem of balancing resource competition in multi-objective optimization in task decomposition [23,27,28,29,30,31,32]. For example, Chai et al. [23] improved resource utilization by balancing power and rate through a two-stage optimization framework. Similarly, Ikoma et al. [29] proposed a resource allocation method based on ACO, which improves task execution efficiency and real-time performance by optimizing computation and network resource allocation. Additionally, Chen et al. [32] introduced the PA-LBIMM algorithm, which integrates user-priority-based Min-Min scheduling to enhance load balancing in cloud computing environments, offering better performance in terms of task completion time under multi-objective optimization. However, non-convex optimization solutions lack stability, so further research is needed on weight-adaptive allocation methods for high-dimensional objective spaces.

For the coupling problem of task relevance in convex optimization, some researchers have proposed task aggregation and graph network methods based on the concept of intelligent computing [33,34,35,36]. Typically, Fan et al. [33] reduced task conflicts through task network graph aggregation. And Cai et al. [36] proposed a task decomposition and resource scheduling method based on the network flow algorithm, which optimizes task offloading and resource allocation in cloud–edge collaborative computing through LSTM prediction and hierarchical scheduling. Although these methods effectively optimize task scheduling, they still face problems such as poor real-time performance, high computational complexity, and insufficient flexibility in resource scheduling.

In the decentralized scheduling scenario, researchers adopt multi-agent collaboration frameworks [37,38]. For example, Zilberstein et al. [37] reduces task latency through deep reinforcement learning. However, the communication overhead and policy consistency between intelligent agents are still bottlenecks, so designing lightweight collaboration protocols and heterogeneous verification mechanisms is necessary. Faced with the challenge of limited resources, Xiaolu et al. designed a cross-layer resource allocation model [28,39]. However, existing methods have not been able to solve the problem of the dynamic matching of satellite ground resources, so combining them with digital twin technology is necessary to achieve virtual real linkage optimization. Although these methods have made some progress in task decomposition, scheduling, and resource optimization, they still face challenges in real-time performance, stability, and intelligence.

2.3. Dynamic Scheduling and Resource Allocation Optimization Methods

Dynamic scheduling mainly focuses on solving problems encountered in complex task decomposition in satellite networks, such as task correlation coupling, and researchers have proposed methods based on dynamic scheduling and resource allocation optimization to address the dynamic resource coupling and real-time challenges faced by complex task allocation in satellite networks. Researchers have adopted DRL and hierarchical multi-time-scale methods to solve the delay and resource allocation efficiency problems in dynamic task scheduling through constrained Markov decision process (CMDP) modeling and mixed near-end policy optimization [40,41,42,43]. Based on multi-agent collaboration and genetic programming, they have constructed autonomous satellite collaboration models and centralized distributed architectures, which have improved the task planning capability of multi-satellite systems [24,44,45,46].

In addition to innovative research work from an algorithmic perspective, some researchers have focused on network architecture innovation and optimized load balancing and economic benefits by designing multi-layer edge computing frameworks and online scheduling mechanisms [47,48,49,50]. For example, Li et al. [42] proposed a dual decoder strategy network based on the attention mechanism, which utilizes the virtual task adjustment mechanism to achieve flexible scheduling sequence generation; Lyu et al. [47] proposed a hybrid cloud satellite multi-layer architecture that dynamically coordinates node selection and computing resource allocation. However, there is an inherent contradiction between real-time assurance and multi-objective trade-offs in existing methods for cross-system collaborative optimization, and further exploration of low-complexity joint optimization theory is needed to balance the global efficiency and local resource constraints of heterogeneous satellite networks.

2.4. Intelligent Beam Matching and Cross-Layer Resource Optimization

While focusing on the decomposition and allocation of complex tasks in satellite networks, resource mapping has also become a core challenge in achieving efficient service provision. In order to address the challenges of non-uniform traffic demand and dynamic topology adaptation in satellite networks, researchers have solved the problems of improving spectral efficiency and dynamic resource allocation through flexible user beam mapping, multi-objective resource optimization, and cross-layer modeling, improving the responsiveness of satellite systems. Ramírez et al. [51] proposed an intelligent beam user matching scheme that breaks through traditional cell boundaries and combines dynamic beam coverage with adjustable bandwidth allocation, achieving efficient resource adaptation in non-uniform traffic scenarios; Du et al. [52] introduces an iterative optimization framework based on TDM, which combines time score and power allocation to reduce resource fragmentation while meeting differentiated requirements. In addition, Chen et al. [27] proposed a multi-objective modeling method that combines region decomposition and resource allocation, using the NSGA-II algorithm to balance coverage and resource consumption, providing a cross-domain reference for resource mapping. However, existing research lacks theoretical support for scenarios such as real-time reconstruction and multi-track layer resource collaboration in dynamic environments, and breakthroughs need to be sought in stochastic optimization models and distributed dynamic decision-making mechanisms.

In conclusion, existing methods have significant bottlenecks in real-time performance assurance, non-convex optimization solution efficiency, cross-domain collaboration capability (multi-orbital layer resource linking), and lack systematic solutions to policy consistency and resource fragmentation issues in heterogeneous network environments. In the future, breakthroughs are needed in low-complexity joint optimization theory, lightweight distributed decision-making mechanisms, and virtual accurate linkage digital twin modeling technology to address the challenges of high dynamics and multi-constraint satellite network collaboration. To address these issues, this paper proposes hierarchical adaptive decomposition and reinforcement learning-based resource mapping (HADRM), which models the complex dependencies between tasks and employs deep reinforcement learning-based resource mapping to cope with real-time changes in task dependencies and on-board resources. Ultimately, timing scheduling ensures the optimization of the execution order of the final tasks without affecting global optimality.

3. Problem Description and Formulation

3.1. System Model

The multi-satellite cooperative computing system consists of multiple heterogeneous satellites, each tasked with various remote sensing operations. The primary objective is to achieve efficient task execution through task decomposition and resource mapping techniques. Each satellite $S=\{s_1,s_2,\dots ,s_n\}$ has unique computational, storage, and communication capabilities, enabling resource sharing to enhance overall system performance. The system architecture comprises satellite nodes, communication links, and a task scheduling center, where components interact via inter-satellite communication for data transmission and processing.

The core components of the system include satellite nodes, the task scheduling center, and the communication network. Each satellite node $s_i$ possesses resources, characterized as computational resources $r^b\left(s_i\right)$, communication resources $c\left(s_i\right)$, and payload resources $r^p\left(s_i\right)$. A task $m_i$ is decomposed into k subtasks $\{T_{i1},T_{i2},\dots ,T_{ik}\}$, with each subtask $T_{ij}$ requiring specific resources, expressed as

$$R\left(T_{ij}\right)=\left[r^p\left(T_{ij}\right),r^b\left(T_{ij}\right),c\left(T_{ij}\right)\right],$$

(1)

The task allocation matrix $\mathbf{X}$ represents the assignment of subtasks to satellites:

$${\mathbf{X}}_{ij}=\left\{\begin{array}{cc}1,\hfill & \mathrm{if}\mathrm{subtask}{T}_{ij}\mathrm{is}\mathrm{assigned}\mathrm{to}\mathrm{satellite}{s}_i,\hfill \\ 0,\hfill & \mathrm{otherwise}\hfill \end{array}\right.$$

(2)

Data flows begin with the observation phase, generating observation data $D_o$, which are transmitted via communication links to other nodes or the task scheduling center, followed by compression and processing phases. The amount of observation data is represented as

$$D_o={\omega }_s^p·r_s^p\left(t\right).$$

(3)

The compressed data can be represented as

$$D_c=\eta ·D_o,$$

(4)

where $\eta$ is the compression efficiency. The data flow model can be represented through task dependency matrices $\mathbf{Z}$ and time constraints.

3.2. Problem Definition

The goal of task decomposition is to find an optimal decomposition strategy that minimizes the total execution time of the tasks while satisfying the task dependencies and time window constraints. The total execution time of a task $m_i$, denoted as ${\phi }_m\left(t\right)$, is the sum of the completion times of all its subtasks. For each subtask $T_{ij}$, its completion time ${\phi }_{ij}\left(t\right)$ is given by the following formula:

$${\phi }_{ij}\left(t\right)=\max ({\phi }_{ik}\left(t\right)+\Delta t_{ik},{\phi }_{ij}^{\mathrm{sub}}),$$

(5)

where ${\phi }_{ik}\left(t\right)$ represents the completion time of a dependent subtask $T_{ik}$, and $\Delta t_{ik}$ is the time delay between the completion of subtask $T_{ik}$ and the start of subtask $T_{ij}$ due to their dependency. The term ${\phi }_{ij}^{\mathrm{sub}}$ represents the subtask completion time, which is determined by the resources required for the subtask. Specifically, it is the time needed to execute subtask $T_{ij}$ independently, considering the computational, communication, and payload resources required. This can be formally expressed as

$${\phi }_m\left(t\right)=\sum _{j=1}^k{\phi }_{ij}\left(t\right),$$

(6)

where ${\phi }_{ij}\left(t\right)$ represents the completion time of subtask $T_{ij}$. The completion time of each subtask depends on Remark 1.

Remark 1

(Task Dependencies and completion time). When a subtask $T_{ij}$ depends on the result of another subtask $T_{ik}$, its completion time must be after the completion of the dependent task. The completion time of a dependent subtask is determined by both the completion time of the preceding subtask and the delay introduced by the dependency. Specifically, subtask $T_{ij}$ can only begin after $T_{ik}$ has completed, with an additional delay $\Delta t_{ik}$ that reflects the time required for data transfer, communication, or synchronization between the tasks. This relationship can be mathematically expressed as

$$t_{ij}\ge t_{ik}+{\phi }_{ik}\left(t\right)+\Delta t_{ik},\mathit{if}\mathit{subtask}{T}_{ij}\mathit{depends}\mathit{on}{T}_{ik},$$

(7)

And the completion time of subtask $T_{ij}$ must be after the completion time of subtask $T_{ik}$, where $t_{ij}$ is the start time of subtask $T_{ij}$, $t_{ik}$ is the completion time of subtask $T_{ik}$, and ${\phi }_{ik}\left(t\right)$ is the completion time of subtask $T_{ik}$. The additional delay $\Delta t_{ik}$ accounts for the necessary synchronization and data handling before $T_{ij}$ can begin.

In scenarios where there is no dependency, the completion time of subtask $T_{ij}$ is independent of other tasks. The completion time ${\phi }_{ij}^{\mathit{sub}}$ of a subtask $T_{ij}$ is determined solely by the resources required for its execution, including computational, communication, and payload resources. This is expressed as

$${\phi }_{ij}^{\mathit{sub}}={\displaystyle \frac{r^p\left(T_{ij}\right)}{R_s^p}}+{\displaystyle \frac{r^b\left(T_{ij}\right)}{R_s^b}}+{\displaystyle \frac{c\left(T_{ij}\right)}{C_s}},$$

(8)

where $r^p\left(T_{ij}\right)$, $r^b\left(T_{ij}\right)$, and $c\left(T_{ij}\right)$ are the resource requirements for payload, computation, and communication, respectively, and $R_s^p$, $R_s^b$, and $C_s$ are the available capacities of the satellite.

In task scheduling, we take the maximum of the two values—the earliest possible completion time determined by task dependencies and the independent completion time of the subtask itself. Therefore, the completion time of subtask $T_{ij}$ is given by Equation (5).

This ensures that the task execution respects both the dependencies between tasks and the intrinsic resource requirements of each subtask, optimizing the overall scheduling of tasks.

The objective is to find the optimal task decomposition strategy that minimizes the total task execution time. The total cost function can be expressed as the sum of the execution times of the observation and data processing tasks:

$${\mu }_m\left(t\right)={\phi }_m\left(t\right).$$

(9)

The total execution time is further decomposed into observation and compression tasks in Equations (10)–(12). Then, the observation task execution time is calculated as follows:

$${\phi }_m^p\left(t\right)=\sum _{s\in S}{\omega }_s^p·r_s^p\left(t\right),$$

(10)

where ${\omega }_s^p$ is the priority of the observation task, and $r_s^p\left(t\right)$ is the execution time for observation tasks.

The compression task execution time is calculated as follows:

$${\phi }_m^b\left(t\right)=\sum _{s\in S}{\displaystyle \frac{r_s^b\left(t\right)}{\nu }},$$

(11)

where $r_s^b\left(t\right)$ is the execution time for compression tasks, and $\nu$ is the efficiency parameter for computational resources. Our goal is to minimize the total execution time of tasks in the multi-satellite cooperative computing system. Inputs include resource characteristics $\mathbf{R}\left(T_{ij}\right)$ and task requirements $\mathbf{M}$, with the optimal task allocation strategy $\mathbf{X}$ being the output. The objective function is

$$\min \sum _{m=1}^M\left({\phi }_m^p\left(t\right)+{\phi }_m^b\left(t\right)\right),$$

(12)

where ${\phi }_m^p\left(t\right)$ denotes the observation time, and ${\phi }_m^b\left(t\right)$ denotes the time for data processing and compression. This combinatorial optimization problem involves complex task decomposition and resource mapping.

3.3. Constraints

Based on the proposed problem scenario, we consider following constraints:

3.3.1. Task Dependency Constraint

If task $T_{ij}$ depends on task $T_{ik}$, then

$$t_{ij}\ge t_{ik},\mathrm{if}{T}_{ij}\mathrm{depends}\mathrm{on}{T}_{ik}.$$

(13)

3.3.2. Priority Constraint

Higher-priority tasks must be executed first:

$${\omega }_{ij}\ge {\omega }_{ik},\mathrm{if}{\omega }_{ij}>{\omega }_{ik}.$$

(14)

3.3.3. Time Window Constraint

Each subtask must be executed within its predefined time window:

$$t_{ij}^{Start}\le t_{ij}\le t_{ij}^{End}.$$

(15)

3.3.4. Resource Constraints

Resources allocated to each subtask must not exceed the total resources of the satellite:

$$\sum r^p\left(T_{ij}\right)\le R_s^p,\sum r^b\left(T_{ij}\right)\le R_s^b,\sum c\left(T_{ij}\right)\le C_s.$$

(16)

3.3.5. Load Balancing Constraint

Resource utilization across all satellites must be balanced:

$${\displaystyle \frac{\sum r^b\left(s_i\right)}{R_s^b}}\approx {\displaystyle \frac{\sum r^b\left(s_j\right)}{R_s^b}},\forall s_i,s_j\in S.$$

(17)

3.3.6. Fault Tolerance Constraint

Considering that individual satellites or their resources (e.g., computation, storage, or payload) may fail in a multi-satellite system, once a failure or partial malfunction is detected in a satellite’s resources, the system will trigger a dynamic task reallocation process. Based on the existing resource constraints (16) and load balancing constraints (17), the task allocation matrix $\mathbf{X}$ is adjusted to promptly reassign the affected tasks, thereby ensuring the continuity and stability of the overall task scheduling.

3.3.7. Dependency and Execution Time Constraints

In scenarios where subtasks have dependencies, the completion time of a subtask $T_{ij}$ is determined not only by its own resource consumption, but also by the completion of preceding tasks. This constraint ensures that the completion time of $T_{ij}$ is bounded by the completion of task $T_{ik}$ and the delay $\Delta t_{ik}$ that accounts for synchronization and data transfer between tasks. The following relation must hold for Equation (7):

Remark 2

(Fault Tolerance). The above fault tolerance mechanism is predicated on the system’s capability for real-time fault detection and response, ensuring that when a single satellite or some of its resources fail, the remaining satellites can utilize their available resources to complete the tasks, thereby maintaining the overall system performance without significant degradation.

3.4. Objective Function

The objective is to minimize the total execution time of tasks. The objective function is

$$\min \sum _{m=1}^M\sum _{t=1}^T\left({\phi }_m^p\left(t\right)+{\phi }_m^b\left(t\right)\right).$$

(18)

For multi-objective optimization, a weighted method is used and we obtain the final objective function as Equation (19):

$$\begin{array}{cccc}\hfill & \min F=\alpha \sum _{m=1}^M{\phi }_m^p\left(t\right)+\beta \sum _{m=1}^M{\phi }_m^b\left(t\right),\hfill & \hfill & \\ \hfill & \mathrm{s}.\mathrm{t}.\hfill \\ \hfill & \mathrm{C}1:t_{ij}\ge t_{ik},\mathrm{if}{T}_{ij}\mathrm{depends}\mathrm{on}{T}_{ik},\hfill \\ \hfill & \mathrm{C}2:{\omega }_{ij}\ge {\omega }_{ik},\mathrm{if}{\omega }_{ij}>{\omega }_{ik},\hfill \\ \hfill & \mathrm{C}3:t_{ij}^{Start}\le t_{ij}\le t_{ij}^{End},\hfill \\ \hfill & \mathrm{C}4:\sum r^p\left(T_{ij}\right)\le R_s^p,\sum r^b\left(T_{ij}\right)\le R_s^b,\sum c\left(T_{ij}\right)\le C_s,\hfill \\ \hfill & \mathrm{C}5:{\displaystyle \frac{\sum r^b\left(s_i\right)}{R_s^b}}\approx {\displaystyle \frac{\sum r^b\left(s_j\right)}{R_s^b}},\forall s_i,s_j\in S.\hfill \end{array}$$

(19)

The objective function aims to minimize the total execution time of observation and compression tasks while ensuring efficient resource utilization and system stability. The function considers both the observation processing time ${\phi }_{ij}^p$ and compression processing time ${\phi }_{ij}^b$, with weighting factors $\alpha$ and $\beta$ to balance their contributions, where $\alpha$ and $\beta$ are weight coefficients for different task phases. The execution time of each task is constrained by resource availability, time windows, and task dependencies. Let $t_{ij}$ be the execution time of an observation task, with feasible execution times defined in the set $T_{ij}$. The deviation from the target execution time is denoted as $d_{i,\mathrm{tar}}\left(t_{ij}\right)$, while resource allocations for compression tasks are represented by $r^p\left(T_{ij}\right)$ and are constrained by the maximum allowed resource capacity $R_s^p$. Power consumption during execution is modeled by $r^b\left(T_{ij}\right)$ and $c\left(T_{ij}\right)$. Additional constraints include distance or deviation limits $t_{ij}^{Start}\le t_{ij}\le t_{ij}^{End}$, as well as capacity constraints for computation and transmission, given by $\sum r^p\left(T_{ij}\right)\le R_s^p$. Task scheduling follows dependency constraints, ensuring that a compression task $t_{ij}$ does not start before the observation task $t_{ik}$, with dependencies represented by ${\omega }_{ij}\ge {\omega }_{ik}$. Furthermore, load balancing is maintained by ensuring that resource utilization across all satellites satisfies ${\displaystyle \frac{\sum r^b\left(s_i\right)}{R_s^b}}\approx {\displaystyle \frac{\sum r^b\left(s_j\right)}{R_s^b}},\forall s_i,s_j\in S$.

The analysis shows that this problem is NP-hard. As the number of tasks M and satellite nodes N increases, the combinatorial complexity of task allocation and resource mapping grows exponentially. Polynomial-time algorithms cannot effectively solve this problem.

Through reduction from the classical task scheduling problem, the complexity of the problem is proven, classifying it as NP-hard. The task dependencies, resource allocation, and time constraints make the problem highly challenging, requiring heuristic or approximation algorithms to solve it.

4. Methodology

Figure 1 illustrates the overall framework of the HADRM method, which is composed of three main modules working iteratively to enhance system efficiency. (i) Task decomposition considers task dependencies and priorities to ensure the logical breakdown of complex tasks. (ii) Resource mapping and allocation integrates both static and adaptive strategies to optimize resource utilization across the system. (iii) Dynamic scheduling continuously adjusts task execution based on real-time system state updates, ensuring adaptability and efficiency. Together, these modules form a cohesive approach to optimizing task execution and resource management.

4.1. Task Decomposition Strategy Based on Graph Theory and Lagrangian Relaxation

To address the challenges of efficient task decomposition considering complex task dependencies, we model the remote sensing tasks as a DAG and apply integer linear programming (ILP) combined with Lagrangian relaxation to minimize the total execution time while satisfying task dependencies and resource constraints.

Task dependencies play a critical role in determining the execution order and time of tasks in a multi-satellite system. In our approach, tasks are modeled as a DAG, where each node represents a subtask $T_{ij}$ and directed edges represent the dependency relationships between subtasks. A key aspect of this model is the handling of dependencies that may impose constraints on the execution order of subtasks.

For instance, if subtask $T_{ij}$ depends on the results of subtask $T_{ik}$, then $T_{ij}$ cannot start until $T_{ik}$ is completed, along with an additional delay $\Delta t_{ik}$ to account for data transfer or synchronization. This relationship can be formally expressed as Equation (7).

However, in cases where there is no strict dependency, subtasks can be executed concurrently, which can reduce the overall execution time. Therefore, adjusting the execution sequence of tasks based on their dependencies is crucial for optimizing the total execution time. By carefully selecting which task should be executed first and considering the delays introduced by dependencies, the overall system efficiency can be maximized.

For example, if task $T_{ij}$ is dependent on $T_{ik}$, but there is no significant data transfer between the two, the system might allow $T_{ij}$ to start earlier, assuming other resources are available. This adjustment is particularly important in a distributed multi-satellite environment, where communication and processing delays can be significant.

This approach ensures that the task execution respects both the dependency relationships and the intrinsic resource requirements of each subtask, optimizing the overall scheduling of tasks.

The task decomposition problem in multi-satellite cooperative computing is modeled as a DAG, where each node represents a subtask $T_{ij}$ and edges represent dependency relationships between subtasks. Each subtask $T_{ij}$ has an completion time $t_{ij}$ and resource requirements $R\left(T_{ij}\right)$. The task dependencies and priorities can be expressed as

$$\mathrm{If}{T}_{ij}\mathrm{depends}\mathrm{on}{T}_{ik},t_{ij}\ge t_{ik}+{\delta }_{ik},$$

(20)

where ${\delta }_{ik}$ is the minimum time interval between tasks.

Based on the DAG model, an ILP model is established to minimize the total execution time. The decision variables are defined as follows:

$x_{ijs}$ is a binary variable, where $x_{ijs}=1$ if subtask $T_{ij}$ is assigned to satellite s, and 0 otherwise. $t_{ij}$ represents the start time of subtask $T_{ij}$.

We obtain the following objective function:

$$\min \underset{i,j}{\max }\left(t_{ij}+d_{ij}\right),$$

(21)

where $d_{ij}$ is the duration of subtask $T_{ij}$.

The optimization problem includes the following constraints (22)–(26):

4.1.1. Task Allocation Constraint

Each subtask must be assigned to exactly one satellite:

$$\sum _{s\in S}{x}_{ijs}=1,\forall T_{ij}$$

(22)

4.1.2. Resource Constraint

At any given time, the total resource demand of subtasks assigned to satellite s must not exceed its available resources:

$$\sum _{T_{ij}\in M}R\left(T_{ij}\right)x_{ijs}\le R_s,\forall s\in S$$

(23)

4.1.3. Task Dependency Constraint

If subtask $T_{ij}$ depends on $T_{ik}$,

$$t_{ij}\ge t_{ik}+d_{ik},\mathrm{if}{T}_{ij}\mathrm{depends}\mathrm{on}{T}_{ik}$$

(24)

4.1.4. Time Window Constraint

Each subtask must be executed within its predefined time window:

$$t_{ij}^{\mathrm{start}}\le t_{ij}\le t_{ij}^{\mathrm{end}}$$

(25)

4.1.5. Task Priority Constraint

Higher-priority tasks should be executed first:

$$\mathrm{If}{\omega }_{ij}>{\omega }_{ik},t_{ij}\le t_{ik}$$

(26)

Due to the NP-hard nature of the ILP problem, a Lagrangian relaxation approach is employed to improve the solution efficiency. The resource and task dependency constraints are relaxed into the objective function using Lagrange multipliers to construct the Lagrangian function:

$$L(x,t,\lambda ,\mu )=\underset{i,j}{\max }\left(t_{ij}+d_{ij}\right)+\sum _{s\in S}{\lambda }_s\left(\sum _{T_{ij}\in M}R\left(T_{ij}\right)x_{ijs}-R_s\right)+\sum _{(ij,ik)\in E}{\mu }_{ij,ik}\left(t_{ij}-t_{ik}-d_{ik}\right)$$

(27)

where ${\lambda }_s$ represents the Lagrange multipliers for the resource constraints, ${\mu }_{ij,ik}$ represents the Lagrange multipliers for the task dependency constraints, and E represents the set of task dependency relationships.

This Algorithm 1 decomposes the complex integer linear programming problem into smaller subproblems and employs Lagrange multipliers to coordinate global constraints with local optimization, ensuring scientific validity. It begins by initializing the iteration counter and Lagrange multipliers (Line 1). During each iteration, the algorithm solves a relaxed subproblem for each subtask $T_{ij}\in M$ (Line 3), minimizing the objective function of task start time, delay penalties, and resource constraint violations weighted by Lagrange multipliers. The solution must satisfy binary constraints, time windows, and other feasibility conditions. By accounting for task dependencies, resource constraints, time windows, and priorities, this approach guarantees feasible and near-optimal task allocation. Next, the Lagrange multipliers are updated to enforce resource and temporal constraints (Line 4). The resource-based multiplier ${\lambda }_s$ is adjusted based on the difference between the total allocated and available resources for each satellite, while the temporal constraint multiplier ${\mu }_{ij,ik}$ is updated based on task precedence relationships, ensuring the overall allocation remains balanced and efficient. A stopping criterion is then evaluated (Line 5): if met, the algorithm terminates; otherwise, it increments the iteration counter and continues. Once convergence is achieved, a feasible solution is constructed (Line 6). The final task assignments and start times (or their averaged values) form the basis of the initial solution, which a repair heuristic (e.g., simulated annealing) refines by mitigating constraint violations and improving efficiency. Finally, the algorithm returns the optimized task assignments and start times $x_{ijs},t_{ij}$ (Line 7).

Algorithm 1: Task Decomposition Using Lagrangian Relaxation (LRCTD)

4.2. Resource Mapping and Allocation Strategy Based on Game Theory and Reinforcement Learning

To tackle the heterogeneity and dynamic nature of satellite resources in multi-satellite cooperative computing, a resource mapping and allocation strategy based on game theory and reinforcement learning is proposed. We model the resource allocation problem as a resource competition game among satellite nodes. The optimal allocation is then derived by solving the Nash equilibrium of the game. Furthermore, a deep reinforcement learning algorithm is integrated to dynamically adjust resource allocation in response to the changing environment, ensuring adaptive and efficient resource mapping.

In a multi-satellite cooperative system, each satellite node competes for limited computational, communication, and storage resources to maximize its utility. This competition can be naturally modeled as a non-cooperative game where each satellite $s_i$ selects a resource allocation strategy ${\mathbf{r}}_i=[r_i^b,r_i^c,r_i^p]$. The utility function for each satellite is defined as

$$U_i({\mathbf{r}}_i,{\mathbf{r}}_{-i})={\displaystyle \frac{f_i\left({\mathbf{r}}_i\right)}{g({\mathbf{r}}_i,{\mathbf{r}}_{-i})}},$$

(28)

where $f_i\left({\mathbf{r}}_i\right)$ represents the benefit derived from the allocated resources, and $g({\mathbf{r}}_i,{\mathbf{r}}_{-i})$ represents the cost influenced by other satellites’ resource strategies ${\mathbf{r}}_{-i}$.

By modeling the allocation as a game, the Nash equilibrium condition ensures that no satellite can improve its utility by unilaterally changing its resource strategy, providing a theoretically sound framework for optimal resource distribution.

To find the optimal resource allocation, we define the Nash equilibrium of this game. A strategy profile $({\mathbf{r}}_1^{\ast },{\mathbf{r}}_2^{\ast },\dots ,{\mathbf{r}}_n^{\ast })$ is a Nash equilibrium if

$$U_i({\mathbf{r}}_i^{\ast },{\mathbf{r}}_{-i}^{\ast })\ge U_i({\mathbf{r}}_i,{\mathbf{r}}_{-i}^{\ast }),\forall i,\forall {\mathbf{r}}_i$$

(29)

We use the best response dynamics to iteratively adjust each satellite’s resource strategy toward equilibrium. However, due to the dynamic nature of the environment, solving for Nash equilibrium in real time is computationally expensive.

Considering the dynamic and complex nature of resource competition, we introduce DRL to adaptively adjust resource allocation. Each satellite node is modeled as an agent in a Markov decision process (MDP) where the state $s_t$ captures the current resource usage and task demand, the action $a_t$ represents the selected resource allocation strategy, and the reward $r_t$ is derived from the utility function $U_i$. The objective of the agent is to learn an optimal policy ${\pi }^{\ast }\left(s_t\right)$ that maximizes its expected cumulative reward.

The learning process employs DQN to approximate the optimal action-value function:

$$Q^{\ast }(s_t,a_t)=\underset{\pi }{\max }\mathbb{E}\left[\sum _{k=0}^{\infty }{\gamma }^k{r}_{t+k}\mid s_t,a_t\right].$$

(30)

The proposed resource allocation algorithm combines game theory and DRL to achieve an optimal and adaptive resource distribution. Algorithm 2 outlines the iterative learning and allocation process.

This algorithm begins by initializing the Q-network and the replay buffer (Lines 2–3). During each iteration, every satellite first observes its current state (Line 6) and selects a resource allocation action according to the $ϵ$-greedy policy derived from the Q-network (Line 7). The chosen action is then executed, yielding a reward and a subsequent state (Line 8), and the transition tuple is stored in the replay buffer (Line 9). A minibatch is subsequently sampled from the replay buffer (Line 11), and for each transition in the minibatch, a target Q-value is computed using the Bellman update (Line 13). The Q-network parameters are then optimized by minimizing the loss function (Line 14). Finally, for each satellite, the optimal resource allocation is obtained by selecting the action that maximizes the Q-network’s output (Line 16). This iterative process enables the resource allocation strategy to continuously improve, converging towards a near-optimal solution in a dynamic environment.

Algorithm 2: Resource Allocation Using Game Theory and DRL (GDRL)

4.3. Dynamic Scheduling and Task Dependency Constraint Handling Based on Temporal Logic

In the multi-satellite cooperative computing system, the dynamic nature of task execution and the complexity of task dependencies necessitate a robust scheduling mechanism. In the dynamic scheduling process, it is essential to consider not only the task dependencies but also how these dependencies evolve in real time as the system state changes. By using Linear Temporal Logic (LTL), we can express the timing and sequence constraints that govern the relationships between tasks. This formal framework ensures that the execution order of tasks adheres to the precedence relationships dictated by their dependencies. Furthermore, the dynamic nature of task execution requires continuous adjustments based on the current system state and task progress. As the system evolves, the scheduling process needs to re-evaluate task dependencies and resource availability to maintain optimal execution. This is achieved by using MINLP, which provides a flexible and adaptive framework for real-time scheduling. This section proposes a dynamic scheduling strategy using temporal logic and MINLP to handle the constraints imposed by task dependencies. Temporal logic provides a formal framework to model the sequential relationships between tasks.

To accurately represent the task dependencies in a multi-satellite environment, we use LTL to express the sequence and timing constraints among tasks. Each task $T_{ij}$ is associated with an LTL formula that defines its start and end conditions based on other dependent tasks:

$$\mathbf{G}(\mathbf{F}{T}_{ik}\to \mathbf{F}{T}_{ij}),$$

(31)

where G denotes the “globally” operator, ensuring that the task relationship holds at all times, and F represents the “eventually” operator, indicating that $T_{ij}$ can only start after the completion of $T_{ik}$. This formalism allows the encoding of complex task dependencies and timing constraints into the scheduling model.

We define the decision variables $x_{ij}\left(t\right)$ as binary variables indicating whether task $T_{ij}$ is executed at time t:

$$x_{ij}\left(t\right)=\left\{\begin{array}{cc}1,\hfill & \mathrm{if}{T}_{ij}\mathrm{is}\mathrm{executed}\mathrm{at}\mathrm{time}t,\hfill \\ 0,\hfill & \mathrm{otherwise}\hfill \end{array}\right.$$

(32)

The objective function aims to minimize the total execution time while satisfying the LTL constraints. The formulation includes constraints for task dependencies, resource limitations, and time windows. For example, the dependency constraint between tasks $T_{ij}$ and $T_{ik}$ can be formulated as

$$\sum _{t=1}^{T}t·x_{ij}\left(t\right)\ge \sum _{t=1}^{T}t·x_{ik}\left(t\right)+{\tau }_{ik},$$

(33)

where ${\tau }_{ik}$ represents the minimum time delay required between the completion of task $T_{ik}$ and the start of task $T_{ij}$.

Theorem 1.

Given a set of task dependencies modeled by LTL formulas and the available resources of the multi-satellite system, the dynamic scheduling problem has a feasible solution if the MINLP formulation satisfies all temporal logic constraints and resource limitations.

Proof. 

We first encode each LTL dependency of the form

$${\phi }_{ik\to ij}=G(F{T}_{ik}\to F{T}_{ij}).$$

By discretizing time into slots $t=1,\dots ,T$. We define the binary decision variables as follows:

$$x_{ij}\left(t\right)\in \{0,1\},\forall T_{ij},t=1,\dots ,T,$$

Let the start time of task $T_{ij}$ be given by

$$t_{ij}=\sum _{t=1}^{T}t{x}_{ij}\left(t\right).$$

(34)

For every dependency pair $(T_{ik},T_{ij})$ with a required minimum delay ${\tau }_{ik}$, introduce an auxiliary binary variable $z_{ijk}\in \{0,1\}$ and enforce the constraints

$$t_{ij}\ge t_{ik}+{\tau }_{ik}-M(1-z_{ijk}),$$

(35)

$$\sum _{t=1}^T{x}_{ik}\left(t\right)\le T{z}_{ijk},\sum _{t=1}^T{x}_{ik}\left(t\right)\ge z_{ijk},$$

(36)

where M is a sufficiently large constant ensuring that when $z_{ijk}=0$, the constraint (35) is inactive.

Resource limitations for each satellite s are imposed by the linear constraint

$$\sum _{T_{ij}\in \mathcal{M}}R\left(T_{ij}\right)x_{ijs}\le R_s,\forall s,$$

(37)

where $R\left(T_{ij}\right)$ denotes the resource requirement of task $T_{ij}$, and $R_s$ is the resource capacity of satellite s.

Thus, the overall MINLP formulation is

$$\begin{array}{cc}\hfill \underset{x_{ij}\left(t\right),t_{ij}}{\min }& \underset{T_{ij}\in \mathcal{M}}{\max }\left(t_{ij}+d_{ij}\right),\hfill \\ \hfill \mathrm{s}.\mathrm{t}.& t_{ij}=\sum _{t=1}^{T}t{x}_{ij}\left(t\right),\forall T_{ij}\in \mathcal{M},\hfill \\ \hfill & \sum _{t=1}^T{x}_{ij}\left(t\right)=1,x_{ij}\left(t\right)\in \{0,1\},\forall T_{ij}\in \mathcal{M},\hfill \\ \hfill & t_{ij}\ge t_{ik}+{\tau }_{ik}-M(1-z_{ijk}),\forall (T_{ik},T_{ij}),\hfill \\ \hfill & \sum _{t=1}^T{x}_{ik}\left(t\right)\le T{z}_{ijk},\sum _{t=1}^T{x}_{ik}\left(t\right)\ge z_{ijk},\forall (T_{ik},T_{ij}),\hfill \\ \hfill & \sum _{T_{ij}\in \mathcal{M}}R\left(T_{ij}\right)x_{ijs}\le R_s,\forall s,\hfill \end{array}$$

(38)

Since all LTL formulas are systematically transformed into the linear inequalities Equations (35) and (36) via auxiliary variables and big-M constraints, and the resource constraints (37) are inherently linear, the MINLP in Equation (38) comprises a finite set of linear inequalities. Therefore, if there exists an assignment of the binary variables $\{x_{ij}\left(t\right),z_{ijk}\}$ satisfying Equation (38), a feasible schedule exists. Consequently, under the condition that all temporal logic and resource constraints are met, the dynamic scheduling problem admits a feasible solution.    □

Based on the concept above, we proposed a scheduling algorithm that employs MINLP to dynamically adjust task scheduling in real time based on the system state and task dependencies. The main idea of the proposed TL-MIS is shown in Algorithm 3.

Algorithm 3: Dynamic Scheduling Using Temporal Logic and MINLP (TL-MIS)

This algorithm starts by initializing the task states and available resources (Lines 2–3). In each iteration, it constructs a scheduling problem based on the current set of tasks and constraints (Line 5). Then, for every task $T_i$ in the set M, if the task dependencies ${\varphi }_{ij}$ (as specified by temporal logic) are satisfied, the algorithm assigns $T_i$ to a satellite from S, determines its start time $t_i$ and duration $\Delta t_i$ (Lines 6–9), and updates the available resources by subtracting the resources required for $T_i$ (Line 10). After processing all tasks in the current iteration, the task states are updated (Line 11), and completed tasks are removed from M (Line 12). Finally, the algorithm returns the optimal task scheduling $x_{ij}\left(t\right)$, which specifies the execution schedule that meets all the temporal and resource constraints.

The proposed dynamic scheduling approach leverages temporal logic to encode task dependencies directly into the scheduling model, allowing for a flexible and robust adaptation to the dynamic nature of multi-satellite cooperative computing. The use of MINLP ensures that the solution satisfies all the constraints, providing a feasible and efficient scheduling strategy.

4.4. Overall Algorithm and Complexity Analysis

In Section 4, we propose a priority-aware decomposition and dynamic resource mapping approach for optimizing multi-satellite cooperative computing. The method integrates three primary components: task decomposition based on graph theory and ILP, resource allocation modeled as a game-theoretic problem solved by DRL, and dynamic scheduling formulated with LTL and MINLP.

The task decomposition module utilizes a DAG representation. It transforms the problem into an ILP formulation, where a Lagrangian relaxation-based heuristic efficiently explores feasible task allocation solutions while satisfying dependencies and resource constraints. The resource mapping and allocation module employs a game-theoretic model, where satellites compete for resources, and a Nash equilibrium-based strategy is determined through a DRL approach. This enables adaptive real-time optimization in response to system dynamics. The dynamic scheduling module leverages LTL to model task dependencies explicitly and incorporates an MINLP solver to iteratively adjust task execution in real time, ensuring the temporal constraints are met.

At each scheduling step, the proposed method executes three sub-algorithms sequentially. The complexity analysis shows that the dominant computational cost arises from the ILP-based task decomposition, which has a complexity of $O\left(N^3\right)$, given that the graph-based task dependency representation typically requires cubic complexity for solving the associated ILP problems. Meanwhile, the reinforcement learning-based resource mapping algorithm contributes an additional complexity of $O(K·N^2)$ per iteration, where K denotes the number of training iterations, and N is the number of satellites. The dynamic scheduling algorithm based on temporal logic and MINLP further contributes a complexity of approximately $O\left(N^2\log N\right)$ due to the nonlinear constraints and temporal logic encoding.

Therefore, combining these analyses, the overall time complexity per iteration of the proposed method is $O\left(N^3\right)$, dominated by the ILP component. Thus, the overall computational complexity of the algorithm across all iterations is $O(T_{\max }·N^3)$, where $T_{max}$ denotes the maximum number of iterations until convergence.

5. Experiment Results

In order to evaluate the performance of the proposed method, we construct an experimental scenario oriented to the decomposition of remote sensing tasks based on the self-developed Common Satellite Toolkit (CSTK) simulation platform. The CSTK platform calculates the real-time positions and orbits of the satellites within a 3D scenario for the satellite’s TLE data and assigns a unique computation, storage, and observation payload resource to each satellite for mission execution.

5.1. Simulation Scenario and Dataset Details

This scenario simulates the task of remote sensing data decomposition and allocation in a dynamic satellite network, with a duration from 04:00:00.00 UTC on 3 September 2024 to 04:00:00.00 UTC on 5 September 2024.

When constructing remote sensing tasks, we thoroughly considered the satellites’ operational status and the target area’s geographical characteristics. Each remote sensing task is represented as a structured data unit designed to facilitate efficient scheduling and resource allocation in a dynamic satellite network. The dataset captures both the satellites’ operational status and the target areas’ geographical characteristics, enabling accurate imaging and timely task execution. The main fields include the task ID, satellite ID assigned to the task, task time window, target area, expected data volume, task priority, and task dependencies. Regarding the target area, we describe it in the form of latitude and longitude ranges, clearly specifying the minimum and maximum latitude and longitude of the imaging area to ensure accurate coverage of the predetermined area during task execution. The “task dependency relationship” field clearly describes the sequential dependencies between the current task and other tasks.

Specifically, in each task, the observable angle and altitude requirements between the satellite and the target area are determined through precise calculations based on the satellite’s orbit information and ground station position. We use a formula to calculate the observation angle that meets the minimum elevation angle requirement, in order to derive the most suitable imaging time window. Subsequently, we set different priorities for each task based on its importance and resource consumption. The resource requirements of the task are mainly reflected in the working status of the imaging payload and the data transmission requirements. During the task execution process, the satellite needs to complete multi-stage operations such as data acquisition, compression, and transmission in real time, and each stage has strict time and resource limitations.

To further illustrate the structure of the task dataset used in this study,

Table 1. A detailed description of remote sensing tasks.

Real Dataset	Task ID	Region		Discrete Time Range		Resource Type
		Latitude (deg)	Longitude (deg)	Start Time (s)	End Time (s)	All
$D_{real}$	T1	0	−0.280806	10	86,450	1,2,3
		0	89.5788
		59.8026	89.5788
		59.8026	−0.280806
	T2	0	59.8128	10	86,450	1,2,3
		29.6053	59.8128
		29.6053	−30.0468
		−0.592105	−30.0468

provides a more detailed breakdown of actual task instances, including task IDs, target observation regions, discrete time ranges, and resource requirements. The interface for adding remote sensing tasks is shown in Figure 2.

We combined precise satellite data and using the CSTK simulation platform to construct a real multi-satellite network environment. The actual dataset was constructed using precise satellite data from multiple authoritative platforms, including Celestrak (CELESTRAK same as below. satellite database: https://celestrak.org/) and SatNOGS (SatNOGS open-source ground station network: https://satnogs.org/). Celestrak provides precise orbit parameters (comprising the semi-major axis, eccentricity, inclination, ascending node longitude, and perigee angle) that meet the standards of the North American Aerospace Defense Command, ensuring reliable orbit information. SatNOGS provides detailed ground station observation data, such as coordinates and communication link status.

This dataset covers various key parameters in satellite networks, including the computing, storage, and payload resources of each satellite, as well as task identification, subtask details, task time windows, task priorities, and resource requirements in task data. Specifically, the satellite data section provides a detailed record of the resource distribution of each satellite. The task data section decomposes each remote sensing task into several subtasks, which not only indicate the type (such as observation or compression), priority, and required resources, but also clearly define the start and end time windows of the task and the dependencies between tasks. As shown in

Table 2. Field definitions and value ranges.

Satellite Data
Field Name	Notation	Value Range
Satellite ID	$s_i$	1–300
Computation Resource	$rb\left(s_i\right)$	70–150
Storage Resource	$C_i$	300–500 MB
Payload Resource	$rp\left(s_i\right)$	1–3
Task ID	$m_i$	1–300
Subtask ID	$T_{ij}$	–
Subtask Type	–	compression, observation
Priority	${\omega }_{ij}$	1–5
Computation Requirement	$rb\left(T_{ij}\right)$	32–100
Storage Requirement	$D\left(T_{ij}\right)$	173–294
Payload Requirement	$rp\left(T_{ij}\right)$	0–3
Start Time	$E_k$	2024-09-06 T 18:29:44 Z
End Time	$L_k$	2024-09-06 T 20:29:44 Z
Dependencies	dependencies	empty or list of Subtask IDs

, we can intuitively understand how the dataset comprehensively reflects the satellite orbit characteristics, resource distribution, and key parameters in task scheduling.

In order to evaluate the performance of this paper under each evaluation metric, we conducted simulation experiments on 14 datasets with different numbers of satellites and numbers of missions.

Table 3. Number of satellites and tasks in selected datasets.

Datasets	${\mathit{D}}_1$	${\mathit{D}}_2$	${\mathit{D}}_3$	${\mathit{D}}_4$	${\mathit{D}}_5$	${\mathit{D}}_6$	${\mathit{D}}_7$
Satellite Nodes	10	20	40	60	80	100	120
Task Quantity	20	40	60	100	120	140	150
Datasets	${\mathit{D}}_{\mathbf{8}}$	${\mathit{D}}_{\mathbf{9}}$	${\mathit{D}}_{\mathbf{10}}$	${\mathit{D}}_{\mathbf{11}}$	${\mathit{D}}_{\mathbf{12}}$	${\mathit{D}}_{\mathbf{13}}$	${\mathit{D}}_{\mathbf{14}}$
Satellite Nodes	140	160	180	200	220	240	300
Task Quantity	200	240	280	300	360	400	300

shows the details of the datasets used for the experiments.

5.2. Comparative Algorithm and Performance Metrics

To address the problem’s characteristics of temporal variation, complex resource allocation, block structure preservation, network delay, and hierarchical scheduling, we select five comparative algorithms: Optimizing Scheduled Virtual Machine Requests Placement in Cloud Environments: A Tabu Search Approach (TS-SVMPP) [31] with time complexity $O\left(n^2\right)$; Cooperative Mapping Task Assignment of Heterogeneous Multi-UAV Using an Improved Genetic Algorithm (IDCE-GA) [30] with time complexity $O\left(PG\right)$ (in the genetic algorithm, P represents the population size in each generation, and G represents the number of generations); MILP-StuDio: MILP Instance Generation via Block Structure Decomposition (MILP-STUDIO) [25] with time complexity $O\left(n^3\right)$; Resource Allocation Considering Impact of Network on Performance in a Disaggregated Data Center (RA-CNP) [29] with time complexity $O\left(n\log n\right)$; and Task Decomposition and Hierarchical Scheduling for Collaborative Cloud–Edge–End Computing (VNE-AC) [36] with time complexity $O\left(n\right)$. In addition, the HEFT-LA algorithm [26] is included in the scheduling category with time complexity $O\left(n^2\right)$, which improves task execution efficiency through a lookahead variant, and the PA-LBIMM algorithm [32] with time complexity $O\left(PG\right)$, which integrates user-priority-based Min-Min scheduling to enhance load balancing. These algorithms are commonly used to solve resource allocation and scheduling problems and have efficient optimization effects. TS-SVMPP and IDCE-GA are often used to optimize virtual machine placement and UAV task allocation, demonstrating good adaptability, while MILP-STUDIO, RA-CNP, and VNE-AC exhibit strong optimization capabilities in large-scale and dynamic environments.

For performance evaluation, we employ the following metrics. Task execution rate $TCR\left(t\right)$ is calculated using the equation

$$TCR(t)={\displaystyle \frac{N_{\mathrm{completed}}\left(t\right)}{N_{\mathrm{total}}\left(t\right)}}$$

(39)

which evaluates the proportion of successfully executed tasks. The objective function value defined in Equation (19) is used to quantify the overall optimization effect of the system. Additionally, resource utilization $U_r(t)$ serves as a metric to evaluate the efficiency of resource allocation, defined as

$$U_r(t)={\displaystyle \frac{{\sum }_{s\in S}{R}_s^{\mathrm{used}}}{{\sum }_{s\in S}{R}_s^{\mathrm{total}}}}$$

(40)

To measure communication costs, we introduce the following metrics:

$$CC={\displaystyle \frac{{\sum }_{s\in S}{\sum }_{i,j\in M_s}c\left(T_{ij}\right)}{{\sum }_{s\in S}{C}_s}}$$

(41)

where $c\left(T_{ij}\right)$ represents the communication cost for task $T_{ij}$ in the communication resource request, and $C_s$ represents the total communication capacity of the resource. This metric reflects the communication cost incurred during the execution of tasks, with lower values indicating better communication efficiency. The CC helps evaluate the optimization of communication resources and their impact on the overall system.

In addition, our evaluation criteria also include EQ (task execution quality, where higher values indicate better completion), UQ (execution uncertainty, where lower values indicate smaller errors or delays), and SR (success rate, measured as the ratio of executed tasks to total tasks, expressed as a percentage).

5.3. Numerical Analysis

For each dataset, we performed multiple executions to ensure the robustness and stability of the algorithm, facilitating subsequent comparison and analysis. Our data is based on simulated and synthetic data, reflecting remote sensing satellite tasks in the real world, providing insights into the performance of algorithms in real-world environments.

Figure 3 provides the objective function values and optimization trends for 14 datasets, offering a detailed view of the performance of each algorithm at different task scales. From

Table 4. Objective function value results across 14 datasets.

Datasets	HEFT-LA [26]	PA-LBIMM [32]	IDCE-GA [30]	TS-SVMPP [31]	MILP-STUDIO [25]	RA-CNP [29]	VNE-AC [36]	HADRM
$D_1$	12,031.12	11,530.57	12,058.48	9102.37	9524.48	9500.25	8964.25	11,031.12
$D_2$	24,041.98	23,012.32	13,548.48	12,001.33	11,548.48	12,314.66	12,856.35	22,541.99
$D_3$	76,841.25	75,341.26	578,412.13	520,147.66	508,741.13	525,478.99	553,284.27	75,321.26
$D_4$	107,481.54	105,486.17	98,521.48	89,214.65	81,425.48	90,214.55	95,632.46	105,481.55
$D_5$	265,145.89	252,347.36	198,745.48	194,512.37	174,785.48	198,523.13	204,654.30	252,145.90
$D_6$	425,512.32	420,134.12	451,478.33	412,654.75	386,521.13	435,254.74	426,587.11	404,512.33
$D_7$	765,648.25	752,218.74	815,478.65	1,014,520.85	964,587.33	1,023,200.99	1,045,545.99	745,648.25
$D_8$	1,021,457.15	1,051,234.28	1,158,745.21	1,302,541.66	1,224,587.66	1,325,000.55	1,355,596.65	1,152,145.15
$D_9$	1,223,521.25	1,212,356.98	1,387,452.15	1,554,789.54	1,458,741.21	1,574,215.65	1,580,025.24	1,203,521.25
$D_{10}$	1,387,582.36	1,378,620.54	1,758,412.66	1,812,254.15	1,725,412.65	1,823,654.55	1,856,833.00	1,366,582.37
$D_{11}$	1,652,645.29	1,556,321.27	1,854,785.21	1,925,874.66	1,798,541.15	1,954,785.55	1,972,285.36	1,542,645.30
$D_{12}$	1,634,658.48	1,534,625.72	2,254,874.21	2,203,547.12	2,145,874.21	2,245,214.99	2,270,025.69	1,523,658.48
$D_{13}$	1,774,511.54	1,611,241.28	2,458,741.66	2,365,412.15	2,314,789.65	2,385,412.66	2,402,569.55	1,604,511.55
$D_{14}$	2,258,836.49	2,052,354.12	3,685,412.33	3,502,541.65	3,414,789.33	3,552,148.66	3,595,541.00	2,038,836.49

, it can be seen that HADRM consistently produces lower objective function values in larger-scale scenarios. For example, in dataset D12, the value of HADRM is 1,523,658, while the value of IDCE-GA is 2,254,874, a decrease of approximately 32.4%. In dataset D14, the value of HADRM2038836 increases by nearly 44.7% compared to the 3,685,412 reported by IDCE-GA. These quantitative differences highlight the enhanced ability of HADRM in managing large-scale complex task environments.

The outstanding performance of HADRM can be attributed to its hierarchical adaptive decomposition and reinforcement learning-based resource mapping mechanism. Specifically, HADRM dynamically decomposes complex task sets into smaller subproblems, simplifying scheduling and reducing computational overhead. Its reinforcement learning component continuously adjusts resource mapping decisions in real time based on constantly changing network conditions and task dependencies. This integrated, data-driven approach enables HADRM to quickly adapt and maintain efficient resource allocation, even in the face of a surge in workload.

In contrast, IDCE-GA and TS-SVMPP, although they perform reasonably in medium-sized scenarios, lack this dynamic adjustment capability. This limitation makes it difficult for them to maintain stable optimization when the task load increases. Similarly, MILP-STUDIO and RA-CNP rely on complex integer programming formulas, which can lead to a rapid increase in computational overhead in large-scale environments. Although VNE-AC sometimes produces competitive results in smaller networks, its static scheduling mechanism limits its adaptability to rapidly changing conditions in a wider and more complex environment. Though HEFT-LA and PA-LBIMM perform reasonably well, they still do not achieve the same level of optimization as HADRM. HEFT-LA lacks the dynamic resource mapping of HADRM, making it less effective in large-scale, dynamic environments. PA-LBIMM, while incorporating user-priority awareness, relies on static scheduling, limiting its adaptability in complex, fluctuating conditions.

Table 5. Resource utilization across 14 datasets.

Datasets	HEFT-LA [26]	PA-LBIMM [32]	IDCE-GA [30]	TS-SVMPP [31]	MILP-STUDIO [25]	RA-CNP [29]	VNE-AC [36]	HADRM
$D_1$	93.0214%	95.1215%	89.5412%	96.5874%	97.8541%	96.0415%	98.5415%	94.5214%
$D_2$	92.6521%	94.4542%	86.9874%	97.5412%	96.9874%	97.1245%	98.1123%	94.1521%
$D_3$	90.5426%	90.5124%	87.4578%	95.5874%	96.5874%	95.5874%	97.5641%	91.5426%
$D_4$	86.0141%	87.5126%	74.5478%	87.2542%	88.5478%	87.4523%	88.6541%	87.2141%
$D_5$	87.0541%	88.5126%	72.5874%	86.0987%	87.4574%	86.0145%	88.3354%	88.6541%
$D_6$	84.0424%	84.9732%	75.2145%	82.5412%	89.5214%	81.2542%	84.5412%	85.1424%
$D_7$	86.0145%	88.7215%	76.5874%	83.0124%	91.0874%	82.8124%	84.5524%	88.2145%
$D_8$	81.5471%	83.7423%	72.8541%	79.8452%	88.2354%	80.2531%	80.5569%	83.5471%
$D_9$	82.5487%	83.6523%	69.8574%	76.4521%	85.0214%	76.8421%	77.3695%	83.5487%
$D_{10}$	89.2541%	92.4542%	68.5478%	73.1254%	83.2478%	72.6589%	73.5586%	92.2541%
$D_{11}$	81.0424%	82.0652%	64.5874%	71.8745%	81.0587%	71.0548%	73.5548%	81.5496%
$D_{12}$	81.0493%	82.0632%	61.2478%	70.1254%	79.0154%	69.3214%	72.2154%	81.5493%
$D_{13}$	79.0469%	80.7392%	57.8541%	66.5478%	76.5874%	65.8742%	67.5541%	80.2469%
$D_{14}$	76.5143%	77.9435%	53.2478%	62.8745%	72.5874%	61.8541%	63.2895%	77.5143%
Average	85.0246%	86.6049%	72.2428%	79.3857%	90.1071%	79.3928%	88.0500%	83.1071%

shows the resource utilization percentages of each algorithm at different task scales, providing us with a detailed quantitative evaluation. For example, in dataset D14, the resource utilization rate of HADRM reached 77.5143%, higher than IDCE-GA’s 53.2478% and TS-SVMPP’s 62.8745%; in dataset D10, the resource utilization rate of HADRM reached 92.2541%, which is also better than the other comparative algorithms. These data fully demonstrate the ability of HADRM to more efficiently utilize available resources in large-scale complex task environments.

As shown in Figure 4a, we first evaluate each algorithm’s resource utilization in a static scenario by gradually increasing the task size. The results indicate that HADRM consistently maintains a high utilization rate, reflecting its advantage in real-time resource allocation as the task size grows.

Next, to investigate how the iteration count affects performance, we conduct a parameter-tuning experiment. Specifically, we adjust the number of iterations and observe the algorithms’ dynamic changes in resource usage. As illustrated in Figure 4b, HADRM continues to achieve the highest utilization among all methods over successive iterations, demonstrating robust and adaptive resource allocation under changing workload conditions.

Its excellent performance is mainly attributed to its hierarchical adaptive decomposition and reinforcement learning-based resource mapping mechanism. Specifically, HADRM simplifies the scheduling process and reduces computational overhead by dynamically decomposing complex task sets into more manageable subproblems; meanwhile, its reinforcement learning module can adjust resource allocation decisions in real time based on constantly changing network conditions and task dependencies.

However, although IDCE-GA and TS-SVMPP perform well in medium-scale scenarios, they lack the necessary dynamic adjustment capabilities, making it difficult for them to maintain stable optimization effects when task loads increase; however, MILP-STUDIO and RA-CNP rely on complex integer programming methods, leading to a rapid increase in computational overhead in large-scale environments. In addition, the static scheduling mechanism of VNE-AC also limits its adaptability in rapidly changing and complex environments. Although HEFT-LA and PA-LBIMM performed well, especially the PA-LBIMM algorithm, which showed competitive results in multiple datasets, HADRM maintained more balanced and efficient resource utilization overall.

As shown in

Table 6. Task execution time across 14 datasets.

Algorithms	${\mathit{D}}_1$	${\mathit{D}}_2$	${\mathit{D}}_3$	${\mathit{D}}_4$	${\mathit{D}}_5$	${\mathit{D}}_6$	${\mathit{D}}_7$
HEFT-LA [26]	320.35	810.21	1070.35	2600.22	1800.23	4350.25	8650.65
PA-LBIMM [32]	325.46	815.21	1045.22	2558.75	1760.35	4480.77	8664.25
IDCE-GA [30]	354.21	412.48	854.21	2854.33	3145.48	4854.33	9124.21
TS-SVMPP [31]	220.13	390.21	705.21	2175.13	2385.66	4550.48	4789.15
MILP-STUDIO [25]	198.13	356.48	685.21	1954.33	2187.48	3845.33	4201.21
RA-CNP [29]	245.66	410.24	710.13	2204.13	2405.66	4900.54	5250.33
VNE-AC [36]	215.66	452.16	769.35	2335.27	2546.29	4685.89	4961.23
HADRM	314.25	798.21	1044.35	2554.22	1752.23	4265.25	8547.65
Algorithms	${\mathit{D}}_{\mathbf{8}}$	${\mathit{D}}_{\mathbf{9}}$	${\mathit{D}}_{\mathbf{10}}$	${\mathit{D}}_{\mathbf{11}}$	${\mathit{D}}_{\mathbf{12}}$	${\mathit{D}}_{\mathbf{13}}$	${\mathit{D}}_{\mathbf{14}}$
HEFT-LA [26]	5700.65	7630.33	9764.33	12,850.33	10,250.66	11,300.65	29,950.15
PA-LBIMM [32]	5634.82	7637.54	9684.33	12,647.54	10,124.76	11,117.65	30,052.54
IDCE-GA [30]	6541.15	12,548.48	15,847.33	18,457.13	21,874.48	27,541.21	39,874.13
TS-SVMPP [31]	5987.45	12,012.48	14,985.21	19,458.33	22,514.48	26,847.45	39,874.13
MILP-STUDIO [25]	5001.15	10,845.48	13,487.33	17,845.13	20,541.48	24,847.21	37,254.13
RA-CNP [29]	6100.15	12,245.66	15,234.66	19,852.13	22,841.66	27,041.66	40,532.13
VNE-AC [36]	6553.49	12,509.37	15,660.33	20,053.44	23,360.23	27,654.12	41,025.67
HADRM	5562.65	7536.33	9564.33	12,541.33	10,032.66	11,054.65	29,652.15

and Figure 5a, we measure the task execution time of each algorithm at different task scales, providing a comprehensive quantitative comparison. From these results, it is evident that algorithms such as MILP-STUDIO and TS-SVMPP perform well in small-scale datasets with shorter execution times; however, as the task scale increases, HADRM demonstrates notable advantages. For example, in dataset D14, the execution time of HADRM is 29,652.15, which is substantially lower than MILP-STUDIO’s 37,254.12 and the times of IDCE-GA and TS-SVMPP, both around 39,874.12.

Next, to investigate how the iteration count affects task execution time, we conducted a parameter-tuning experiment. As shown in Figure 4b, HADRM not only achieves lower execution times, but also converges more rapidly over successive iterations, indicating that in large-scale, complex task scenarios, HADRM can more efficiently handle task scheduling and resource allocation.

The advantage of HADRM lies in its adoption of a scheduling strategy that integrates hierarchical adaptive decomposition and reinforcement learning. Specifically, HADRM reduces the dimensionality of problems by decomposing large-scale complex tasks into multiple easily manageable subtasks, and utilizes reinforcement learning modules to monitor network status and task dependency changes in real time, dynamically adjusting scheduling strategies and effectively shortening overall execution time. In contrast, IDCE-GA is based on genetic algorithms, and its evolutionary process converges slowly and is prone to becoming stuck in local optima, making it difficult to search for global optimal solutions in a timely manner when facing large-scale tasks. Although TS-SVMPP uses tabu search to improve local optimization, the search space rapidly expands when the number of tasks increases, resulting in a significant increase in computational burden. MILP-STUDIO relies on integer programming for solving, and its computational complexity increases exponentially, leading to a sharp increase in computation time in large-scale scenarios. RA-CNP adopts a static network performance model, and the scheduling strategy lacks responses to real-time changes in task load and network status. The fixed static scheduling mechanism of VNE-AC cannot effectively cope with the dynamic changes in task dependencies in complex environments, and its overall scheduling efficiency is greatly limited.

For clarity of presentation, we conducted experiments on all 14 datasets but only show representative results for four of them in this table. The

Table 7. Task execution performance across 4 datasets.

Algorithms	${\mathit{D}}_5$			${\mathit{D}}_9$			${\mathit{D}}_{13}$			${\mathit{D}}_{14}$
	EQ	UQ	SR	EQ	UQ	SR	EQ	UQ	SR	EQ	UQ	SR
HEFT-LA [26]	77	3	96.22%	144	16	89.99%	210	30	87.45%	261	39	87.01%
PA-LBIMM [32]	77	3	95.77%	142	18	88.55%	208	32	86.59%	256	44	85.30%
IDCE-GA [30]	75	5	93.75%	138	22	86.25%	206	34	85.83%	250	50	83.33%
TS-SVMPP [31]	77	3	96.25%	143	17	89.38%	210	30	87.50%	253	47	84.33%
MILP-STUDIO [25]	76	4	95.00%	144	16	90.00%	210	30	87.50%	260	40	86.67%
RA-CNP [29]	77	3	96.25%	143	17	89.38%	209	31	87.08%	261	39	87.00%
VNE-AC [36]	73	7	91.25%	134	26	83.75%	199	41	82.92%	243	57	81.00%
HADRM	78	2	97.50%	146	14	91.25%	215	25	89.58%	264	36	88.00%

provides a detailed display of two key metrics for task execution for each algorithm in four datasets ($D_1$–$D_4$). From the table, it can be seen that HADRM achieved the best performance in all datasets. For example, in dataset $D_1$, HADRM’s EQ reached 78 and its UQ was only 2, significantly better than those of IDCE-GA (EQ 75, UQ 5), TS-SVMPP (EQ 77, UQ 3), MILP-STUDIO (EQ 76, UQ 4), and VNE-AC (EQ 73, UQ 7). In dataset $D_2$, HADRM led again with EQ 146 and UQ 14. In datasets $D_3$ and $D_4$, HADRM achieved EQs of 215 and 264, respectively, while its UQs were only 25 and 36. These data fully demonstrate the advantages of HADRM in terms of task execution quality and stability.

The trend of task execution rate in Figure 6 further illustrates the dynamic changes in the performance of various algorithms at different task scales. From the graph, it can be seen that as the task size increases, and HADRM consistently maintains high execution quality and low uncertainty, demonstrating its ability to effectively schedule tasks and reduce errors in high-load environments. This outstanding performance is mainly attributed to the advanced task decomposition and real-time scheduling mechanism adopted by HADRM, which can dynamically split complex tasks into manageable subtasks and flexibly adjust scheduling strategies based on real-time feedback, thereby ensuring efficient and stable execution in large-scale task environments.

In contrast, IDCE-GA relies on traditional genetic algorithms, while TS-SVMPP introduces tabu search to improve local optimization, but the search space rapidly expands when the task size increases. The integer programming method used by MILP-STUDIO has high computational complexity, while RA-CNP is limited by static network models, and the fixed scheduling mechanisms of VNE-AC cannot easily balance efficiency and low uncertainty in large-scale complex environments. HEFT-LA and PA-LBIMM demonstrate competitive performance in terms of makespan and resource utilization but still fall behind HADRM. While they offer improvements in load balancing and user-priority handling, their task execution time and resource utilization are less optimized compared to HADRM’s more efficient scheduling. This is mainly due to the lack of dynamic task mapping in HEFT-LA and the trade-off between VIP and ordinary tasks in PA-LBIMM.

Figure 7 presents the normalized communication cost across all 14 datasets for each algorithm. From the graph, it is clear that HADRM consistently outperforms the other algorithms in minimizing communication cost, especially in large-scale environments. For example, in dataset $D_5$, HADRM reduces the communication cost by approximately 2% compared to IDCE-GA, and by over 4% compared to MILP-STUDIO. Additionally, in the dataset $D_{13}$, HADRM achieves a significant reduction of around 5% compared to PA-LBIMM, and a 3% improvement over RA-CNP. These results highlight HADRM’s superior efficiency in managing communication resources, especially when task scale increases.

In contrast, algorithms like IDCE-GA and TS-SVMPP, although they perform well in certain datasets, exhibit a higher communication cost due to the inefficiencies in their communication scheduling mechanisms. Similarly, RA-CNP and VNE-AC struggle with communication overhead, while HEFT-LA and PA-LBIMM, though competitive in some aspects, still lag behind HADRM. This is primarily due to HADRM’s advanced dynamic resource mapping and task scheduling mechanisms, which optimize both task execution and communication cost effectively in large-scale environments.

5.4. Summary

In conclusion, the proposed HADRM method outperformed the comparative algorithms in multiple key performance indicators. HADRM performs particularly well in large-scale task scenarios, with significantly improved resource utilization and significantly better objective function values and task execution times than IDCE-GA, TS-SVMPP, MILP-STUDIO, HEFT-LA, RA-CNP, and VNE-AC. RA-CNP and VNE-AC significantly lag behind. HADRM also consistently outperforms the other algorithms in terms of CC, especially in large-scale environments. Compared to IDCE-GA, TS-SVMPP, and MILP-STUDIO, HADRM achieves a significant reduction in communication cost. It is worth noting that MILP-STUDIO has demonstrated solution accuracy and efficiency on a small task scale that is not inferior to the algorithm proposed in this paper. However, in large-scale models, our method outperforms MILP-STUDIO in terms of resource utilization and execution time. In contrast, IDCE-GA has slower convergence speed and is prone to becoming stuck in local optima due to the limitations of genetic algorithms. When the workload of TS-SVMPP surges, the search space expands rapidly and the computational load increases rapidly. RA-CNP adopts a static network model, which cannot easily adapt to environmental changes. The fixed scheduling mechanism of VNE-AC also limits its response to dynamic changes in task dependencies. Although HEFT-LA and PA-LBIMM perform well in certain evaluation metrics such as resource utilization, HEFT-LA’s local optimal decision-making is enhanced by introducing forward-looking information from task sub-nodes, but still lacks adaptability to dynamic environmental changes. The load balancing mechanism of PA-LBIMM also limits its flexible response to changes in task priority. It is precisely these specific shortcomings that have led to a significant decline in the performance of comparative algorithms in large-scale complex task environments, while HADRM has achieved superior performance due to its real-time dynamic optimization mechanism.

6. Conclusions

In this paper, we solve the problem of low efficiency in complex task decomposition and dynamic resource allocation in multi-satellite collaborative computing. The innovation of this study lies in proposing a dynamic resource mapping method based on task priority using graph theory decomposition, game theory, and deep reinforcement learning, as well as a real-time task scheduling method based on temporal logic.

The experimental results show that in the selected dataset, the objective function value of our method is reduced by at least 32.4% compared to the comparative algorithms (such as IDCE-GA), and the task execution time is significantly reduced, especially in large-scale scenarios where the resource utilization advantage is obvious. However, this method still has shortcomings in terms of parameter tuning and computational complexity control, and further optimization of the algorithm’s convergence and real-time performance is needed in practical applications. In future research, we will explore low-complexity joint optimization strategies and combine digital twin technology to achieve virtual real linkage, in order to further enhance the dynamic adaptability of the algorithm in heterogeneous satellite network collaborative scenarios.