Dynamic Satellite-to-Controller Assignment (DSCA)

• Dynamic Satellite-to-Controller Assignment (DSCA) is a framework that dynamically maps satellites to ground controllers to minimize propagation delays in rapidly changing LEO networks.
• It leverages optimization models, predictive handover algorithms, and adaptive controller placement to balance delay reduction with reconfiguration costs and resource efficiency.
• Practical implementations like CNAA and PPGA have demonstrated significant improvements in control-plane stability and reduced latency compared to static assignment methods.

Searching arXiv for papers on dynamic satellite-to-controller assignment and closely related LEO controller-assignment formulations. Dynamic Satellite-to-Controller Assignment (DSCA) denotes the class of methods that repeatedly determine which controller should manage each satellite in a time-varying satellite network, typically under Low Earth Orbit (LEO) mobility, changing visibility, and delay-sensitive control-plane requirements. In the cited literature, DSCA appears both as an explicit optimization problem for SDN-enabled LEO constellations and as a broader design pattern spanning controller placement, controller activation, handover suppression, and predictive reassignment. Across these formulations, the central problem is consistent: static satellite-to-controller mappings become suboptimal as orbital geometry evolves, whereas purely reactive nearest-controller reassignment can induce excessive churn. Recent work therefore treats DSCA as a dynamic, state-dependent assignment problem that must balance propagation delay, control-plane stability, resource usage, and reconfiguration cost (Hasanain et al., 22 Jul 2025, Zhao et al., 29 Jan 2026).

1. Conceptual scope and motivation

DSCA is motivated by the fact that LEO satellite constellations are highly dynamic because satellites move rapidly relative to the Earth and to one another. This causes frequent topology changes, changing visibility between satellites and ground controllers, varying propagation delays over time, and the need to reconfigure control assignments continuously (Hasanain et al., 22 Jul 2025). Under these conditions, a static controller assignment is inefficient because an assignment that is good at one moment can quickly become poor as satellites move. The reported consequences include larger propagation delays, suboptimal routes, and wasted controller resources (Hasanain et al., 22 Jul 2025).

The literature distinguishes several operational interpretations of the “controller.” In SDN-based LEO networks, controllers are fixed Earth locations managing satellite switches through an SDN control plane (Hasanain et al., 22 Jul 2025). In KubeSpace, the control nodes are ground stations, each running a full Kubernetes control plane and managing an isolated cluster of satellites (Zhao et al., 29 Jan 2026). In relay-centric distributed satellite systems, the relay satellite acts as the controller or coordination node for neighboring satellites within a single-level star topology (Veeravalli, 3 Jan 2026). In resilient SDA architectures, the role is approximated by on-orbit actuator nodes whose regions of responsibility and coordination relationships are determined geometrically and graph-theoretically (Benchoubane et al., 13 May 2025).

A recurring contrast in the literature is between static assignment and dynamic reassignment. Static satellite-to-controller assignment (SSCA) pre-assigns satellites to controllers and does not adapt to motion (Hasanain et al., 22 Jul 2025). Dynamic approaches instead update mappings over time to reduce propagation delay, improve resource utilization, or maintain low-latency control. This suggests that DSCA is less a single algorithm than a family of time-evolving controller-selection mechanisms defined by orbit-driven network dynamics.

2. System models and mathematical formulations

In the SDN-enabled LEO formulation, the data plane consists of LEO satellites acting as SDN switches, connected via Intra-Orbit ISLs and Inter-Orbit ISLs, while the control plane consists of SDN controllers placed at fixed Earth locations (Hasanain et al., 22 Jul 2025). The set of controllers is denoted $c_j \in C$, with total number $m$, and the set of satellites is $s_i \in S$, with total number $n$. Assignment at time slot $l$ is represented by the binary variable $x^{[l]}_{i,j}$, and controller activation by the binary variable $y^{[l]}_j$ (Hasanain et al., 22 Jul 2025).

The DSCA problem in that work is formulated as a mixed integer linear programming (MILP) model whose goal is to minimize the average propagation delay only, subject to assignment and activation constraints. Propagation delay between satellite $s_i$ and controller $c_j$ at time slot $l$ is denoted $m$0, where shortest paths to visible ground stations are computed using Dijkstra’s algorithm and propagation delays are determined through OMNeT++ simulations (Hasanain et al., 22 Jul 2025). Delay normalization is defined as

$m$1

and the weighted average propagation delay objective is

$m$2

The constraints require that each satellite is assigned to exactly one controller, no assignment occurs if delay exceeds a threshold, the number of active controllers is fixed to $m$3, and a satellite can only be assigned to an active controller (Hasanain et al., 22 Jul 2025).

Opt-DSCA extends DSCA by jointly optimizing average propagation delay and the number of active controllers. In that formulation, the fixed-controller-count constraint is removed, and a second objective term is introduced: $m$4 The full optimization balances lower propagation delay against fewer active controllers through the weight $m$5 (Hasanain et al., 22 Jul 2025).

