Remote-Sensing Satellite Mission Scheduling Optimisation Method under Dynamic Mission Priorities

Abstract

Mission scheduling is an essential function of the management control of remote-sensing satellite application systems. With the continuous development of remote-sensing satellite applications, mission scheduling faces significant challenges. Existing work has many inherent shortcomings in dealing with dynamic task scheduling for remote-sensing satellites. In high-load and complex remote sensing task scenarios, there is low scheduling efficiency and a waste of resources. The paper proposes a scheduling method for remote-sensing satellite applications based on dynamic task prioritization. This paper combines the and Bound methodologies with an onboard task queue scheduling band in an active task prioritization context. A purpose-built emotional task priority-based scheduling blueprint is implemented to mitigate the flux and unpredictability characteristics inherent in the traditional satellite scheduling paradigm, improve scheduling efficiency, and fine-tune satellite resource allocation. Therefore, the Branch and Bound method in remote-sensing satellite task scheduling will significantly save space and improve efficiency. The experimental results show that comparing the technique to the three heuristic algorithms (GA, PSO, DE), the BnB method usually performs better in terms of the maximum value of the objective function, always finds a better solution, and reduces about 80% in terms of running time.

1. Introduction

The application fields of remote-sensing satellites are constantly evolving and changing. The scale of the satellite observation network constituted by different sensor satellites and star cluster networks will grow. Satellite ground stations will receive satellite telemetry data and transmit satellite control commands at the same time. Satellite mission scheduling technology is the unified and orderly scheduling management of multiple missions from multiple ground stations for numerous satellites. The remote-sensing satellite systems field is experiencing an unprecedented surge in complexity, which drives the need for dynamic and intelligent satellite mission scheduling. Dynamic prioritized satellite mission scheduling has two advantages over traditional static or semi-static scheduling frameworks. Firstly, dynamically prioritized satellite mission scheduling can preemptively adapt to fluctuations in mission complexity [1,2,3] and resource constraints [4,5,6,7] in modern satellite networks compared to obsolete static or semi-static scheduling frameworks. Secondly, dynamic mission prioritized satellite mission scheduling can always find the optimal solutions to improve efficiency and save time. That improves efficiency and saves a lot of time. This can open up many new opportunities and applications.

Certainly, satellite mission scheduling has undoubtedly faced significant challenges in recent years as technological breakthroughs in remote-sensing satellite applications and growing demands in the era of globalization continue to drive conventional systems forward. As we navigate the intricacies of satellite applications, we need to be clear about two aspects. The first is that we need to be clear about the full potential of satellite resources, which are finite and costly, and adapt to the fluidity of mission priorities in real time. Inflexible mission scheduling mechanisms may lead to suboptimal allocation of resources, which may result in a significant decrease in efficiency. Second, we need to ensure that tasks located on the priority ladder are executed with unparalleled accuracy and scheduling capabilities to achieve optimal results and time to complete satellite task execution. Finally, realizing these two paths is full of challenges, navigating the constant changes in task priorities, specifying the optimal time within tight resource constraints, and ensuring the algorithms are robust.

To cope with and overcome these challenges, researchers have proposed a dynamic mission scheduling framework in the remote-sensing satellite application domain [2,8,9]. The dynamic mission scheduling framework can be effectively applied to the time-varying nature of satellite networks and the timeliness of remote-sensing satellite mission scheduling in the face of the dynamic mobility of satellite resources in remote-sensing satellite networks and the complexity of the environment. The researchers also propose a dynamic resource allocation strategy to integrate and optimize the resources in the satellite network [10,11]. In addition, deep learning [12,13] and meta-heuristic algorithms [14] are proposed for remote-sensing satellite task scheduling to improve the inefficiency of task scheduling and to adapt to the dynamics of task prioritization.

However, the existing remote-sensing satellite task scheduling framework faces challenges such as huge consumption of computational resources [2,9], insufficient dynamic adjustment capability [8], and insufficient adaptability as well as real-time performance [15,16]. Moreover, due to the high computational power requirement of deep learning [12,13] and the weak satellite computational power, it is not highly applicable in satellite networks. Meanwhile, meta-heuristic algorithms [14] are prone to fall into local optimums and have long computation time in the worst case, so they are not suitable for the time-varying characteristics of satellite networks and the high timeliness of task scheduling.

Therefore, in order to adapt to the time-varying characteristics of satellite networks and the need for high timeliness of task scheduling, and to improve the scheduling efficiency, we first propose a dynamic remote-sensing satellite task scheduling model, which takes into account the importance of task priority setting, resource allocation, and real-time parameter adjustment. Based on this model, we propose a novel scheduling algorithm based on the BnB method. By introducing a dynamic priority adjustment mechanism, the algorithm can respond to unforeseen changes in the satellite state or satellite tasks in real-time to optimize task priority and resource allocation. In addition, through the iterative optimization technique, the task sequence is subdivided into smaller sub-sequences, which are optimized and merged separately, further improving the accuracy as well as the performance of the scheduling scheme. Our method can effectively utilize computational resources, improve the adaptability of the model, flexibly respond to real-time changes in mission requirements to improve the satellite network and improve the real-time and adaptability of the system.

In this paper, we make the following contributions:

• A dynamic remote-sensing satellite task scheduling model is designed to solve the difficulties of mobility and unpredictability inherent in traditional static satellite task scheduling.
• The dynamic task prioritization based on the BnB method is proposed for dynamic remote-sensing satellite task scheduling, which overcomes the problems of huge consumption of computational resources and poor adaptability, and achieves the goals of efficiency improvement and adaptability enhancement.
• The efficiency of the BnB method is compared with three baseline algorithms through empirical validation using real satellite network data as well as simulated data. The results highlight the effectiveness of our method, which always finds better solutions and shows significant improvements in runtime.

2. Related Work

With the continuous development in the field of remote-sensing satellite application systems, the demand for dynamic intelligent task scheduling strategies is growing along with technological breakthroughs in remote-sensing satellite applications. Outdated static or semi-static scheduling frameworks cannot adapt to fluctuating task complexity and resource constraints in modern satellite networks. In the field of remote-sensing satellite mission scheduling, it is mainly confronted with huge consumption of computational resources [2,9], insufficient dynamic adjustment capability [8], adaptability [17,18] and real-time [15,16] challenges. These challenges lead to sub-optimal resource allocation as well as inefficiencies, especially in demanding as well as task-mobile situations. In this paper, we lay the foundation for a scheduling framework based on the BnB method by shedding light on these issues, and our method demonstrates the quest for efficiency and adaptability in remote-sensing satellite mission scheduling, providing a robust and comprehensive solution.

2.1. Dynamic Task Priority and Satellite Scheduling

Currently, static or semi-static task scheduling frameworks are unable to adapt to the complexity and dynamics of modern remote-sensing satellite networks [19,20,21,22]. There is an urgent need to design responsive and efficient systems that can adapt to fluctuations in task complexity [1,2,3] and resource constraints [4,5,6,7] and maintain performance and efficiency.

Fan et al. [8] highlighted the potential of the dynamic satellite auto-scheduling paradigm by introducing the satellite range scheduling for variable task priority in discrete periods algorithm (SRS&TPP). Their pioneering work became the cornerstone of subsequent breakthrough discoveries. Faced with ubiquitous challenges such as competition for resources, the ephemeral nature of information, and the slow pace of satellite mission scheduling, Dai et al. [2] proposed the first mobile scheduling device applied to remote-sensing satellite networks. Wang et al. [9] effectively solved problems such as delayed task execution due to limited satellite resources by introducing dynamic scheduling algorithms on a space mobile edge computing network. However, the above research faces problems such as insufficient dynamic adjustment capability and inefficiency when dealing with complex multi-task environments.