A broader DSCA-like formulation appears in dynamic controller placement and switch assignment (CPSA) for SDN-based LEO networks. There, time is slotted as $m$6, with $m$7 indicating whether satellite $m$8 is a controller and $m$9 indicating whether switch $s_i \in S$0 is assigned to controller $s_i \in S$1 (Jiang et al., 18 Apr 2025). The objective is an integer nonlinear programming problem that minimizes a weighted sum of load imbalance $s_i \in S$2, average controller response delay $s_i \in S$3, and reconfiguration overhead $s_i \in S$4: $s_i \in S$5 Here, $s_i \in S$6, decomposed into controller migration cost, switch reassignment cost, and controller synchronization cost (Jiang et al., 18 Apr 2025). This formulation broadens DSCA beyond latency-only optimization by explicitly pricing transition overhead between adjacent time slots.

3. Predictive assignment and handover-aware control

KubeSpace presents a particularly explicit and operationally detailed DSCA mechanism. Its dynamic assignment mechanism is the Control Node Assignment Algorithm (CNAA), designed for LEO satellite container orchestration (Zhao et al., 29 Jan 2026). The paper separates the overall problem into two parts: placing a small number of ground control nodes well, and dynamically assigning each satellite to the most appropriate controller over time while avoiding churn from tiny distance fluctuations (Zhao et al., 29 Jan 2026).

CNAA runs on the satellite and predicts future controller changes from orbital motion using TLE data. Its inputs are TLE orbital data, the current and future satellite position $s_i \in S$7, the set of ground control nodes $s_i \in S$8, a future time window $s_i \in S$9, a sampling interval $n$0, a decision interval $n$1, and a handover threshold ratio $n$2 (Zhao et al., 29 Jan 2026). The algorithm first performs coarse orbit prediction and distance sampling: for each sampled time $n$3, it predicts $n$4 and computes

$n$5

for every ground node $n$6. It then constructs interpolation functions $n$7 from the sampled points so that controller distance can be evaluated at fine time granularity without recomputing full orbital propagation every decision step (Zhao et al., 29 Jan 2026).

The fine-grained assignment stage initializes the current controller as

$n$8

then, at each decision time $n$9, computes

$l$0

A handover is triggered only if the best controller is different from the current controller and the distance advantage satisfies the ratio test

$l$1

If that condition holds, the satellite records a handover event $l$2 and updates $l$3 (Zhao et al., 29 Jan 2026). The threshold suppresses unnecessary controller switching caused by small oscillations in distance, thereby reducing handover frequency. The paper also notes that the algorithm can be used proactively by ground stations to identify future handover events in advance, enabling data pre-synchronization before the actual switch (Zhao et al., 29 Jan 2026).

This predictive and thresholded mechanism is explicitly contrasted with both static placement schemes and naïve dynamic schemes. In a static scheme, a satellite remains bound to one controller or cluster for a long period, leading to long inter-satellite paths and higher latency as geometry changes. In a naïve dynamic scheme, a satellite simply rebinds to the currently nearest controller, which can cause excessive handovers whenever two controllers have similar distances or the satellite moves near a boundary. CNAA is designed to balance proximity and stability (Zhao et al., 29 Jan 2026).

4. Placement, activation, and the coupling between assignment and topology

Several papers stress that assignment quality depends strongly on which controllers are even available to be chosen. In KubeSpace, this coupling is formalized by the Control Node Placement Algorithm (CNPA), which chooses the set $l$4 of $l$5 ground stations to act as control nodes so as to minimize the worst-case satellite-to-nearest-controller latency over all sampled topologies (Zhao et al., 29 Jan 2026). The objective is

$l$6

with optimization

$l$7

subject to binary assignment and placement constraints. The paper describes this as an NP-hard 0–1 integer program and therefore uses a two-stage heuristic: cluster topology snapshots into representative groups using $l$8-means, select representative topologies, greedily add ground stations using a $l$9-center-style evaluation, and improve the result with local search (Zhao et al., 29 Jan 2026).

The dynamic CPSA framework similarly couples placement and assignment. In that model, a subset of satellites is activated as controllers, and each switch must be assigned to one active controller in each time slot (Jiang et al., 18 Apr 2025). The work argues that most existing strategies cannot sensibly and dynamically adjust the controller location and controller-switch mapping according to topology variation and traffic undulation meanwhile, hence the joint dynamic formulation (Jiang et al., 18 Apr 2025). The proposed prior population-based genetic algorithm strings together adjacent time-slot optimizations by seeding the next slot’s population with individuals from the previous slot, thereby exploiting continuity in topology and traffic (Jiang et al., 18 Apr 2025).

Opt-DSCA introduces controller activation decisions directly into the assignment problem. Unlike DSCA, which fixes the number of active controllers to $x^{[l]}_{i,j}$0, Opt-DSCA determines the optimal number of active controllers from network conditions (Hasanain et al., 22 Jul 2025). This suggests a broader interpretation of DSCA in which assignment and activation are co-optimized rather than treated as separate subproblems.

The relay-centric MPCC-DLT model extends this coupling in a different direction. There, assignment is not to fixed control-plane entities but to neighboring satellites selected for cooperative computation around a relay satellite. The relay chooses how much load to process locally and how much to distribute to children, with optimal fractions determined by equal-finish-time conditions (Veeravalli, 3 Jan 2026). The paper defines satellite contribution as

$x^{[l]}_{i,j}$1

and the minimum number of cooperating satellites needed to satisfy a deadline is chosen by ordering these contributions and adding satellites until feasibility is met (Veeravalli, 3 Jan 2026). A plausible implication is that DSCA-like problems can also be framed as dynamic controller-centered coalition formation under heterogeneous compute and communication conditions.

5. Optimization methods, graph-theoretic substrates, and learning-based interpretations

The literature spans exact formulations, heuristics, geometric constructions, and learning-based methods.

In the MILP-based DSCA and Opt-DSCA framework, both problems are solved using CPLEX implemented in Python, with OMNeT++, INET, and an extension of OS3 providing the simulation environment (Hasanain et al., 22 Jul 2025). This is a conventional mathematical programming approach, emphasizing explicit delay and activation objectives.

For dynamic joint placement and assignment, the prior population-based genetic algorithm (PPGA) is proposed to solve the time-slotted integer nonlinear CPSA problem (Jiang et al., 18 Apr 2025). At the first time slot, an initial prior individual is generated using a clustering-based method; for later slots, the prior population is formed from a subset of the final generation population from the previous slot together with the previous solution encoding. Genetic operators differ between placement and assignment parts of the chromosome, using partially matched crossover and reverse mutation for placement, and two-point crossover and breeder mutation for assignment (Jiang et al., 18 Apr 2025). The paper reports that consecutive time slots have similar topology, traffic, and good solutions, which motivates this warm-start strategy (Jiang et al., 18 Apr 2025).

A different foundation is provided by graph theory for resilient SDA. There, Voronoi tessellations define regions of spatial responsibility around actuator satellites, while Delaunay triangulation defines local communication pathways between them (Benchoubane et al., 13 May 2025). Voronoi cells approximate dynamic responsibility assignment because each point in space belongs to the nearest actuator; Delaunay edges provide a proximity-preserving communication graph whose properties include Euclidean Minimum Spanning Tree containment, a spanner property, and a closest pair property (Benchoubane et al., 13 May 2025). The framework then uses degree distribution in LEO and $x^{[l]}_{i,j}$2-core decomposition in higher orbits to select approver and verifier roles dynamically (Benchoubane et al., 13 May 2025). Although it does not solve a formal DSCA optimization problem, it supplies a topology-aware substrate for dynamic reassignment and cooperative control.

A learning-based interpretation emerges from the sequential assignment problem literature. Multi-agent reinforcement learning for sequential satellite assignment problems models assignment over time as a state-dependent MDP in which agents learn per-task values and a distributed optimal assignment mechanism selects the joint assignment (Holder et al., 2024). The method, REDA, learns $x^{[l]}_{i,j}$3 values per agent-task pair and applies the optimal assignment operator $x^{[l]}_{i,j}$4 to the learned value matrix, rather than asking agents to choose tasks directly (Holder et al., 2024). This is not presented as a DSCA algorithm in the control-plane sense, but it maps naturally to DSCA as a repeated, constrained, state-dependent assignment problem with handover and energy considerations.

6. Performance findings and empirically observed trade-offs

The published results converge on a common empirical theme: dynamic assignment improves delay performance relative to static assignment, but the best operating point depends on how aggressively reassignment is allowed.

In the SDN-enabled DSCA study, SSCA performs worst overall, especially when the number of controllers is small (Hasanain et al., 22 Jul 2025). With only 2 controllers, SSCA has many delays above 70 ms, while around 70% of communications with 7 controllers had delays below 65 ms (Hasanain et al., 22 Jul 2025). DSCA consistently gives shorter delays than SSCA because it dynamically reassigns satellites as the constellation moves; one reported example states that at about 55 ms, roughly 60% of communications are served by DSCA, while SSCA is closer to 70 ms delay (Hasanain et al., 22 Jul 2025). The same study reports that adding controllers beyond 4 yields diminishing returns, and that Opt-DSCA dynamically activates between 2 and 5 controllers while keeping propagation delay in an acceptable range of 50–65 ms (Hasanain et al., 22 Jul 2025). This demonstrates the paper’s central trade-off: more active controllers lower delay but increase resource usage, whereas fewer active controllers improve efficiency but may increase reassignment and delay if underprovisioned (Hasanain et al., 22 Jul 2025).