Lu et al. [17]’s study of satellite network structure has laid the groundwork for innovative scheduling strategies, providing a new perspective on the complexity of network performance. Implementing dynamic grouping in satellites improves routing efficiency and flexibility [23], crucial for mission scheduling flexibility. Weighting-based routing is effective in satellite communications, enhancing the prioritization process of network traffic [24]. The introduction of the TP-Satellite protocol significantly improves the throughput and fairness of resource allocation, which is critical for mission classification in satellite networks [25]. Adaptive transmission models set a new standard for energy-efficient satellite mission management [26]. At the same time, improved routing for low-Earth-orbit (LEO) networks [27] and improved routing in LEO networks take advantage of dynamic properties to optimize efficiency. However, the current research is faced with the complexity of network restructuring and the possible lack of sufficient real-time and adaptability.

Some heuristic algorithms are widely used in satellite networks because of their advantages of simplicity, fast computation, and the ability to adapt to the spatio-temporal dynamic characteristics of satellite networks as well as to satisfy the user’s need for high timeliness of task execution. Chen et al. [28] improved the efficiency of multi-satellite observation by combining genetic algorithms (GA) and satellite scheduling. Velliangiri et al. [15] extended the promise of adaptive scheduling techniques beyond cloud computing by combining e-search with genetic algorithms, significantly innovating the field. Complementing these developments, the research of Sylverin Kemmoe Tchomte and M. Gourgand advanced particle swarm optimization (PSO) to provide robust solutions to complex optimization challenges in satellite scheduling [16]. This innovative trajectory continues with the introduction of the hybrid sampling PSO method by  Wang et al. [29], which significantly improves the efficiency of satellite constellation design and highlights its feasible contribution to practical scheduling strategies. In addition, Liang et al. [30] significantly advances satellite mission scheduling by using differential evolutionary (DE) algorithms to optimize resources as well as improve scheduling efficiency. However, the heuristic algorithm remains unsatisfactory for rapidly changing scheduling demands due to its sensitivity to parameters.

2.2. Resource Integration and Optimization in Satellite Networks

In addition to the challenges of the dynamic nature of remote-sensing satellite networks, the effective utilization, integration, and optimization of resources across a vast satellite coverage area poses unique challenges.

Zhang et al. [18] have assisted in optimizing resources for remote-sensing satellite networks through their pioneering explorations in developing dynamic network virtualization techniques. A dynamic priority queue-based task-time optimal scheduling algorithm proposed by Han et al. [31] heralds a paradigm shift in envisioning how satellite infrastructure can adapt to changing conditions. This demonstrates how modeling innovations can significantly improve satellite scheduling capabilities, especially in complex terrain [32,33]. Their findings are of great significance but also highlight an emerging necessity: the need to construct finer, more detailed, and more accurate models that reflect the changing environment of satellite networks. Together, these studies highlight the decisive role of evolutionary algorithms in simplifying complex scheduling tasks in various technological fields.

Integrating and optimizing resources in satellite networks is crucial for improving the efficiency and performance of space-based communication systems [34]. Shahriar et al. [34] provided a study of mobility management schemes, laying the groundwork for allocating resources in an all-IP satellite network. Boero et al. [35] investigated the latency problem in software-defined networks integrating terrestrial and satellite systems, proposing an architecture that mitigates the impact of satellite link latency on network resource optimization. Wang et al. [10] and Huang et al. [11] proposed dynamic resource allocation strategies, with the former developing a contact plan design algorithm with near-optimal throughput and the latter proposing a snapshot partitioning strategy that balances satellite storage constraints and system performance in GNSS. Vieira et al. [36] presented the exploration of network coding for resource optimization in satellite systems characterized by dynamism, which they believe has potential for next-generation satellite systems. Yu et al. [37] contributed to this discussion by showing how energy-efficient broadcasting can result in significant resource savings in a satellite network, which is crucial for latency-sensitive application considerations. Yuan et al. [38] study on the design of inter-satellite links in LEO/MEO networks provides a comprehensive solution to support different service requirements, further advancing the field of resource optimization in satellite networks. However, while these methodological frameworks provide effective methods for resource optimization, they may struggle to achieve a real-time response and efficient performance management in large-scale networks or under highly dynamic conditions.

In addition, Shahriar et al. [34] presented “Mobility Management Protocols in Next Generation All-IP Satellite Networks”, which provides a comprehensive overview of mobility management schemes; however, the applicability of this research in highly dynamic environments may be limited. In terms of satellite system optimization, Vieira et al. [36] revealed the potential of network coding in dynamic satellite systems, opening up new avenues for improved data transmission. However, the performance of this study in terms of real-time and coding efficiency still needs to be improved. Yu et al. [37] proposed “Minimal Energy Broadcasting for Delay-Sensitive Applications in Satellite Networks”, which reduces the energy consumption in satellite broadcasting. The above studies mainly focus on optimizing resource and energy consumption, but their effects in dynamic environments facing multi-task and multi-band operations need to be further explored. Overall, although each of these studies has made progress in dealing with mobility management, efficiency, network coding, and energy optimization, they still have limitations in terms of adaptability, efficiency, real-time performance, and energy optimization, and further research is needed to improve the breadth and efficiency of their practical applications.

In conclusion, global researchers still face great challenges for a comprehensive and unified solution to address the multifaceted challenges of satellite mission scheduling in dynamic satellite networks, as shown in

Table 1. Challenges and limitations related to remote-sensing satellite mission scheduling.

Author(s) [Ref]	Applications/Algorithms Used	Limitation(s)
Wei and Cao [19], Li et al. [20], Guo and Chen [21], Gong et al. [22], Wang and Tang [1],  Zhou et al. [3], He et al. [4], Salaht et al. [5], Qiu et al. [6], Zhu et al. [7],Fan et al. [8], Chen et al. [28], Velliangiri et al. [15], Tchomté and Gourgand [16], Wang et al. [29], Lu et al. [17], Zhang et al. [18], Yi et al. [23], Yu et al. [24], Jiong et al. [25], Ruan et al. [26], Wenjuan and Peng [27]	Dynamic Task Scheduling and Resource Management Algorithms (SRS&TPP, Resource Competition Management, Mobile Edge Computing); Heuristic and Hybrid Algorithms (GA, DE, PSO); Network Architecture Optimization and Dynamic Packetization (network performance analysis, dynamic packet improvement, routing optimization).	Inadequate dynamic adjustment capability, sensitive to parameters, complex network structure adjustment, may lack sufficient real-time and adaptability
Dai et al. [2], Wang et al. [9]	Resource-intensive algorithms for satellite scheduling; Advanced resource allocation frameworks	High computational resource consumption
Zhang et al. [18], Han et al. [31], Chhabra et al. [32], Xie et al. [33], Liang et al. [30], Shahriar et al. [34], Boero et al. [35], Wang et al. [10], Huang et al. [11], Vieira et al. [36], Yu et al. [37], Yuan et al. [38]	Network virtualization; dynamic priority queue scheduling; network coding; resource allocation strategies	Resource integration, optimization and dynamic resource allocation have limitations in large-scale networks or under highly dynamic conditions.

. Existing research in remote-sensing satellite networks, and mission scheduling mainly faces huge consumption of computational resources, insufficient dynamic adjustment capability, adaptability and real-time challenges. In addition, the optimization of resources as well as energy in dynamic satellite networks is equally limited. Based on the above challenges, this paper proposes dynamic task prioritization for remote-sensing satellite task scheduling based on the BnB method, and this paper’s method has unique advantages in the efficiency of remote-sensing satellite task scheduling, especially the effective use of computational resources and the adaptability to dynamic environments. By introducing the dynamic task prioritization strategy, the method in this paper can more flexibly face the real-time changing task demands, and the real-time adaptability of the system is greatly improved. In addition, based on the BnB method, the efficiency as well as the consumption of computational resources in highly dynamic and uncertain environments are greatly improved, and the adaptability and responsiveness of the system are also significantly enhanced.

3. Mission Scheduling Model on Remote-Sensing Satellites

Remote-sensing satellites are critical for understanding and monitoring the Earth’s surface and atmosphere. The scheduling of missions for these satellites involves a complex interplay of technological precision, strategic planning, and adaptive problem-solving. An effective mission scheduling model is pivotal to maximizing remote-sensing satellites’ utility [39,40]. This requires a harmonious blend of various factors, including but not limited to task prioritization, resource allocation, and the real-time adjustment of mission parameters. This model is the linchpin for ensuring satellites collect data efficiently and effectively, supporting a broad spectrum of Earth observation needs.

3.1. Scene Description

In the context of remote sensing, the scene is set high above the Earth, with satellites equipped with a range of sensors scanning the Earth’s surface. This scenario is not static; it is dynamic and influenced by several factors, such as the Earth’s surface, weather patterns, and human activities. So, in this scenario, remote-sensing satellites must be very careful with their mission scheduling and resource allocation, balancing the need for timely data with the limited available resources. The quality of its output depends on the ability of the mission scheduling model to adapt and respond to the environment.

3.1.1. Remote-Sensing Satellite Mission Scheduling Scenario

Figure 1 depicts remote-sensing satellites as orbital platforms that collect data and process information on the Earth’s surface. Its core function is to use a series of onboard sensors and a control center to observe the ground environment and plan satellite resources continuously. The mission planning and scheduling process is that when a remote user on the ground sends a mission request to the mission control center, the request is received by the mission control center, which then plans the satellite resources according to the user’s needs and the satellite resource status, including the satellite position, load status, storage capacity, computational capacity, and energy constraints, and generates the sequence of mission execution and the target satellite’s execution instructions. The mission control center sends the satellite execution instructions to the measurement and control station. When there is a visible time window between the satellite and the measurement and control station, the measurement and control station sends the mission instructions to the target satellite, and the satellite receives the mission instructions and executes the relevant actions according to the instruction content. After the satellite completes the execution of the task, when there is a visible time window with the relay satellite or ground station, the satellite will downlink the data of the task execution result to the relay satellite or ground base station. The ground station processes the data and sends them to the mission control center. Finally, the mission control center will process and send the information to the user.

3.1.2. Remote-Sensing Satellite Mission Scheduling Optimization Problem

The system under consideration in this paper is a mission scheduling system on a remote-sensing satellite. The system’s main objective is to efficiently plan satellite resources based on scheduling constraints, mission priorities, satellite resource status (satellite orbital position), and potential real-time changes in mission priorities. The system aims to maximize resource utilization and improve the efficiency of the satellite scheduling process.

3.1.3. Components and Interactions

To understand how remote-sensing satellites effectively manage their Earth observation missions, it is essential to delve into the various components and their interactions in the satellite mission scheduling system. Since the mission planning and scheduling process is when a ground remote user sends a mission request to the mission control center, this request is received by the mission control center, and then the satellite resources are planned according to the user’s needs, satellite resource status, including satellite position, load status, storage capacity, computational capacity, and energy constraints, and then the sequence of mission execution is generated along with the execution instructions for the target satellite. The mission control center is intricate and multifaceted, consisting of several key elements that work in concert to optimize mission scheduling and execution. Each component plays a different role, from queuing and prioritizing tasks to allocating resources and executing planned tasks. Let us explore these components in more detail:

• Task Queue: A dynamic list of tasks waiting to be executed. Each task in the queue has attributes such as priority, satellite location, etc.
• Resource Allocator: Responsible for allocating satellite resources to tasks based on their requirements and priorities. It ensures that high-priority tasks are prioritized while considering resource constraints.
• Priority Adjuster: Monitors the task queue and adjusts task priorities in real-time according to task characteristics, urgency, and resource requirements. It ensures timely resolution of tasks with changing requirements.
• Scheduling Algorithm: Determines the execution order of tasks in the task queue. It considers factors such as task time constraints, task priority, resource allocation, and degree of task interrelationships. The algorithm is designed to quickly adapt to changes in the environment and effectively manage task prioritization.
• Executor: Executes tasks according to the order determined by the scheduling algorithm. It ensures that tasks are executed efficiently according to their resource allocation.

3.1.4. Details of the Remote-Sensing Satellite Mission Scheduling Process

The operational flow of the Remote-Sensing Satellite Mission Scheduling System (RSMS) is a carefully organized process that ensures efficient management of missions and resources. This process is the cornerstone of satellite adaptation to the dynamic nature of Earth observation missions. It consists of a series of steps, from initial task queuing to final execution, each of which is critical to the overall efficiency of the satellite. Let us break down this operational process into sequential steps to obtain a clearer picture of how each task is managed and executed: Tasks are added to the task queue with an initial priority and resource requirements. Meanwhile, the priority adjuster monitors the queue and makes real-time adjustments to the task priority based on changing requirements. Subsequently, the resource allocator allocates resources to the tasks based on the adjusted priority and resource requirements. Subsequently, the scheduling algorithm determines the optimal execution order for the tasks, considering their priorities, resource allocations, and interrelationships. Finally, the executor processes the tasks according to the determined order to ensure efficient execution and resource utilization.

3.1.5. Challenges and Considerations

The system model recognizes the challenges highlighted in the problem description:

• Addresses the variability and uncertainty of task prioritization during satellite scheduling and applying its mobility.
• Ensure the reasonable allocation of resources in the competition for satellite resources.
• Design an adaptable scheduling algorithm that optimizes the use of resources and manages task priorities effectively.

To address these challenges, the system model emphasizes the importance of real-time priority adjustment, efficient resource allocation strategies, and robust scheduling algorithms that can adapt to changing environmental conditions and mission requirements.

3.2. Problem Description

Remote-sensing satellite mission scheduling goes beyond the basic organizational tasks into advanced optimization under constraints. The goal is to plan action paths and synchronize these actions with the time course and limited resources. In this intricate satellite mission scheduling, every action and every decision reverberates throughout the system, affecting efficiency, effectiveness, and results.

3.2.1. Model Definition

The task queue scheduling problem on satellites involves determining the optimal order in which tasks are performed on satellites, focusing mainly on task prioritization. The objective is to enhance the stability of the satellite scheduling system by rationally allocating resources, maximizing the task benefits during the scheduling process, and ensuring that the cumulative runtime after all tasks are executed is minimized.

In this research, we develop a complex mathematical model to reveal the complexity of the satellite mission queue scheduling problem with special emphasis on mission prioritization. We treat remote-sensing satellite mission scheduling as a combinatorial optimization problem, formulated through integer programming techniques. This approach allows us to encapsulate a complex decision-making process involving multiple interdependent variables that are indispensable for efficient satellite scheduling. By defining each satellite and its corresponding mission in a rigorous mathematical model, we can apply combinatorial optimization algorithms to find a feasible solution that meets the operational constraints and mission objectives. To achieve this goal, it is necessary to determine an informed resource allocation scheme and release a predetermined queue of tasks to maximize the mission gains throughout the scheduling process while minimizing the cumulative runtime after all the tasks have been executed.

3.2.2. Mathematical Formulation and Variable Definition

We define all satellites as a set in the satellite task queue scheduling process.

$$S=\{s_1,s_2,\dots ,s_n\},n\ge 1,n\in {\mathbb{N}}^{*},$$

(1)

and a particular satellite is denoted as $s_j$, where $j\in \{1,2,\dots ,n\}$. Within the scope of each satellite, missions are organized according to the existing needs so that all missions are grouped into the following sets

$$T=\{t_1,t_2,\dots ,t_m\},m\ge 1,m\in {\mathbb{N}}^{*}$$

(2)

and an individual task within the set is represented as $t_i$, with $i\in \{1,2,\dots ,m\}$. Each task is judiciously assigned a corresponding orbit, denoted as

$$O=\{o_1,o_2,\dots ,o_q\},q\ge 1,q\in {\mathbb{N}}^{*},$$

(3)

with a specific orbit earmarked as $o_k$, where $k\in \{1,2,\dots ,q\}$.

Each task $t_i$ is also associated with a priority value, denoted as $p_i$. The set of all task priority values is represented as:

$$P=\{p_1,p_2,\dots ,p_m\},$$

(4)

where $p_i$ indicates the priority of task $t_i$ and is a positive integer with higher values indicating higher priority. To further refine our model, additional parameters symbolizing the earliest start time, the latest finish time, and the running time for each task $t_i$ are defined as follows:

$$T_i^{\mathrm{init}\_\mathrm{start}}\in \mathbb{R},\forall i\in 1,2,\dots ,m,$$