KubeSpace reports strong assignment-related results on Starlink traces. For placement, with $x^{[l]}_{i,j}$5 and 20 topology clusters, CNPA achieves an average daily maximum communication latency of 60.05 ms, within 1 ms of exhaustive optimum, and an average communication latency of 32.05 ms, also within 1 ms of optimal (Zhao et al., 29 Jan 2026). Compared with random placement, the maximum latency is reduced by 22%, and compared with the single-node scheme it is reduced by 50% (Zhao et al., 29 Jan 2026). For dynamic assignment, CNAA reduces control-node handover frequency by 19% relative to a baseline that chooses only the shortest-distance controller, while increasing average communication latency by only 2 ms (Zhao et al., 29 Jan 2026). The paper frames this as a better overall operating point because lower handover churn also reduces pre-synchronization overhead and helps preserve uninterrupted management (Zhao et al., 29 Jan 2026).

KubeSpace further reports that a normal Kubernetes node handoff requires leaving one cluster and joining another, involving eviction, cleanup, re-registration, and often service interruption. Even with an nginx container over a wired LAN, the handover takes about 9.7 seconds, with roughly 4.5 seconds of node invisibility (Zhao et al., 29 Jan 2026). Against other multi-controller platforms, KubeSpace reduces handover latency by about 84% versus Karmada and 79% versus Multi-KubeEdge, reduces daily node invisibility to effectively zero, eliminates pod unavailability during handovers, and achieves a 59% reduction in average satellite management latency compared with Krios, with no management interruption time (Zhao et al., 29 Jan 2026). These findings position DSCA not merely as a latency optimization problem but as a control-plane continuity problem.

In dynamic joint controller placement and assignment, PPGA is reported to perform best or near-best across metrics including load balance, controller migration cost, switch reassignment cost, synchronization cost, and average response delay (Jiang et al., 18 Apr 2025). Reported synchronization costs include $x^{[l]}_{i,j}$6 ms for PPGA, $x^{[l]}_{i,j}$7 ms for MDPC, and $x^{[l]}_{i,j}$8 ms for MAFST, while average response delay is reported as stable in the range of about 30 ms to 115 ms (Jiang et al., 18 Apr 2025). A notable result is convergence speed: with prior population, optimization takes about 20 generations, versus more than 200 generations with only random population (Jiang et al., 18 Apr 2025).

7. Related interpretations, misconceptions, and open distinctions

A common misconception is to treat DSCA as synonymous with “always choose the nearest controller.” The KubeSpace results directly contradict this simplification: a purely shortest-distance baseline can cause excessive handovers, and a thresholded predictive policy can reduce handover frequency with only a 2 ms increase in average communication latency (Zhao et al., 29 Jan 2026). More generally, DSCA is a multi-objective balancing problem in which proximity and stability are both first-class concerns.

Another potential misconception is that DSCA necessarily implies a single unified global cluster. KubeSpace explicitly rejects this interpretation. Its distributed control plane is not a “single unified Kubernetes cluster” spread across the globe; rather, it is an independent multi-controller architecture in which each ground node governs its own satellite subset (Zhao et al., 29 Jan 2026). To prevent interference, KubeSpace introduces a state-based binding model using a custom ControlPlaneBindingState field on each satellite node with states Bound, Binding, Releasing, or Released, and the controller manager and scheduler filter out nodes that are not Bound (Zhao et al., 29 Jan 2026). This suggests that DSCA in distributed cloud-native control planes includes namespace and state-isolation mechanisms in addition to assignment logic.

The relationship between DSCA and controller placement is also often understated. Both KubeSpace and dynamic CPSA show that assignment quality depends strongly on the controller candidate set (Zhao et al., 29 Jan 2026, Jiang et al., 18 Apr 2025). This suggests that “assignment-only” views of DSCA may be incomplete in settings where controllers themselves can be placed, activated, or migrated.

Finally, the literature does not converge on a single universal DSCA abstraction. In one line of work, DSCA is a MILP over satellite-controller assignments and active-controller variables (Hasanain et al., 22 Jul 2025). In another, it is a predictive handover-control policy embedded in a multi-controller orchestration architecture (Zhao et al., 29 Jan 2026). In a broader sense, it includes relay-selected cooperative clusters in distributed computation (Veeravalli, 3 Jan 2026), geometric responsibility reassignment in resilient SDA (Benchoubane et al., 13 May 2025), and sequential assignment learned by MARL with distributed assignment operators (Holder et al., 2024). A plausible implication is that DSCA is best understood as a unifying systems problem rather than a single canonical optimization model: the repeated selection of control responsibility under orbital mobility, constrained communication, and non-negligible reassignment cost.