(5)

$$T_i^{\mathrm{init}\_\mathrm{end}}\in \mathbb{R},\forall i\in 1,2,\dots ,m,$$

(6)

$$D_i\in {\mathbb{R}}^{+},\forall i\in 1,2,\dots ,m.$$

(7)

where $T_i^{\mathrm{init}\_\mathrm{start}}$ denotes the earliest start time of the task $t_i$ and $T_i^{\mathrm{init}\_\mathrm{end}}$ denotes the latest allowed end time of the task $t_i$, which provides a time boundary outside of which the task cannot be completed, and $D_i$ denotes the execution time of the task.

Proposition 1.

In the dynamic priority satellite task scheduling model for remote sensing, given a task set $T=\{t_1,t_2,\dots ,t_m\}$, $m\ge 1$, $m\in {\mathbb{N}}^{*}$. By dynamically adjusting task priorities, i.e., adjusting the priority of each sub-task sequence $T_i$ according to the real-time calculated adjustment factor $\mathsf{\Delta }P(T_i,t)$, the task execution order can be effectively optimized, thereby reducing overall task completion time and enhancing system real-time responsiveness.

Proof. 

First, we define the priority function as

$$P\left(T_i\right)=\frac{C_{\mathrm{sum},i}}{N_i},$$

(8)

where $C_{\mathrm{sum},i}$ is the sum of complexities of all tasks in the subsequence $T_i$, and $N_i$ is the number of tasks in the subsequence.

By introducing the adjustment factor $\mathsf{\Delta }P(T_i,t)$, which adjusts priorities in real-time based on time t and changes in external conditions, the variation in task priority can be expressed as:

$$P^{\prime }(T_i,t)=P\left(T_i\right)+\mathsf{\Delta }P(T_i,t).$$

(9)

Thus, the system rearranges the subsequences according to the real-time updated priority $P^{\prime }(T_i,t)$, prioritizing subsequences with higher priorities. This prioritization allows tasks with better priorities to be scheduled first, maximizing resource utilization efficiency and responsiveness. By prioritizing tasks with higher real-time priorities, the system can significantly reduce the waiting time for tasks and idle time of the system. The result of this dynamic adjustment and reordering is an effective reduction in the total completion time, which can be represented by the formula:

$$C_{\mathrm{optimized}}\left(T\right)=\sum _{i=1}^{k}C(T_{\sigma \left(i\right)},t),$$

(10)

where $\sigma$ is a function that sorts based on the descending order of $P^{\prime }(T_i,t)$. This mechanism ensures that the scheduling system maintains efficient operation while minimizing the total completion time of tasks.    □

3.2.3. Constraints Incorporation

Based on Equations (1)–(4), we established the basic framework of our model, which includes the sets of satellites, tasks, corresponding orbits, and task priorities. Further, Equation (8) defines the priority calculation method for task subsequence $T_i$, introducing the adjustment factor $\mathsf{\Delta }P(T_i,t)$ (see Equation (9)) that demonstrates a mechanism for dynamically adjusting task priorities. This real-time update maximizes resource utilization efficiency and system responsiveness. Additionally, as shown in Equation (10), by sorting the task sequences in descending order of $P^{\prime }(T_i,t)$ using function $\sigma$ and calculating the optimized total completion time $C_{\mathrm{optimized}}\left(T\right)$, this mechanism ensures that the scheduling system operates efficiently while minimizing the overall task completion time, effectively enhancing the system’s scheduling flexibility and real-time response capability.

Time Constraints: To ensure temporal consistency, we add some constraints to ensure that each task is executed within the allowed time window. Specifically, the actual start and end times of the tasks are constrained to predefined ranges, and based on Equations (5)–(7), we know the initial start time, the initial end time, and the run time for each task. The specific constraints are shown below:

$$T_i^{\mathrm{start}}\ge T_i^{\mathrm{init}\_\mathrm{start}}\forall i,$$

(11)

$$T_i^{\mathrm{end}}\le T_i^{\mathrm{init}\_\mathrm{end}}\forall i.$$

(12)

Orbit Allocation: To ensure that each task is reasonably assigned to an orbit, we implement the following constraint:

$$\sum _{k=1}^q{X}_{ik}=1\forall i.$$

(13)

Task Execution: A pivotal constraint ensuring that the entirety of a task is executed within the assigned orbit’s timeframe is expressed as:

$$T_i^{\mathrm{start}}+D_i=T_i^{\mathrm{end}}\forall i.$$

(14)

3.2.4. Objective Function

In keeping with the overall goal of optimal mission scheduling within satellite systems, we seek to maximize mission efficiency while ensuring system stability and minimum mission completion times. Our model aims to maximize satellite mission efficiency and resource utilization by minimizing the total execution time while ensuring optimal resource allocation. This goal is achieved through a linear programming approach that balances mission priorities with available satellite capacity. We define

$$C_{max}=\underset{i\in \{1,2,\dots ,m\}}{max}{T}_i^{end},$$

(15)

$$C_{min}=\underset{i\in \{1,2,\dots ,m\}}{min}{T}_i^{start},$$

(16)

and combined with Equations (15) and (16), the objective function is formulated as:

$$\mathrm{Maximize}{S}_{\mathrm{numerator}}\times (C_{max}-C_{min})-S_{\mathrm{numerator}}\times S_{\mathrm{denominator}},$$

(17)

where

$$S_{\mathrm{numerator}}=\sum _{i=1}^m{p}_i\times D_i,$$

(18)

$$S_{\mathrm{denominator}}=\sum _{i=1}^m(T_i^{\mathrm{end}}-T_i^{\mathrm{start}})\times D_i.$$

(19)

Through Equation (17), we establish an objective function to maximize task efficiency as well as resource utilization to ensure optimal task time management and resource allocation. Where Equations (18) and (19) denote the weighting of the task’s priority and the task’s total execution time over the demand, respectively, in this way, we try to balance the task priority, demand and execution time to achieve efficient operation of the system.

The preceding exposition details a mathematical model tailored for satellite mission queue scheduling, carefully outlining the variables, constraints, and objective functions critical to achieving the overarching goal of optimal mission sequencing within a satellite system. The inherent complexity of this scheduling puzzle suggests that it is consistent with the class of combinatorial optimization problems. Given the intricate interplay between task prioritization, resource allocation, and time constraints, the preliminary analysis demonstrates features synonymous with the NP-hard problem. No known polynomial-time algorithm can guarantee solutions for all possible instances. Future work will require rigorous computational complexity analysis to determine the precise classification of this problem and develop practical algorithms to solve it.

4. Methodology

Considering the growing need for remote-sensing satellite mission scheduling and its critical role in ensuring optimal satellite operations, our study delves into the complexity of onboard mission queue scheduling. These challenges stem from the dynamic nature of mission prioritization and require a versatile and adaptive solution capable of using changing conditions. While static or semi-static traditional mission scheduling methods provide some comfort, an efficient, robust, and adaptable approach is critical. To address the NP-hard nature of the satellite task scheduling problem, we develop a novel scheduling algorithm based on the BnB method. The algorithm aims to efficiently explore the solution space by systematically evaluating the feasibility of potential schedules and pruning suboptimal paths early in the computational process. The dynamic nature of the algorithm allows for the real-time adjustment of task prioritization and resource allocation in rapid response to unforeseen changes in satellite state or task requirements. By combining feedback mechanisms and adaptive strategies, the algorithm ensures that resource allocation is not only based on the initial plan but also reflects the current operational environment, thus optimizing scheduling flexibility and mission readiness. So, this paper utilizes the capabilities of the BnB method to address the complex challenges posed by loading task queue scheduling in a dynamic task prioritization context.

The flowchart in Figure 2 visually represents BnB, illustrating the step-by-step process of solving the task scheduling problem. It demonstrates the decision-making process, especially the branch and bound steps, to ensure clarity of understanding.

4.1. Dynamic Priority Satellite Task Scheduling Model

Given the complex nature of satellite task scheduling, especially with changing priorities, a robust mathematical model is indispensable. Let’s derive this based on our defined notations:

• The total number of tasks is represented by n.
• The priority of each task is given by $p_i$ for $i=1,2,\dots ,n$.
• The start time, end time, and running time for the i-th task are $s_i$, $e_i$, and $t_i$, respectively.
• Our goal is to maximize the weighted sum of tasks based on their priorities and running times, which can be represented as:

  $$S_{\mathrm{numerator}}=\sum _{i=1}^n{p}_i\times t_i.$$

  (20)
• Another aspect to consider is the time difference between the start and end times for each task, which serves as a denominator in our objective function:

  $$S_{\mathrm{denominator}}=\sum _{i=1}^n(e_i-s_i)\times t_i.$$

  (21)
• Combining the above, our objective function is as follows:

  $$\mathrm{Objective}=S_{\mathrm{numerator}}\times (C_{max}-C_{min})-S_{\mathrm{numerator}}\times S_{\mathrm{denominator}},$$

  (22)

  where $C_{max}$ and $C_{min}$ are the maximum and minimum possible values of our objective, respectively.
• The constraints of our model include:

  $$s_i+t_i\le e_i,\forall i\in \{1,2,\cdots ,n\}.$$

  (23)
  This ensures that the task finishes within its allowed time window.
• Each task should be scheduled:

  $$\sum _{i=1}^n{s}_i=1.$$

  (24)
• Overlapping of tasks is not allowed:

  $$s_i+t_i\le s_j\mathrm{or}{s}_j+t_j\le s_i,\forall i\ne j.$$

  (25)

In our model, Equation (22) defines the objective function that aims to maximize the sum of task priority and duration weighting by maximizing the task priority and duration weighting. Equation (23) ensures that each task is completed within its allowed time window. Equation (24) specifies that the sum of the start times of all tasks is 1. This is the initial condition of the model and ensures that all tasks are considered equally and initialized correctly in the scheduling model and that there is no time overlap (see Equation (25)). These formulas form a powerful mathematical model for solving the dynamic priority adjustment problem in satellite mission scheduling.

Axiom 1

(Uniqueness of Task Execution). Every task is executed at most once within its allowed time window.

Explanation: This foundational principle ensures that no task in the system is executed multiple times, ensuring resource efficiency and avoiding redundancy.

Having established the above hypothesis, a natural question arises: How do tasks interact with each other regarding timing and execution? This leads us to a fundamental theorem.

Theorem 1

(Task Overlapping Prohibition). Given two tasks $tas{k}_i$ and $tas{k}_j$, if $tas{k}_i$ starts before $tas{k}_j$ and ends after $tas{k}_j$ starts, then $tas{k}_j$ cannot start until $tas{k}_i$ is complete.

Proof. 

Consider the situation where $tas{k}_i$ is already running when $tas{k}_j$ is set to begin. From our model constraints, we have as follows:

$$s_i+t_i\le e_i,$$

(26)

$$s_j+t_j\le e_j.$$

(27)

From Equation (26), $tas{k}_i$ will end at time $e_i$. For $tas{k}_j$ to start before $tas{k}_i$ ends would mean $s_j<e_i$. However, combining this with Equation (27) leads to a contradiction since $s_j+t_j>e_i+t_j$, which violates the non-overlapping constraint. So, $tas{k}_j$ cannot start until $tas{k}_i$ has been completed.    □

This theorem is deeply rooted in our mathematical model and provides clear insights into task execution patterns. It ensures that tasks do not overlap and that each task obtains the resources it needs without competing for them.

We are now poised to address the central challenge of this research: devising a solution strategy for the onboard task queue scheduling problem, particularly in the context of dynamically changing task priorities. The problem can be concisely defined as follows:

Given a set of tasks (each with a dynamic priority, start time, end time, and execution duration), determine an optimal scheduling sequence that maximizes the system’s utility while adhering to the constraints derived from the previous mathematical model and hypotheses.

Mathematically, we aim to solve:

$$\mathrm{Maximize}{S}_{\mathrm{numerator}}\times (C_{max}-C_{min})-S_{\mathrm{numerator}}\times S_{\mathrm{denominator}}.$$

(28)

Constraints as defined by Axiom 1 and Theorem 1.

This problem encapsulates the essence of the satellite scheduling challenge under dynamic priorities. In the subsequent sections, we will delve into potential solution strategies, algorithmic frameworks, and a holistic solution approach to address this challenge.

One of the most prominent strategies for solving combinatorial optimization problems, as we define them, is BnB. Rooted in integer programming and discrete optimization principles [41,42], this method provides a structured way to explore the solution space while dis-carding suboptimal solutions, ensuring computational efficiency and accuracy.

Essence of the Branch and Bound method:

The core concept of the BnB approach lies in two primary operations:

• Branching: This involves decomposing the problem into smaller subproblems or branches. For our task scheduling problem, this translates into exploring different permutations of the task sequence.
• Bounding: By evaluating the potential solution quality of branches, we can discard (or “bound”) certain branches if they do not lead to a better solution than the best solution found so far.

Before exploring the mathematical complexity, it is crucial to understand the basic concepts that govern BnB methods. Our goal is to fully and efficiently explore the solution space, which often requires us to make informed decisions to select branches that should be explored further and discard those that are unlikely to provide advantages. This decision-making process depends on the specific properties and characteristics of the problem. Combinatorial optimization problems often involve the concept of suboptimality, which is a characteristic of our task scheduling problem.

Theorem 2.

Suboptimality Principle A branch cannot produce a solution that is better than the current best solution, then neither can any of its descendants in the solution tree.

Proof. 

Suppose we have a branch B which has an upper bound greater than or equal to the value of the best known solution. Let S be any solution that belongs to the sub-tree rooted at B. By the definition of an upper bound, the value of S is no better than the upper bound of B. Therefore, S is also no better than the best-known solution. This holds true for any solution in the sub-tree rooted at B, which proves our claim.    □

During the branch and bound process, we will compute an upper bound (usually a relaxed version of the problem) and a lower bound (based on the current best solution) at each node or branch point. If the upper bound of a branch is not as optimal as the current best solution, the branch can be pruned.

The pruning strategy is a vital component of BnB, as shown in Figure 3. Pruning helps to efficiently navigate the solution space by eliminating suboptimal branches. The described strategy ensures that our method remains computationally efficient by focusing only on promising branches.

Algorithm 1 provides a structured representation of this method. The pseudo-code encapsulates the mathematical essence of the BnB method. At each step, we evaluate the potential of a node (or task scheduling sequence) using the objective function derived from Equation (28). If the potential is promising, we explore it further by branching. Otherwise, we prune the branches. This complex balance between exploration (branching) and exploitation (bounding) ensures that the algorithm efficiently navigates the solution space and follows the optimal task scheduling sequence. Therefore, we propose Algorithm 1 to derive an optimal task scheduling sequence. Initially, best_solution is initialized to infinity, setting a reference point that represents the upper bound of the algorithm’s effort to minimize (line 1, as highlighted by Equation (28)). The starting point of the BnB method is determined by creating an initial_node, which represents our initial task scheduling node (line 2). If the algorithm encounters a leaf node, it evaluates the priority of the current solution based on the best solution found so far. If more desirable, the best_solution is updated accordingly (lines 3–5). For nodes with branching potential, a new sequence of possible tasks is expanded from the current node (line 7). Subsequently, by pruning the application boundaries, the algorithm discards nodes considered not beneficial to the solution space (line 8). Each surviving node undergoes a recursive application of the BnB method after pruning, allowing the algorithm to delve deeper into the potential solution terrain (lines 9–11). This mechanism ensures that the algorithm efficiently and thoroughly searches the environment for the optimal task scheduling order.

Algorithm 1: Branch and Bound Algorithm for Problem Solving

In the context of satellite mission scheduling planning, the schematic shown in Figure 4 illustrates a typical scheduling scenario. This helps to grasp the complexity inherent in onboard mission queue scheduling. Figure 4 is an illustrative guide for integrating remote-sensing satellite mission scheduling with BnB methods, visually representing the complex processes involved. The figure serves as a critical roadmap for navigating the complexity of satellite mission scheduling, where each step implies an interplay between system mission planning and the adaptive resolution of subproblems. It depicts how the entire scheduling task (which may be partitioned into smaller, more manageable sequences) is optimized by a Branch and Bound algorithm that methodically explores the decision tree, prunes suboptimal paths, and focuses on promising solutions. It conveys the meticulous choreography of satellite operations, where each task is closely linked to the overall mission objectives, ensuring that the satellite makes the best use of its valuable elapsed time as it collects and transmits critical Earth observation data. Figure 4 shows the remote-sensing satellite mission scheduling process in detail.

4.2. Constructing an Algorithmic Framework

Given the system model developed in the previous sections and the understanding of the optimal solution algorithm, we now present a comprehensive algorithmic framework to optimize the task scheduling problem. The framework is designed based on the mathematical relationships and constraints previously outlined in Equation (20) through Equation (25) and is intended to refine the solution space further and provide enhanced performance.

Iterative Refinement through Sub-problems:

Often, a promising approach in combinatorial optimization schemes is to decompose the overall problem into smaller, more manageable subproblems. By solving these subproblems and combining their solutions, we can iteratively refine our answer to the main issue. In our task scheduling context, this involves breaking down the entire task sequence into more minor sequences, optimizing them individually, and then combining them.

Mathematical Expression for Sub-problem Decomposition:

Let us denote the entire task sequence by T. We can break it down into k smaller sequences $T_1,T_2,\dots ,T_k$ such that:

$$T=T_1\cup T_2\cup \dots \cup T_k,$$

(29)

where $T_i$ represents the $i^{th}$ sub-sequence. The optimization objective for each $T_i$ is to minimize the completion time, which can be represented as:

$$\mathrm{Minimize}C\left(T_i\right),$$

(30)

where $C\left(T_i\right)$ denotes the completion time of sequence $T_i$ as defined in Equation (21).

Merging Sub-problem Solutions:

Once we have optimized solutions for each sub-sequence $T_i$, the next step is to merge them in a manner that results in an optimized solution for the entire sequence T.

$$C\left(T\right)=C\left(T_1\right)+C\left(T_2\right)+\dots +C\left(T_k\right).$$

(31)

The challenge lies in ordering these sub-sequences to achieve global optimization.

To address the problem of efficient task scheduling, we propose Algorithm 2, which aims to generate an optimized sequence of tasks. The task sequence T is initially decomposed into multiple sub-sequences $T_1,T_2,\dots ,T_k$, as outlined in Equation (29) (line 1). For each of these identified sub-sequences $T_i$, the algorithm embarks on its optimization (lines 2–4). This refinement is achieved through the OptimizeSubSequence function, leveraging BnB, in alignment with the relation presented in Equation (30), ensuring each sub-sequence $T_i$ is meticulously optimized (lines 8-9). Post optimization of all sub-sequences, the algorithm amalgamates these to form the comprehensive optimized task sequence $T_{\mathrm{opt}}$, as described in Equation (31) (line 5). In summation, Algorithm 2 delivers an optimized sequence, $T_{\mathrm{opt}}$, that undergoes segment-based refinement followed by a cohesive merger, ensuring all-encompassing efficiency.

Algorithm 2: Optimize Task Scheduling Algorithm

These individual sub-sequences are optimized using BnB, a well-known combinatorial optimization technique. The method systematically enumerates candidate solutions through a state-space search: the set of candidate solutions forms a rooted tree, where the complete set is located at the root. The algorithm explores the branches of this tree, which represent subsets of the solution set. Before enumerating the candidate solutions of a branch, the branch is checked against the estimated upper and lower bounds of the optimal solution. If it does not produce a better solution than the algorithm’s best solution, it is discarded.

Once each subsequence has been optimized, the merging phase begins. This phase is paramount as how the sub-sequences are combined will determine the efficiency of the resultant task sequence $T_{\mathrm{opt}}$. The algorithm relies on the additivity of the sub-sequence completion times, as shown in Equation (31). However, a salient point to consider is the ordering of these sub-sequences, which can significantly impact the global optimization of T. The ordering should be carefully planned to ensure that the generated merged sequence achieves the overall goal of the shortest completion time.

4.3. Advancing to a Comprehensive Solution

We now propose a comprehensive solution to the task scheduling problem. The solution will use the previously discussed iterative optimization techniques but with additional optimizations to improve performance and ensure accuracy.

Incorporating Priority into Sub-problem Decomposition:

Given our objective to minimize the overall completion time, prioritizing tasks based on specific criteria, such as their complexities or dependencies, is crucial. Let us introduce a priority function $P\left(T_i\right)$ for each sub-sequence $T_i$:

$$P\left(T_i\right)=\frac{C_{\mathrm{sum},i}}{N_i}.$$

(32)

where $C_{\mathrm{sum},i}$ is the sum of the complexity of all tasks in the sub-sequence $T_i$ and $N_i$ is the number of tasks contained in the sub-sequence $T_i$. Higher values of $P\left(T_i\right)$ indicate that the sub-sequence $T_i$ has tasks with higher average complexity and should be scheduled earlier.

Optimized Merging of Sub-problem Solutions:

The main insight of this section is that when merging sub-sequences, we should consider their priority values. This ensures that sub-sequences with tasks of higher average complexity are scheduled first, thus potentially reducing the overall completion time.

To holistically tackle the challenge of task scheduling, we introduce Algorithm 3, designed meticulously to deliver a fully optimized task sequence, $T_{\mathrm{opt}}$. In the initial phase, the algorithm leverages the DecomposeSubSequences function to split the task sequence T into multiple sub-sequences, precisely $T_1,T_2,\dots ,T_k$, as dictated by Equation (29) (see line 8). Upon decomposition, the algorithm then dives into a two-fold operation for each of these sub-sequences. It first invokes the CalculateP function to compute $P\left(T_i\right)$ following the scheme presented in Equation (32) (line 9). Post calculation, the OptimizeSubSequence function steps in, utilizing the renowned BnB to refine each $T_i$ (lines 10). With all sub-sequences thoroughly optimized, the next strategic move is to organize these in a particular sequence. The SortSubSequences function is tasked with this responsibility, ensuring that the sub-sequences are arrayed based on descending values of their computed $P\left(T_i\right)$ (line 11). Concluding the procedure, these sorted sub-sequences are merged seamlessly by the MergeSortedSubSequences function to sculpt the fully optimized task sequence $T_{\mathrm{opt}}$, as elaborated in Equation (33) (line 12). In essence, Algorithm 3 offers a comprehensive solution, emphasizing both the granular refinement of sub-sequences and their strategic aggregation, all converging to produce an unparalleled task scheduling outcome.

$$C_{\mathrm{optimized}}\left(T\right)=\sum _{i=1}^{k}C\left(T_{\sigma \left(i\right)}\right),$$

(33)

where $\sigma$ is a permutation function that orders the sub-sequences based on decreasing values of $P\left(T_i\right)$.

Algorithm 3: Total Task Scheduling Solution

As described in Algorithm 3, Total Task Scheduling Solution takes a deeper look at the task scheduling problem by incorporating an intelligent prioritization mechanism. It combines the advantages of iterative refinement with prioritization decomposition to provide a robust and efficient scheduling solution.

By integrating prioritization into the iterative optimization approach, the method presented in Algorithm 3 provides a nuanced and holistic solution for task scheduling. The strategy balances granularity and global optimization, positioning it as a reliable solution for complex scheduling schemes.

4.4. Comparative Analysis: Performance and Complexity

Analyzing the three algorithms, BnB exhibits a worst-case time complexity of $O\left(n^p\right)$, influenced by task count and processors. The algorithmic framework improves this by introducing sub-ordering, but its efficiency may be affected by the distribution of tasks. The solution enhances this approach by prioritizing tasks and may outperform other methods, especially for larger tasks. However, actual performance may vary, emphasizing the importance of benchmarking in real-world scenarios.

5. Comparative Experimental Analysis

As mentioned above, the specific mathematical model for solving the satellite mission scheduling problem and various theoretical advantages of BnB have been given in detail; however, we need detailed simulation data to determine BnB and other algorithms separately to obtain reliable and convincing output data and to make comparisons. We use our simulation platform and the Python language driver to instantiate BnB, then we can further illustrate the superiority of BnB if it demonstrates significant advantages both in terms of execution time and the maximum value of the output objective function. In this paper, we propose to use the branch bounding method to solve the satellite mission scheduling problem and compare it with three heuristic algorithms, namely, Genetic Algorithm, Particle Swarm Algorithm, and Differential Evolutionary Algorithm. The experimental results show that the BnB algorithm exhibits significant advantages in terms of runtime and output quality. The BnB method usually performs better in terms of the maximum value of the objective function, always finds a better solution, and reduces about 80% in terms of the running time.

5.1. Simulation Experiments and Dateset Details

In this paper, we compare and analyze the performance and advantages of the branch delimitation method by comparing several simulation experiments with three heuristic algorithms (GA [15], PSO [16], DE [30]). To address the pivotal challenges associated with resource scheduling and cooperative computing within space-based information networks, we conceived and developed the Common Computing Environment Simulation Toolkit (CSTK). This innovative toolkit, designed specifically for spatial information networks, is built upon authentic datasets derived from existing space-based information networks. Within this framework, we simulate datasets of satellite-related information. This dataset encompasses satellite payload data, orbital trajectories, inter-satellite communication windows, as well as the capacity and availability of satellite resources. The main simulation interface is shown in Figure 5. The experimental simulation data mainly include synthetic data based on actual satellite-related data and simulation data generated based on satellite and mission characteristics.

The scene start time is “10 January 2024 05: 00:00.000UTCG”, and the end time is “11 January 2024 05:00:00.000 UTCG”. The end time is “11 January 2024 05:00:00.000 UTCG”. To complete the simulation of remote-sensing satellite mission scheduling, we also simulate the simulation data of Earth observation application scenarios, including mission execution time, mission re-source types, mission resource requirements, etc. Our simulation platform creates a multi-satellite, multi-mission Earth observation scenario. The 2D and 3D views of the satellites and the Earth in the simulated Earth observation scenario are shown in Figure 6.

The experimental results show that the branch delimitation algorithm has the advantages of high efficiency and high task benefit in completing the remote-sensing satellite scheduling task, and it always finds the optimal solution and saves 80% of the running time. As shown in

Table 2. Runtime Environment Configuration Introduction.

Configuration Items	Computer Configuration Message
Operating System	Windows 11 Family Chinese Version
CPU	Intel(R) Core(TM) i5-1035G1 CPU @ 1.00 GHz
Hard Disk	512 GB
Memory	8 GB
Video Cards	NVIDIA GeForce MX350

, the following table describes the operating environment of the experiment.

5.2. Numerical Comparative Analysis

To verify the superiority of this paper’s method in remote-sensing satellite mission scheduling, we use a rigorous experimental dataset in the simulation platform, which includes the complexity of the remote-sensing satellite mission scheduling problem, as shown in

Table 3. Comprehensive Field and Value Range Directory of the Dataset.

Data Set Field Value Ranges
Task_Number	Start_Time	End_Time	Running_Time	Priority	Orbit	Orbit_Length
1~500	1~100	1~120	1~20	1~10	1~50	10~20

. The fields in Table 3 are summarized below, Task_Number serves as a unique identifier for each satellite task. Start_Time and End_Time are timestamps that denote the commencement and completion of the tasks, respectively. Running_Time signifies the total duration of the task. Priority field indicates the priority of the task, and its urgency to be executed. Finally, Orbit field specifies the operational path of the satellite task, with Orbit_Length providing more details of the orbital period, which is essential for understanding the spatial and temporal requirements of the mission.

To ensure the experimental results’ reliability, we tested this paper’s algorithms and the corresponding procedures of the three comparison heuristics (GA [15], PSO [16], DE [30]) on separate datasets as shown in

Table 4. Number of tasks for the four datasets with sequentially increasing number of tasks.

M1	M2	M3	M4
50	100	200	500

. We divided the dataset into four categories based on the number of tasks, which are 50, 100, 200 and 500, respectively. Each program will be run ten times sequentially based on the four datasets to ensure that reliable and evenly distributed program runtime data are obtained.

The paper comprehensively examines the performance of this paper’s method BnB method with three heuristic algorithms (GA [15], PSO [16], DE [30]) in dynamic task priority-based task scheduling for remote-sensing satellites by testing the four datasets in Table 4 and in-depth analyses of simulated experimental data. Our simulation experiments are mainly designed to evaluate the efficiency and output quality of the BnB algorithm and the (GA [15], PSO [16], DE [30]) algorithms in dealing with the remote-sensing satellite task scheduling problem. Our analysis is based on synthetic data and simulated data to simulate the complex scenarios of real satellite task scheduling and assess the algorithms’ potential effectiveness in practical applications. We finally summarized the output data in

Table 5. Based on four datasets, four algorithms, a total of 16 sets of tests with ten tests in each set, the final specific runtime data (in seconds), and the growth rate of runtime length of GA [15], PSO [16], and DE [30] algorithms to the BnB algorithm are obtained.

Algorithms	M1				M2				M3				M4
	BnB	GA [15]	PSO [16]	DE [30]	BnB	GA [15]	PSO [16]	DE [30]	BnB	GA [15]	PSO [16]	DE [30]	BnB	GA [15]	PSO [16]	DE [30]
test01	0.0940	0.3006	0.8841	0.4652	0.0737	0.5512	1.7420	1.5779	0.1952	1.0052	3.5887	5.8476	0.8228	2.4348	9.4291	37.2457
test02	0.0894	0.3034	0.8793	0.4514	0.0839	0.5119	1.7436	1.7918	0.2171	0.9435	3.5529	5.7551	0.8476	2.4049	9.3927	37.3014
test03	0.0873	0.2920	0.8615	0.4525	0.0731	0.5085	1.7586	1.6975	0.2075	0.9517	3.4389	5.8758	0.8605	2.4183	9.4811	37.2759
test04	0.0874	0.2989	0.8784	0.4451	0.0799	0.5032	1.7860	1.7468	0.2209	0.9555	3.9116	5.8791	0.8621	2.4548	9.4173	37.4516
test05	0.0921	0.3101	0.8608	0.4478	0.1000	0.5361	1.7411	1.7178	0.2235	0.9847	4.7579	5.7603	0.8740	2.4696	9.5877	37.3045
test06	0.0857	0.3059	0.8943	0.4476	0.0784	0.5109	1.7270	1.7812	0.1985	0.9498	3.8535	5.7991	0.8674	2.4359	9.4239	37.3760
test07	0.1080	0.3052	0.8841	0.4541	0.0777	0.5096	1.7571	1.6120	0.2345	0.9788	3.5310	5.8745	0.8248	2.4339	9.5728	37.3866
test08	0.1001	0.2975	0.8709	0.4629	0.0802	0.5360	1.7433	1.5862	0.2112	0.9652	3.6118	5.8199	0.8287	2.5141	9.4699	37.5179
test09	0.0852	0.3023	0.9055	0.4737	0.0761	0.5112	1.7437	1.5781	0.2037	0.9598	3.5603	5.9578	0.8478	2.4504	9.4383	37.1881
test10	0.0891	0.3065	0.8728	0.4839	0.0743	0.5115	1.7638	1.5962	0.2526	0.9624	3.5274	5.8571	0.8375	2.4125	9.4030	37.2971
Average Runtime	0.0918	0.3022	0.8792	0.4584	0.0797	0.5190	1.7506	1.6686	0.2165	0.9657	3.7334	5.8426	0.8473	2.4429	9.4616	37.3345
Increasing Ratio	/	2.291	8.573	3.992	/	6.479	22.636	20.410	/	4.1494	17.383	28.955	/	1.9593	10.460	44.2693

and

Table 6. Based on four datasets, four algorithms, and a total of 16 sets of tests, data on the specific output values of each set of tests and the growth rate of the output values of the GA [15], PSO [16], and DE [30] algorithms to the BnB algorithm are finally obtained.

Output	BnB	GA [15]	PSO [16]	DE [30]
M1	−15,194,245	−15,144,305	−15,144,305	−15,144,305
M2	−10,887,093	−10,831,442	−10,831,442	−10,831,442
M3	−223,110,544	−22,2929,624	−222,929,624	−222,929,624
M4	−1,489,745,232	−1,489,276,272	−1,489,276,272	−1,489,276,272
Increasing Ratio	BnB	GA [15]	PSO [16]	DE [30]
M1	/	−0.00328677	−0.00328677	−0.00328677
M2	/	−0.00511165	−0.00511165	−0.00511165
M3	/	−0.0008109	−0.0008109	−0.0008109
M4	/	−0.00031479	−0.00031479	−0.00031479

, including the running time of each run of each program, the data results, and the comparison data of the three heuristic algorithms (GA [15], PSO [16], DE [30]) compared to the BnB algorithm in two metrics, and we plotted four graphs to show the experimental results more intuitively. Based on the test data in Table 5, two box-and-line plots are drawn in Figure 7 and Figure 8, which show the average running time and the growth rate of running time in Figure 8. In addition, two bar charts, Figure 9 and Figure 10, are plotted based on the two sub-tables in Table 6 to visualize the experimental results. In the comparative analysis, we define the performance metric of the BnB algorithm as A. The performance metrics of the other three algorithms (GA [15], PSO [16], DE [30]) are B, C, and D. Taking Metric A of the core algorithm, BnB, as the benchmark, we compute the growth or reduction rate of the performance of the other algorithms with respect to the performance of the BnB algorithm, i.e., by the formulae (B-A)/A, (C-A)/A, and (D-A)/A to measure it. This comparison allows us to clearly identify the performance differences between the algorithms in terms of running time and the maximum value of the output objective function.

5.3. Runtime Comparison

In the comparative analysis of dynamic priority-based remote-sensing satellite mission scheduling runtime, the dynamic mission priority-based remote-sensing satellite application scheduling method (BnB) significantly outperforms the three heuristics (GA [15], PSO [16], DE [30]). As shown in Figure 7, its average runtime is significantly lower than the other three algorithms, especially on the larger dataset (M4, 500 number of tasks), where the runtime of the BnB method averages 0.8473 s. In comparison, the average running times of GA [15], PSO [16] and DE [30] are 2.4429, 9.4616 and 37.3345 s, respectively. This reinforces the fact that the BnB method has a significant time-efficiency advantage in dealing with large-scale remote-sensing satellite task scheduling problems. As shown in Figure 7, it can be seen that the BnB algorithm shows more stability and scalability than the three baseline algorithms as the size of the dataset continues to grow. This trend indicates that the BnB algorithm is designed to be more suitable for large-scale data processing. We can also confirm the advantage of the BnB algorithm in terms of runtime by further analyzing the runtime growth rate. As shown in Figure 8, the results show that the growth rate of the BnB algorithm is much lower than that of the three heuristic algorithms, which reflects the stability of the BnB algorithm in large-scale task scheduling, and highlights its significant time efficiency in handling high-load tasks in remote-sensing satellite applications, which further confirms the usefulness of the BnB approach in remote sensing This further confirms the practicality and superiority of the BnB approach in remote-sensing satellite task scheduling.

The BnB algorithm effectively avoids repeated computations and saves a large amount of computational resources through the branch-limiting strategy in its design, reduces the search space and improves the operational efficiency through reasonable pruning. In the future, the data structure of the BnB algorithm will be further improved to accelerate data processing and increase computational capability by utilizing modern computing technologies, such as parallel computing and efficient data structures, to enhance the algorithm’s running time and resource management efficiency. It is also possible to provide support for future applications of the BnB algorithm in dynamic real-time task scheduling as well as in high computational environments by formulating rules for optimizing the execution of the BnB algorithm, e.g., by prioritizing tasks with high resource demands and considering pruning strategies in real-time.

5.4. Comparison of Output Results

In the comparative analysis of the results, we focus on the quality of the solutions produced by the algorithms, which is usually measured by the degree of optimization and resource utilization in the scheduling of remote-sensing satellite missions. The Priority-based Dynamic Task Scheduling (BnB) method for satellite remote sensing applications proves its advantages over three heuristic algorithms (GA [15], PSO [16], DE [30]) in terms of advantage in terms of quality. As can be seen from the data in the result analysis Figure 9 and Figure 10, the BnB algorithm produces better scheduling results in most of the cases, demonstrating its effectiveness in optimizing the order of task execution and resource allocation. This suggests that the BnB algorithm is able to better utilize resources and ensure that task priorities as well as execution efficiency are taken into account when solving high-complexity remote-sensing satellite task scheduling.

More specifically, the BnB algorithm is able to produce more productive outputs on all test sets, demonstrating a high optimization capability, which is particularly important when dealing with the high complexity remote-sensing satellite task scheduling problem. This demonstrates its practical application value for ensuring the efficiency and operational effectiveness of remote-sensing satellite systems. These comparative results not only show the obvious advantages of the BnB algorithm in terms of result quality but also highlight the potential and importance of the algorithm in future remote-sensing satellite mission planning applications. In the future, more advanced pruning strategies can be developed, and the introduction of an adaptive scheduling mechanism can be considered to adjust the scheduling strategy according to the urgency of the mission and the efficiency of resource utilization to further improve the scheduling results of the BnB algorithm.

5.5. Combining the above Comparative Analyses

Through our simulation experiments, we compare the performance of the BnB method with three heuristic algorithms (GA [15], PSO [16], DE [30]) on different datasets. The results show that the BnB method outperforms the other algorithms in terms of execution time and output quality. In particular, regarding execution time, the BnB method significantly reduces the latency during task scheduling, which is a key factor when dealing with thousands of tasks with different start and end times, duration constraints, and priorities. The BnB method also reduces the latency when assigning tasks to different trajectories. It reduces the risk of delaying task start times, extending task durations, or breaking completion time constraints.

The comprehensive comparative analysis combined with experimental results clearly proves the validation of our proposition about real-time adjustment of task priority, and the dynamic remote-sensing satellite scheduling method based on dynamic task priority (BnB) proposed in this paper has significant advantages in solving the remote-sensing satellite task scheduling problem. The proposition is supported practically, and the real-time adjustment of dynamic priority improves operational efficiency. Future research could explore how to incorporate modern computing techniques, such as parallel computing and efficient data structures, to further improve the responsiveness and adaptability of scheduling algorithms, and how to utilize advanced optimization theories to deal with a wider range of task types and more complex resource constraints.

6. Conclusions

Dynamic task prioritization is one of the main challenges in remote-sensing satellite mission scheduling. In this paper, a dynamic remote-sensing satellite task scheduling model is designed to achieve a solution to the static and non-adaptive limitations of the traditional satellite scheduling model. Based on this model, a remote-sensing satellite task scheduling method based on dynamic task prioritization is proposed to solve the remote-sensing satellite task scheduling problem using BnB and compared with three baseline algorithms. Simulation experiments show that the execution time of this paper’s method is significantly shortened by 80% compared with the three baseline algorithms, which is a significant advantage in improving the scheduling efficiency and optimizing the utilization of satellite resources. The principle of the BnB method is based on the principles of integer programming and discrete optimization, which is very suitable for task scheduling. The application of this paper’s method in remote-sensing satellite mission scheduling has multiple significance, which not only has significant advantages in mission scheduling and resource allocation optimization, but can effectively reduce time delay, allocation delay, and the risk of mission overtime, etc., but also can adapt to dynamic and complex environments to improve the accuracy and reliability of scheduling. However, the approach in this paper faces challenges in efficiency and computational resources when dealing with extremely complex and data-heavy problems. In addition, the real-time performance and generalizability need to be further improved. Future research can incorporate deep learning and meta-heuristic algorithms to improve the performance of the algorithm in large-scale as well as real-time applications. We suggest the use of BnB in real remote-sensing satellite scheduling applications, which provide a valuable reference for future research in this area.