Topology-Aware Joint Control Plane Placement and Assignment for Resilient Hierarchical Cloud–Edge Networks

Abstract

Hierarchical cloud–edge networks rely on distributed control planes to manage large-scale heterogeneous infrastructures, where controller placement and node assignment strongly affect latency, load balancing, and resilience. Existing methods typically decouple these decisions and provide limited guarantees under controller failures or topology constraints. We introduce a topology-aware joint optimization framework for controller placement and node assignment in hierarchical cloud–edge networks. The problem is formulated as a multi-objective integer linear program capturing latency, load balancing, and control continuity. To ensure scalability, we design a two-phase heuristic: structurally important controller candidates are selected using graph-based metrics, including node degree and k-core decomposition, followed by a redundancy-aware proximity assignment strategy that preserves connectivity under single-controller failures. Experiments on synthetic hierarchical and random topologies with up to 500 nodes show that the proposed approach achieves optimality gaps below 10% with execution times under 10 ms. It improves load distribution and reduces control latency compared to baseline methods while maintaining resilience under controller failures. Results show that exploiting topological structure in joint placement and assignment enables efficient and resilient control plane design for hierarchical cloud–edge networks, supporting near-real-time reconfiguration.

1. Introduction

The separation of the control plane from the data plane and the introduction of centralized network management have established Software-Defined Networking (SDN) as a transformative paradigm for overcoming the rigidity of traditional network architectures. The ability to dynamically configure, monitor, and optimize network behavior through software control is particularly beneficial for large-scale applications such as cloud computing, the Internet of Things (IoT), and 5G/6G networks. However, the centralized nature of the control plane introduces new challenges related to reliability, scalability, and performance [1,2].

Controller Placement Problem (CPP) is one of the most critical design challenges in SDN, as it determines the number and locations of controllers to minimize control latency, maximize reliability, and maintain a balanced workload distribution. Improper placement leads to high switch-to-controller communication delay, controller overload, and reduced network resilience. Heller et al. [3] demonstrated that this latency has a significant impact on network performance, establishing controller placement as a fundamental design factor in SDN architectures. Subsequent studies extended CPP to additional objectives including fault tolerance [4] and energy efficiency [5].

In multi-controller SDN environments, CPP is inherently coupled with the switch assignment problem, which determines how switches are mapped to controllers under latency and capacity constraints. Addressing placement without jointly optimizing assignment leads to suboptimal performance, particularly in large-scale or mission-critical networks [6,7]. Inefficient assignment strategies result in controller congestion, increased control overhead, and degraded fault tolerance [5].

As SDN deployments scale and diversify, resilience has emerged as the primary design requirement. Networks must maintain operation during controller failures, link failures, and unexpected traffic surges [3,7,8]. A widely adopted strategy is redundant multi-controller deployment, where each switch is connected to multiple controllers so that backup controllers take over upon primary failure. However, resilience cannot be achieved by placement alone; the assignment of switches to controllers determines the backup relationships that exist in practice, making joint optimization essential [8,9].

The urgency of this joint design is further amplified as SDN deployments extend beyond fixed terrestrial infrastructures into inherently dynamic environments, including LEO satellite constellations, vehicular networks, and large-scale IoT deployments [10,11,12]. In such settings, topology changes and controller failures are routine operational events rather than exceptional conditions, and controller reassignment must complete within the network’s coherence time, namely the interval during which current topology and load conditions remain operationally valid. A control plane that cannot adapt at this speed offers only nominal fault tolerance, making fast and topology-aware joint optimization a practical necessity rather than a theoretical concern.

Recent work has addressed resilience-aware CPP through a variety of optimization and metaheuristic approaches, including genetic algorithms, particle swarm optimization, and integer linear programming [13]. Despite this progress, most existing methods treat controller placement and switch assignment as sequential or independent subproblems, limiting their effectiveness in dynamic or failure-prone environments. Furthermore, many approaches focus narrowly on latency minimization without fully accounting for redundancy requirements, controller capacity limits, and the topological structure of the network.

In this paper, we propose a joint optimization framework for controller placement and switch assignment in resilient SDN environments. The framework is grounded in a multi-objective Integer Linear Program (ILP) that jointly optimizes controller placement and switch assignment under resilience, capacity, and QoS constraints, incorporates topological centrality measures based on node degree and k-core decomposition into the objective function, and serves as an exact benchmark for evaluating heuristic solutions.

To overcome the computational limitations of exact optimization at scale, a two-phase heuristic framework was proposed. In the first phase, five topology-aware candidate selection strategies of polynomial complexity exploit structural graph properties to identify a compact set of controller locations. In the second phase, switches are assigned to the selected controllers through a greedy proximity-driven algorithm that enforces redundancy and respects capacity constraints. By construction, every switch has guaranteed connections to a minimum number of controllers, ensuring control-plane continuity under individual controller failures.

The main contributions of this paper are as follows:

• We propose a multi-objective ILP that integrates k-core decomposition and node degree as explicit optimization criteria alongside latency minimization and assignment coverage, enabling the network’s structural backbone to directly guide resilient controller placement decisions.
• We introduce five topology-aware candidate selection strategies of polynomial complexity and provide a systematic comparison of structural criteria, from local degree to global core number, for controller placement, together with a complete complexity analysis.
• We design a two-phase heuristic framework that separates candidate selection from switch assignment, guarantees per-switch redundancy through minimum assignment constraints, and enforces controller capacity limits using a proximity-driven greedy assignment algorithm.
• We perform a systematic scalability study comparing exact and heuristic controller placement across two structurally distinct topologies, namely flat random and hierarchical multi-core networks, up to 500 nodes. The results quantify optimality gaps and demonstrate that richer hierarchical k-core structures significantly improve heuristic solution quality by reducing placement symmetry.

The remainder of this paper is organized as follows. Section 2 reviews related work on controller placement and resilient SDN. Section 3 presents the system model and relevant graph-theoretic concepts. Section 4 formalizes the optimization problem. Section 5 describes the proposed heuristic framework. Section 6 presents the numerical evaluation. Section 7 concludes the paper and outlines directions for future research.

2. Literature Review

CPP has been extensively studied since the early formalization by Heller et al. [3], who demonstrated that the geographic distribution of controllers significantly affects switch-to-controller latency and established CPP as a foundational SDN design challenge. Comprehensive surveys have confirmed that the problem has since expanded well beyond latency minimization to encompass resilience, capacity, energy efficiency, and joint assignment objectives [7,10,14,15]. This section organizes existing contributions into four themes: latency-aware placement, resilience and fault tolerance, switch assignment, and joint optimization approaches, before positioning the present work with respect to the identified gaps.

2.1. Latency-Aware Controller Placement

Early CPP formulations primarily focused on minimizing the propagation delay between switches and controllers. Subsequent work extended this to multi-controller settings, where controller-to-controller synchronization delay must also be accounted for [16]. Naseri et al. [17] proposed a binary linear programming model that jointly minimizes the setup cost and average control packet latency in wide-area networks, demonstrating favorable trade-offs over prior methods. Metaheuristic approaches have also been applied to the latency minimization objective: Ma et al. [18] proposed an improved artificial bee colony algorithm that simultaneously minimizes the average and worst-case propagation latency while balancing the controller load, achieving solutions within 4.37% of the optimum on real-world topologies. More recently, deep reinforcement learning has been applied to dynamic controller placement in IoT and vehicular networks [19], where traffic fluctuations render static placement strategies insufficient. Despite these advances, latency-only formulations remain insufficient when redundancy requirements and controller capacity constraints are jointly present.

2.2. Resilience and Fault Tolerance

Resilience-aware placement has received increasing attention as SDN deployments move toward mission-critical applications. Sallahi and St-Hilaire [4] formulated an optimal placement model that guarantees switch connectivity under single controller failures. Vizarreta et al. [20] proposed two strategies based on disjoint control paths and distinct controller replicas, showing that both significantly improve control-plane resilience with a limited penalty on the average path length. Perrot and Reynaud [21] formulated an ILP for resilient placement by incorporating QoS and load balancing constraints at multiple backup levels. Kumari et al. [22] showed through a survey that redundancy alone does not guarantee reliability unless switches are properly distributed among the controllers. At larger scales, Mogyorósi et al. [23] addressed resilient control-plane design for virtualized 6G core networks, proposing latency-aware dual hypervisor placement protected against single-link and node failures and proved that finding the minimum number of hypervisors is NP-hard and difficult to approximate.

More recently, the resilience challenge has expanded to non terrestrial and integrated network environments. Chiti et al. [12] propose a multi controller placement strategy for integrated terrestrial and LEO satellite networks in which satellites dynamically operate as SDN controllers despite frequent topology variations. Their results show that topology aware placement substantially reduces latency while improving control plane load balancing. Choi et al. [11] address the scalability aspect of this problem in LEO mega constellations. They introduce a topology virtualization framework that isolates the control plane from continuous topological changes and achieves efficient load balancing across deployments at the scale of Starlink.

2.3. Switch Assignment

The switch assignment problem has received comparatively less attention as an independent problem. Tanha et al. [6] showed that assigning switches to multiple controllers significantly improves the reliability of wide-area SDN, and formulated capacity-constrained assignment as an optimization model. Lange et al. [5] demonstrated that the nearest-controller assignment leads to an uneven load distribution under heterogeneous traffic, thereby motivating load-aware heuristics. Dynamic assignment strategies have more recently been explored through reinforcement learning: Bouzidi et al. [24] proposed a deep Q-network approach that dynamically clusters switches and places controllers to minimize response time and intra-cluster delay, while Kumari et al. [25] used online reinforcement learning to rebalance switch-to-controller mappings under dynamic traffic and failure events.

2.4. Joint Placement and Assignment

A growing body of work has recognized that placement and assignment must be optimized jointly because their interdependence makes sequential approaches inherently suboptimal [7,13]. Dong and Xue [13] formulated a mixed-integer joint optimization model that minimizes the control delay while balancing the controller workload. Metaheuristic approaches have also been applied to the joint problem: Liao and Leung [26] proposed a multi-objective genetic algorithm with particle swarm optimization-based mutation to simultaneously minimize switch-to-controller delay, controller-to-controller delay, and load imbalance, while Radam et al. [27] combined harmony search and particle swarm optimization for multi-controller placement. Sirjani et al. [28] combined reinforcement learning with metaheuristics for joint placement and demonstrated improved scalability over pure ILP approaches. The graph-theoretic properties have also been explored as structural proxies for controller placement. Kumar and Malik [29] proposed a k-core decomposition-based articulation point method for identifying critical controller locations in IoT-SDN networks, combined with a metaheuristic optimization stage.

2.5. Positioning of This Work

Despite extensive research on controller placement, three gaps remain.

Firstly, while k-core decomposition has been used as a preprocessing or ranking heuristic [29], it has not been systematically integrated as an explicit optimization component within a unified formulation that jointly considers node degree, distance-aware costs, and resilience-oriented design objectives.

Secondly, most existing formulations treat redundancy requirements and controller capacity constraints in isolation, and rarely embed them within a single consistent optimization framework that also accounts for structural centrality and communication cost.

Thirdly, the joint scalability analysis of exact and heuristic approaches across structurally diverse network topologies remains limited, particularly beyond a few hundred nodes and across heterogeneous structures such as random and hierarchical multi-core networks.

This paper addresses these gaps through a unified ILP formulation that integrates structural centrality and performance objectives, a set of five topology-aware candidate selection strategies with formal complexity analysis, and a systematic scalability study up to 500 nodes across random and hierarchical multi-core topologies.

3. System Model

3.1. Network Model

We model the underlying physical infrastructure as an undirected graph $G=(V,E)$, where V is the set of network nodes and $E\subseteq V\times V$ is the set of bidirectional communication links. Each node $v\in V$ represents a physical device that hosts a switch responsible for forwarding data-plane traffic. A subset $L\subseteq V$ identifies the nodes that are additionally eligible to host an SDN controller, so that $S=V$ and $L\subseteq S$. In the simulation study presented in Section 6, we adopted the common assumption that every node in V is a candidate controller location, that is, $L=V$, so that the placement strategies operate over the full node set.

3.1.1. Local Connectivity: Node Degree

The degree of node $l\in V$ is defined as the number of its direct neighbors:

$$\mathrm{deg}\left(l\right)=\left|\right\{j\in V\mid (l,j)\in E\left\}\right|.$$

(1)

Nodes with a higher degree offer a larger number of alternative communication paths, thereby reducing the risk of isolation under link failures. In the context of controller placement, high-degree nodes can serve a larger number of switches over short paths, enhancing the local fault tolerance and reducing the average control-plane latency.

3.1.2. Global Centrality: Core Number

The k-core of graph G is the maximal subgraph in which every node has degree at least k [30]. We denote by ${\mathcal{C}}_k\left(G\right)$ the k-core of G. The core number of node l is defined as the index of the deepest k-core to which the node belongs.

$$\kappa \left(l\right)=\max \{k\mid l\in {\mathcal{C}}_k\left(G\right)\}.$$

(2)

Nodes with a high core number, $\kappa \left(l\right)$, reside in the densest and most interconnected regions of the network, thus forming a structural backbone. Controllers placed at such nodes maintain connectivity to a large fraction of the network, even under partial failures, thereby enhancing the global robustness of the control plane.

Figure 1 illustrates the k-core decomposition of the Karate Club network [31], which is a widely used benchmark in graph theory. Each panel shows the subgraph induced by nodes belonging to the k-core at the corresponding level, with node colors consistent across the panels. The color of a node reflects its core number and is preserved as decomposition deepens. Nodes surviving into the innermost core ($\kappa =4$ here) form the densest and most interconnected subgraph and are precisely those prioritized as candidate controller locations by the Core-Only and Hybrid Centrality strategies introduced in Section 5.

3.1.3. Topological Motivation for Placement

Together, $\mathrm{deg}\left(l\right)$ and $\kappa \left(l\right)$ capture the complementary aspects of the node centrality. A node may have a high degree but low core number, indicating many neighbors in a sparse periphery, or a high core number but a moderate degree, indicating deep embeddedness in a dense subgraph. Controllers placed at nodes that score highly on both metrics are simultaneously well connected locally and structurally robust globally, which is the guiding principle of the placement strategies developed in Section 5.

3.2. SDN Control Plane Architecture

In SDN, the control plane is physically decoupled from the data plane. Switches handle packet forwarding according to flow rules, whereas controllers maintain a global view of the network and issue configuration commands to the switches via a dedicated control channel. Therefore, the placement of controllers and assignment of switches to controllers are critical design decisions that directly affect the performance, reliability, and scalability of the control plane.

3.2.1. Switch-Controller Assignment

Each switch $s\in S$ must be assigned to at least one controller $l\in L$ through which it receives control instructions. Communication between switches and controllers is mediated by a southbound interface, for which several protocols have been proposed. OpenFlow [1] is among the most widely adopted, explicitly supporting the notion of a primary controller handling active control decisions, and one or more backup controllers that take over upon primary failure. Other protocols, such as NETCONF and RESTCONF, offer alternative interaction models that are oriented toward device configuration and telemetry. While the choice of the southbound protocol is not the focus of this work, it is worth noting that placement strategies are not entirely protocol-agnostic: latency-sensitive protocols such as OpenFlow favor distributed, proximity-aware placements, whereas configuration-driven or telemetry-oriented protocols may shift the optimization emphasis toward scalability and load balancing. In this study, we adopt a latency-aware model consistent with the OpenFlow interaction paradigm, using the shortest-path distance as a proxy for the control-plane propagation delay.

3.2.2. Resilience Through Redundant Assignment

A single-controller assignment leaves the network vulnerable to controller failures; if the sole controller of a switch becomes unavailable, the switch loses all control-plane connectivity. To mitigate this risk, each switch must be connected to a minimum number of controllers, $R_{\min }\ge 2$, ensuring that at least one backup controller is always available. Conversely, assigning a switch to too many controllers introduces unnecessary synchronization overheads and control traffic. Therefore, an upper bound $R_{\max }$ is imposed on the number of controllers per switch. Together, $R_{\min }$ and $R_{\max }$ define the redundancy requirements that are formally expressed as assignment bounds in the problem formulation.

3.2.3. Controller Capacity

Each controller has a finite processing capacity and can reliably manage at most $C_{\max }$ switches simultaneously. Exceeding this limit degrades the control responsiveness and increases the risk of control-plane congestion. This capacity limitation is enforced as a constraint in the optimization model, and its interaction with the redundancy requirement $R_{\min }$ governs the global feasibility of any valid assignment, a condition explicitly verified in the heuristic procedure in Section 5.

3.2.4. Number of Controllers

Deploying more controllers improves coverage and reduces switch-to-controller distances, but increases infrastructure and management costs. The budget constraint limits the total number of active controllers to $N_{\max }^{ctrl}$. Therefore, the joint optimization of controller placement and switch assignment must balance resilience, efficiency, and deployment cost within these structural constraints, all of which are formalized in the following section.

3.3. Communication Cost Model

In SDN, the responsiveness of the control plane depends critically on the latency of the communication channel between each switch and its assigned controllers. A switch that is topologically distant from its controller experiences longer round-trip times for control message exchanges, thereby degrading the flow setup latency and reaction time to network events. Therefore, accurately modeling this cost is central to any placement optimization framework.

3.3.1. Distance as a Proxy for Propagation Delay

We quantify the communication cost between switch $s\in S$ and candidate controller location $l\in L$ using the shortest-path distance in graph G:

$$d(s,l)=\mathrm{length} \mathrm{of} \mathrm{the} \mathrm{shortest} \mathrm{path} \mathrm{between} s \mathrm{and} l \mathrm{in} G.$$

(3)

This metric serves as a proxy for the propagation delay under the assumption that each hop introduces a uniform and additive latency contribution. Although more refined delay models incorporating link capacities, queuing delays, or geographic distances can be substituted without altering the problem structure, the hop-count metric is widely adopted in the controller placement literature because it captures the essential topology-dependent cost in a tractable and parameter-free manner.

3.3.2. Distance and QoS Requirements

In practice, SDN deployments impose implicit or explicit QoS requirements on control-plane latency. Beyond a certain switch-to-controller distance, the resulting propagation delay becomes operationally unacceptable; the flow setup times increase, fault detection is delayed, and network responsiveness degrades. This motivates treating $d(s,l)$ not merely as a cost to minimize but also as a QoS-relevant quantity that should be kept below an acceptable level for every active switch-controller pair. In the optimization model, this is captured softly through a distance penalty term in the objective function, which discourages long-range assignments without imposing a hard cut-off. In the heuristic assignment procedure, a derived distance threshold is used to explicitly reject assignments whose cost outweighs their benefit to the objective. This is formalized in Section 5 once the objective parameters have been introduced.

4. Problem Formulation

Building on the system model introduced in the previous section, we formalize the joint controller placement and switch assignment problem as an ILP. The model captures the resilience, efficiency, and load-balancing requirements identified in Section 3 through a set of binary decision variables, a collection of structural constraints, and a multi-component objective function that balances competing design criteria.

4.1. Decision Variables

Placement and assignment decisions are encoded using two binary variables and one integer variable:

$$\begin{array}{cc}\hfill y_l& =\left\{\begin{array}{cc}1\hfill & \mathrm{if} \mathrm{a} \mathrm{controller} \mathrm{is} \mathrm{placed} \mathrm{at} \mathrm{node} l\in L,\hfill \\ 0\hfill & \mathrm{otherwise}.\hfill \end{array}\right.\hfill \\ \hfill x_{ls}& =\left\{\begin{array}{cc}1\hfill & \mathrm{if} \mathrm{switch} s\in S \mathrm{is} \mathrm{assigned} \mathrm{to} \mathrm{controller} l\in L,\hfill \\ 0\hfill & \mathrm{otherwise}.\hfill \end{array}\right.\hfill \end{array}$$

Variable $y_l$ encodes the controller placement decision, whereas $x_{ls}$ encodes the assignment of switches to the active controllers.

4.2. Parameters

Table 1. Key parameters of the controller placement and switch assignment model.

Parameter	Description
$R_{\min }$	Minimum number of controllers per switch (resilience requirement)
$R_{\max }$	Maximum number of controllers per switch
$C_{\max }$	Maximum number of switches managed by a single controller
$N_{\max }^{ctrl}$	Maximum number of controllers to deploy
$d(s,l)$	Shortest-path distance between switch s and controller node l
$\mathrm{deg}\left(l\right)$	Degree of node l in graph G
$\kappa \left(l\right)$	Core number of node l in G
$\alpha ,\beta ,\gamma ,\delta$	Non-negative weights controlling the relative importance of each objective component

summarizes the key parameters used in our controller placement and switch assignment model.

4.3. Constraints

4.3.1. Assignment Bounds per Switch

Each switch must be connected to at least $R_{\min }$ and at most $R_{\max }$ controllers. These bounds define the admissible redundancy range for each switch: the lower bound guarantees resilient multi-controller connectivity, whereas the upper bound limits synchronization overhead and control-plane signaling complexity.

$$\begin{array}{c}\hfill R_{\min }\le \sum _{l\in L}{x}_{ls}\le R_{\max },\forall s\in S.\end{array}$$

(4)

4.3.2. Valid Assignments Only to Active Controllers

A switch can only be assigned to a controller activated by the placement decision.

$$\begin{array}{c}\hfill x_{ls}\le y_l,\forall s\in S,\forall l\in L.\end{array}$$

(5)

4.3.3. Controller Capacity Constraint

Each controller can simultaneously manage at most $C_{\max }$ switches and prevent a control-plane overload.

$$\begin{array}{c}\hfill \sum _{s\in S}{x}_{ls}\le C_{\max },\forall l\in L.\end{array}$$

(6)

4.3.4. Limit on Total Number of Controllers

The total number of deployed controllers is bounded by the available infrastructure budget.

$$\begin{array}{c}\hfill \sum _{l\in L}{y}_l\le N_{\max }^{ctrl}.\end{array}$$

(7)

4.4. Objective Function

We decompose the objective into four components, each capturing a distinct structural or performance criterion for the joint controller placement and switch assignment problem.

4.4.1. Assignment Coverage

$$z_{\mathrm{assign}}=\sum _{s\in S}\sum _{l\in L}{x}_{ls}$$

(8)

This term aggregates the total number of switch-controller associations induced by a feasible assignment. The admissible range of redundancy is enforced through the constraint in (4), which guarantees that each switch is assigned at least $R_{\min }$ and at most $R_{\max }$ controllers. Within these feasibility limits, the term contributes to the objective by favoring configurations that fully utilize the available redundancy budget across the network, thereby supporting resilient multi-controller connectivity.

4.4.2. Local Connectivity Preference

$$z_{\mathrm{degree}}=\sum _{l\in L}\mathrm{deg}\left(l\right)y_l$$

(9)

This component favors controller locations with higher node degrees, promoting locally well-connected placements that reduce the average hop count to neighboring switches.

4.4.3. Global Centrality Preference

$$z_{\mathrm{core}}=\sum _{l\in L}\kappa \left(l\right)y_l$$

(10)

This term rewards the selection of controllers at nodes with a high core number, thereby placing the control plane in the structurally robust backbone of the network.

4.4.4. Distance Penalty

$$z_{\mathrm{distance}}=\sum _{s\in S}\sum _{l\in L}d(s,l)x_{ls}$$

(11)

This term penalizes long communication paths between switches and their assigned controllers, acting as a soft QoS constraint on control-plane latency.

4.4.5. Overall Objective

The four components are combined into a single weighted objective:

$$\max \left(\alpha z_{\mathrm{assign}}+\beta z_{\mathrm{degree}}+\gamma z_{\mathrm{core}}-\delta z_{\mathrm{distance}}\right)$$

(12)

where $\alpha ,\beta ,\gamma ,\delta \ge 0$ control the relative importance of each criterion. Note that $z_{\mathrm{distance}}$ has a negative sign, as it represents the cost to be minimized rather than the benefit to be maximized.

The proposed formulation balances structural robustness and operational QoS objectives through comparable weighting coefficients. In the experimental configuration, the assignment coverage, degree centrality, k-core centrality, and distance penalty terms are assigned weights of similar magnitude ($\alpha =15$, $\beta =10$, $\gamma =12$, and $\delta =10$). The larger value assigned to $\alpha$ reflects the resilience-oriented design objective of the framework, where redundant controller assignments are prioritized slightly more strongly than communication distance minimization. At the same time, the coefficients remain sufficiently balanced to avoid the dominance of any single objective component. Consequently, controller placement decisions emerge from a joint trade-off between coverage, resilience, connectivity, and communication cost rather than being driven solely by topological or performance-related factors.

4.5. Complete ILP Formulation

The model seeks a joint deployment of controllers and assignment of switches that simultaneously ensures resilience through redundant assignments, favors topologically central controller locations, penalizes distant switch-controller pairs, and respects both the controller capacity and deployment budget. The complete integer linear program is as follows:

$$\begin{array}{cc}\hfill \underset{x,y}{\max }& \alpha \sum _{s\in S}\sum _{l\in L}{x}_{ls}+\beta \sum _{l\in L}\mathrm{deg}\left(l\right)y_l+\gamma \sum _{l\in L}\kappa \left(l\right)y_l-\delta \sum _{s\in S}\sum _{l\in L}d(s,l)x_{ls}\hfill \\ \hfill \mathrm{s}.\mathrm{t}.& R_{\min }\le \sum _{l\in L}{x}_{ls}\le R_{\max },\forall s\in S,\hfill \\ & x_{ls}\le y_l,\forall s\in S,\forall l\in L,\hfill \\ & \sum _{s\in S}{x}_{ls}\le C_{\max },\forall l\in L,\hfill \\ & \sum _{l\in L}{y}_l\le N_{\max }^{ctrl},\hfill \\ & x_{ls},y_l\in \{0,1\}.\hfill \end{array}$$

4.6. Scalability Challenges and Heuristic Design Rationale

The joint placement and assignment problem formulated above belongs to the class of facility location problems, which is known to be NP-hard in general [32]. The additional resilience constraints, requiring each switch to be assigned to at least $R_{\min }$ controllers, further expand the combinatorial search space, making exact ILP solving tractable only for small-to-medium networks within reasonable time budgets. State-of-the-art solvers such as Gurobi or CPLEX are retained here as an exact benchmark, but as shown in Section 6, their runtime grows sharply with network size, rendering them unsuitable for large-scale or time-sensitive deployments.

In dynamic environments such as LEO satellite constellations, vehicular networks, and large-scale IoT infrastructures, reconfiguration must complete within the network’s coherence time, the interval during which current topology and load conditions remain operationally valid, making fast solution methods an operational requirement rather than a convenience.

The two-phase heuristic design proposed in Section 5 is a deliberate architectural choice grounded in the structure of the problem itself. The joint placement and assignment problem admits a natural decomposition: identifying where controllers should be placed is structurally separable from determining how switches should be assigned to those controllers, even though the two decisions remain coupled in the objective function.

This separability motivates a first phase that exploits graph-structural metrics, namely node degree and k-core decomposition, to identify a compact set of candidate controller locations at polynomial cost. These metrics serve as computationally efficient proxies for the placement component of the ILP objective. High-degree nodes are structurally central and tend to reduce the average hop distance, while k-core decomposition identifies the densely connected backbone of the network, where controller placement improves both coverage and resilience.

The second phase then solves the assignment problem over this reduced candidate set using a proximity-driven greedy algorithm that enforces redundancy and capacity constraints by construction.

Beyond computational efficiency, this design offers two practical advantages over black-box metaheuristics such as simulated annealing or genetic algorithms. Firstly, it is interpretable: an operator can directly understand why a controller is placed at a given node based on its graph-structural role. Secondly, it is incrementally re-executable, meaning that a topology change or failure event triggers only a local reassignment rather than a complete re-optimization from scratch.

Reinforcement learning (RL) and multi-agent reinforcement learning (MARL) have demonstrated promising results in dynamic network management [24,25,28], and MARL in particular offers low inference latency once trained. However, several practical considerations motivate the heuristic approach adopted in this work. First, RL-based methods typically require a large and representative training corpus covering diverse topology instances and operating conditions. In environments involving arbitrary or evolving topologies, a pre-trained policy may not generalize effectively without additional retraining, introducing a deployment overhead that the proposed framework avoids. Second, RL policies do not generally provide explicit optimality guarantees with respect to the underlying ILP objective. In contrast, the proposed two-phase heuristic can be directly benchmarked against the exact ILP solution through the optimality gap metric, enabling a transparent assessment of solution quality. Third, interpretability remains an important consideration in control plane design. Placement decisions derived from graph-structural metrics such as degree centrality or k-core decomposition are readily explainable, whereas the internal decision process of a learned policy is typically less transparent. Investigating RL-based adaptive reconfiguration as a complement to the proposed framework, particularly in highly dynamic environments, constitutes an interesting direction for future work.

5. Heuristic Controller Placement and Switch Assignment

The proposed framework addresses the joint controller placement and switch assignment problem using a two-phase heuristic procedure. In the first phase, a restricted set of candidate controller locations $\mathcal{L}\subseteq V$ is identified by exploiting the topological structure of the network. In the second phase, switches are assigned to the selected controllers according to QoS-driven criteria. Proximity is a proxy for propagation delay and resilience requirements, whereby each switch must be assigned to at least $R_{\min }$ controllers to ensure fault tolerance in the control plane. This separation between placement and assignment allows the two phases to be analyzed independently, while their combination yields a complete, computationally tractable solution whose quality is benchmarked against the exact ILP optimum via the gap metric (17).

The proposed heuristics exploit graph-structural properties such as node degree and k-core centrality, together with proximity and coverage-driven criteria, to construct computationally efficient approximations of the underlying multi-objective placement problem. This design ensures that the heuristics are not solving a fundamentally different optimization problem, but rather providing scalable surrogate solutions that preserve the trade-off between resilience, topological centrality, and communication distance. Consequently, the comparison with the ILP is performed under identical modeling assumptions, allowing us to quantify how closely lightweight topology-aware methods approximate the exact solution under scalability constraints.

5.1. Controller Candidate Selection

5.1.1. Motivation

Solving the ILP directly over the full node set V becomes computationally expensive for medium- and large-scale networks, as established in Section 4. To address this limitation, we first introduce Algorithm 1, which defines a candidate preselection phase in which each strategy constructs a restricted set $\mathcal{L}\subseteq V$ such that $\left|\mathcal{L}\right|=N_{\max }^{ctrl}$. Five strategies are considered, each exploiting a different structural property of the network, namely Core-Only, Degree-Based, Hybrid Centrality, Distance-Sum, and Greedy Coverage, which are used throughout the paper under these names for simplicity.

5.1.2. Core-Only

Nodes with a high core number $\kappa \left(l\right)$ belong to dense and structurally central regions of the network, making them natural controller candidates. The selection starts from the deepest core level ${\kappa }^{\mathrm{start}}\in \left[{\kappa }^{\min },{\kappa }^{\max }\right]$ and accumulates candidates by descending through the core levels until $N_{\max }^{ctrl}$ nodes are collected:

$$\begin{array}{cc}\hfill \mathcal{L}& \leftarrow \mathcal{L}\cup \{l\in V\mid \kappa (l)\ge k\},\hfill \\ & \mathrm{for} k={\kappa }^{\mathrm{start}},{\kappa }^{\mathrm{start}}-1,\dots ,1\hfill \end{array}$$

until $\left|\mathcal{L}\right|\ge N_{\max }^{ctrl}$ or $k<1$. By default, ${\kappa }^{\mathrm{start}}={\kappa }^{\max }$, so the selection begins from the innermost core and expands outward only as needed. If $\left|\mathcal{L}\right|>N_{\max }^{ctrl}$ after accumulation, the set is trimmed by retaining the top-$N_{\max }^{ctrl}$ nodes ranked by descending degree, with the node index used as a deterministic tie breaker:

$$\mathcal{L}=\mathrm{Top}\text{-}{N}_{\max }^{ctrl}\left(\mathrm{deg}\left(l\right),\mathrm{id}\left(l\right)\mid l\in \mathcal{L}\right).$$

5.1.3. Degree-Based

This strategy prioritizes locally well-connected nodes, under the assumption that high-degree nodes can reach more switches with fewer hops. Nodes are ranked by degree in descending order, and the top $\min (N_{\max }^{ctrl},|V\left|\right)$ nodes are selected as follows:  

$$\mathcal{L}=\mathrm{Top}\text{-}\min (N_{\max }^{ctrl},\left|V\right|)\left(\mathrm{deg}\left(l\right)\mid l\in V\right).$$

This formulation ensures that the selection remains valid when the network contains fewer nodes than the required number of controllers.

5.1.4. Hybrid Centrality

To combine local and global structural importance, a weighted composite score is defined as

$$\varphi \left(l\right)={\omega }_{\kappa }\kappa \left(l\right)+{\omega }_d{C}_d\left(l\right)+{\omega }_{b}b\left(l\right)+{\omega }_{c}c\left(l\right),$$

where $C_d\left(l\right)$, $b\left(l\right)$, and $c\left(l\right)$ denote the degree, betweenness [33], and closeness centrality of node l respectively, and ${\omega }_{\kappa }+{\omega }_d+{\omega }_b+{\omega }_c=1$. Note that the hybrid score uses degree centrality $C_d\left(l\right)=\mathrm{deg}\left(l\right)/\left(\right|V|-1)$, a normalized quantity, rather than a raw degree, ensuring that all four components are comparable in scale before weighting.

The candidate set selects the top-$\min (N_{\max }^{ctrl},|V\left|\right)$ nodes ranked by $\varphi \left(l\right)$ in descending order as follows:

$$\mathcal{L}=\mathrm{Top}\text{-}\min (N_{\max }^{ctrl},\left|V\right|)\left(\varphi \left(l\right)\mid l\in V\right).$$

5.1.5. Distance-Sum

A controller placed at a node with a small total distance from all other nodes minimizes the average control-plane latency. For each candidate node $l\in V$, the distance-sum score is computed using single-source shortest-path lengths as follows:

$$\sigma \left(l\right)=\sum _{u\in V}d(l,u),$$

where $d(l,u)$ is the shortest-path distance between l and u in G. Nodes are then ranked by $\sigma \left(l\right)$ in ascending order, and the top-$N_{\max }^{ctrl}$ nodes with the smallest scores are selected:

$$\mathcal{L}=\mathrm{Top}\text{-}{N}_{\max }^{ctrl}\left(\mathrm{argmin}\sigma \left(l\right)\mid l\in V\right).$$

5.1.6. Greedy Coverage

This strategy iteratively selects the node that covers the largest number of uncovered nodes within a maximum distance threshold $d_0$, which is interpretable as the maximum acceptable propagation delay. For each candidate node $l\in V$, the coverage gain over the current uncovered set U is

$$\mathrm{gain}\left(l\right)=\left|\{u\in U\mid d(u,l)\le d_0\}\right|.$$

Starting from $U\leftarrow V$ and $\mathcal{L}\leftarrow \varnothing$, at each iteration, the node that maximizes the coverage gain is selected as

$$l^{*}=\arg \underset{l\in V\setminus \mathcal{L}}{\max }\mathrm{gain}\left(l\right),$$

and the uncovered set is updated accordingly:

$$\mathcal{L}\leftarrow \mathcal{L}\cup \left\{l^{*}\right\},U\leftarrow U\setminus \{u\in V\mid d(u,l^{*})\le d_0\}.$$

The procedure terminates when $\left|\mathcal{L}\right|=N_{\max }^{ctrl}$ or no further coverage gain is possible.

Algorithm 1 Candidate Controller Selection Strategies

Require: Graph $G=(V,E)$, desired number of candidate controllers $N_{\max }^{ctrl}$, distance function $d(·,·)$, coverage threshold $d_0$ Ensure: Candidate controller set $\mathcal{L}\subseteq V$ Strategy 1: Core-Only 1: Compute $\kappa \left(v\right)$ for each $v\in V$           ▹k-core decomposition [30] 2: $k\leftarrow {\kappa }^{\mathrm{start}}$,    $\mathcal{L}\leftarrow \varnothing$               ▹ default: ${\kappa }^{\mathrm{start}}={\max }_{v\in V}\kappa \left(v\right)$ 3: while  $k\ge 1$  and  $\left|\mathcal{L}\right|<N_{\max }^{ctrl}$  do 4:     $\mathcal{L}\leftarrow \mathcal{L}\cup \{v\in V\mid \kappa (v)\ge k\}$ 5:     $k\leftarrow k-1$ 6: end while 7: if  $\left|\mathcal{L}\right|>N_{\max }^{ctrl}$  then 8:     $\mathcal{L}\leftarrow \mathrm{Top}\text{-}{N}_{\max }^{ctrl}$ nodes in $\mathcal{L}$ ranked by $\left(\mathrm{deg}\right(v),\mathrm{id}(v\left)\right)$ descending 9: end if Strategy 2: Degree-Based 10: $\mathcal{L}\leftarrow \mathrm{Top}\text{-}\min (N_{\max }^{ctrl},|V\left|\right)$ nodes in V ranked by $\mathrm{deg}\left(v\right)$ descending Strategy 3: Distance-Sum 11: for each $v\in V$ do 12:     $\sigma \left(v\right)\leftarrow {\sum }_{u\in V}d(v,u)$            ▹ all-pairs hop count via BFS 13: end for 14: $\mathcal{L}\leftarrow \mathrm{Top}\text{-}{N}_{\max }^{ctrl}$ nodes in V ranked by $\sigma \left(v\right)$ ascending Strategy 4: Hybrid Centrality 15: Compute $C_d\left(v\right)$, $b\left(v\right)$ [33], $c\left(v\right)$, $\kappa \left(v\right)$ for each $v\in V$ 16: for each $v\in V$ do 17:     $\varphi \left(v\right)\leftarrow {\omega }_{\kappa }\kappa \left(v\right)+{\omega }_d{C}_d\left(v\right)+{\omega }_{b}b\left(v\right)+{\omega }_{c}c\left(v\right)$    ▹${\omega }_{\kappa }+{\omega }_d+{\omega }_b+{\omega }_c=1$ 18: end for 19: $\mathcal{L}\leftarrow \mathrm{Top}\text{-}\min (N_{\max }^{ctrl},|V\left|\right)$ nodes in V ranked by $\varphi \left(v\right)$ descending Strategy 5: Greedy Coverage 20: $U\leftarrow V$,    $\mathcal{L}\leftarrow \varnothing$ 21: while  $\left|\mathcal{L}\right|<N_{\max }^{ctrl}$do 22:     ${\ell }^{*}\leftarrow \arg {\max }_{\ell \in V\setminus \mathcal{L}}\left|\{u\in U\mid d(u,\ell )\le d_0\}\right|$ 23:     if no improvement possible then 24:         break 25:     end if 26:     $\mathcal{L}\leftarrow \mathcal{L}\cup \left\{{\ell }^{*}\right\}$ 27:     $U\leftarrow U\setminus \{u\in V\mid d(u,{\ell }^{*})\le d_0\}$ 28: end while

5.2. Complexity of Candidate Selection

Let $n=\left|V\right|$ and $m=\left|E\right|$ denote the number of nodes and edges of G respectively, and let $N_{\max }^{ctrl}$ denote the desired number of candidate controllers.

5.2.1. Core-Only: Complexity Analysis

The k-core decomposition is computed in $\mathcal{O}(n+m)$ using the peeling algorithm [30]. The accumulation loop iterates over at most ${\kappa }_{\max }$ core levels, where ${\kappa }_{\max }\le n$, and each iteration scans all nodes, yielding $\mathcal{O}({\kappa }_{\max }·n)$ in the worst case. In practice, ${\kappa }_{\max }\ll n$ for sparse networks; therefore, the dominant cost is reduced to $\mathcal{O}(n+m)$. The final trimming step ranks the nodes by $\left(\mathrm{deg}\right(v),\mathrm{id}(v\left)\right)$ and costs $\mathcal{O}\left(n\log n\right)$. Overall: $\mathcal{O}(n\log n+m)$.

5.2.2. Degree-Based: Complexity Analysis

The node degrees are computed in $\mathcal{O}\left(m\right)$ by scanning the edge list. Sorting $\min (N_{\max }^{ctrl},|V\left|\right)$ nodes by $\mathrm{deg}\left(v\right)$ costs $\mathcal{O}\left(n\log n\right)$. Overall: $\mathcal{O}(n\log n+m)$.

5.2.3. Hybrid Centrality: Complexity Analysis

The hybrid score $\varphi \left(v\right)$ aggregates four centrality measures. Degree centrality $C_d\left(v\right)$ costs $\mathcal{O}(n+m)$. Betweenness centrality $b\left(v\right)$ requires $\mathcal{O}(nm+n^2\log n)$ using Brandes’ algorithm [33]. Closeness centrality $c\left(v\right)$ requires one BFS per node, costing $\mathcal{O}\left(n\right(n+m\left)\right)$. k-core decomposition costs $\mathcal{O}(n+m)$. Score aggregation and sorting of $\min (N_{\max }^{ctrl},|V\left|\right)$ nodes cost $\mathcal{O}\left(n\log n\right)$. The bottleneck is betweenness centrality. Overall: $\mathcal{O}(nm+n^2\log n)$.

5.2.4. Distance-Sum: Complexity Analysis

Computing $\sigma \left(v\right)={\sum }_{u\in V}d(v,u)$ for a single node requires a Breadth-First Search (BFS) in $\mathcal{O}(n+m)$ for unweighted graphs, where $d(v,u)$ is the hop count. Repeating over all n nodes yields $\mathcal{O}\left(n\right(n+m\left)\right)$. Sorting the resulting scores results in a cost $\mathcal{O}\left(n\log n\right)$, which is dominated. Overall: $\mathcal{O}\left(n\right(n+m\left)\right)$.

5.2.5. Greedy Coverage: Complexity Analysis

At each of the $N_{\max }^{ctrl}$ iterations, the algorithm evaluates every remaining candidate $\ell \in V\setminus \mathcal{L}$ and counts how many uncovered nodes $u\in U$ satisfy $d(u,\ell )\le d_0$, where $d_0=1$ hop in the experiments. Assuming $d(·,·)$ is precomputed at cost $\mathcal{O}\left(n\right(n+m\left)\right)$ via BFS from all nodes, each coverage gain evaluation costs $\mathcal{O}\left(n\right)$, and each iteration scans at most n candidates. Therefore, the greedy loop costs $\mathcal{O}(N_{\max }^{ctrl}·n^2)$. The early termination condition, triggered when no further coverage gain is possible, may reduce the average number of iterations to below $N_{\max }^{ctrl}$ in practice. Overall (excluding pre-computation): $\mathcal{O}(N_{\max }^{ctrl}·n^2)$.

5.2.6. Overall Complexity of Candidate Selection

Table 2. Worst-case computational complexity of the candidate selection strategies.

Strategy	Complexity	Bottleneck
Core-Only	$\mathcal{O}(n\log n+m)$	Sorting
Degree-Based	$\mathcal{O}(n\log n+m)$	Sorting
Distance-Sum	$\mathcal{O}\left(n\right(n+m\left)\right)$	All-pairs BFS
Hybrid Centrality	$\mathcal{O}(nm+n^2\log n)$	Betweenness centrality
Greedy Coverage	$\mathcal{O}(N_{\max }^{ctrl}·n^2)$	Greedy selection loop

summarizes the time complexity of each selection strategy. The overall heuristic pipeline, selection followed by assignment, is dominated by the betweenness centrality computation in Strategy 4 ($\mathcal{O}(nm+n^2\log n)$), or by the all-pairs BFS required for Strategies 3 and 5 and the assignment phase ($\mathcal{O}\left(n\right(n+m\left)\right)$), both of which are computed once and shared across all downstream steps.

5.3. Switch Assignment Algorithm

The switch-to-controller assignment heuristic, detailed in Algorithm 2, operates in two successive steps. Given the candidate controller set $\mathcal{L}\subseteq V$ produced by Algorithm 1, each switch $s\in S$ must be assigned to at least $R_{\min }$ and at most $R_{\max }$ controllers, whereas no controller can serve more than $C_{\max }$ switches. A global feasibility check is first performed to verify that the available controller capacity is sufficient to satisfy the minimum redundancy requirement across all switches.

In the first step, each switch greedily selects its $R_{\min }$ closest available controllers, ensuring that the minimum redundancy constraint is satisfied for every switch.

In the second step, additional controllers are assigned up to $R_{\max }$, but only if the candidate controller falls within the objective-derived distance threshold:

$$d_{\max }={\displaystyle \frac{\alpha }{\delta }},$$

(13)

where $\alpha$ and $\delta$ are the objective weights defined in (12), associated with assignment coverage and distance penalty, respectively. Beyond $d_{\max }$, an additional assignment would incur a distance cost that outweighs the marginal coverage benefit, yielding a net negative contribution to the objective.

This two-phase structure separates feasibility from quality: the first step guarantees a valid assignment, whereas the second refines it under proximity and capacity constraints.

Algorithm 2 Heuristic Switch-to-Controller Assignment

Require: Candidate controller set $\mathcal{L}\subseteq V$, set of switches S, distance function $d(·,·)$, parameters $R_{\min }$, $R_{\max }$, $C_{\max }$, $\alpha$, $\delta$ Ensure: Assignment map $\mathcal{A}:S\to 2^{\mathcal{L}}$ Global Feasibility Check 1: if  $\left|S\right|·R_{\min }>\left|\mathcal{L}\right|·C_{\max }$  then 2:     raise Infeasibility error 3: end if 4: $\mathcal{A}\left(s\right)\leftarrow \varnothing$  for all  $s\in S$ 5: $\mathrm{load}(\ell )\leftarrow 0$  for all  $\ell \in \mathcal{L}$ Step 1: Minimum Redundancy Assignment ($R_{\min }$) 6: for each $s\in S$ do 7:     Sort $\mathcal{L}$ by $d(s,\ell )$ ascending $\to {\mathcal{L}}_s$ 8:     for each $\ell \in {\mathcal{L}}_s$ do 9:         if $\mathrm{load}(\ell )<C_{\max }$ then 10:            $\mathcal{A}\left(s\right)\leftarrow \mathcal{A}\left(s\right)\cup \{\ell \}$ 11:            $\mathrm{load}(\ell )\leftarrow \mathrm{load}(\ell )+1$ 12:         end if 13:         if $\left|\mathcal{A}\left(s\right)\right|=R_{\min }$ then 14:            break 15:         end if 16:     end for 17:     if $\left|\mathcal{A}\left(s\right)\right|<R_{\min }$ then 18:         raise Infeasibility error for switch s 19:     end if 20: end for Step 2: Extended Assignment up to $R_{\max }$ 21: $d_{\max }\leftarrow \alpha /\delta$ 22: for each $s\in S$ do 23:     while $\left|\mathcal{A}\left(s\right)\right|<R_{\max }$ do 24:         $\mathcal{C}\leftarrow \{\ell \in \mathcal{L}\mid \mathrm{load}(\ell )<C_{\max },\ell \notin \mathcal{A}\left(s\right)\}$ 25:         if $\mathcal{C}=\varnothing$ then 26:            break 27:         end if 28:         ${\ell }^{*}\leftarrow \arg {\min }_{\ell \in \mathcal{C}}d(s,\ell )$ 29:         if $d(s,{\ell }^{*})<d_{\max }$ then 30:            $\mathcal{A}\left(s\right)\leftarrow \mathcal{A}\left(s\right)\cup \left\{{\ell }^{*}\right\}$ 31:            $\mathrm{load}\left({\ell }^{*}\right)\leftarrow \mathrm{load}\left({\ell }^{*}\right)+1$ 32:         else 33:            break 34:         end if 35:     end while 36: end for 37: return  $\mathcal{A}$

5.4. Complexity Analysis of the Switch Assignment Heuristic

Let $n=\left|S\right|$ denote the number of switches and $p=\left|\mathcal{L}\right|$ be the number of placed controllers, with $p\le n$ in practice.

5.4.1. Global Feasibility Check

The condition $\left|S\right|·R_{\min }>\left|\mathcal{L}\right|·C_{\max }$ is evaluated in $\mathcal{O}\left(1\right)$.

5.4.2. Step 1: Minimum Redundancy Assignment

For each switch $s\in S$, the algorithm sorts the p controllers by $d(s,\ell )$, costing $\mathcal{O}\left(p\log p\right)$, then scans the sorted list until $R_{\min }$ controllers are assigned. Because $R_{\min }\le p$, the scan cost is at most $\mathcal{O}\left(p\right)$. Over all n switches:

$$\mathcal{O}(n·p\log p).$$

(14)

5.4.3. Step 2: Extended Assignment

For each switch $s\in S$, the while loop runs for at most $R_{\max }-R_{\min }$ iterations. At each iteration, the candidate set $\mathcal{C}$ is built by filtering $\mathcal{L}$ in $\mathcal{O}\left(p\right)$, and $\arg \min$ is computed in $\mathcal{O}\left(p\right)$. Each iteration therefore costs $\mathcal{O}\left(p\right)$. Over all n switches:

$$\mathcal{O}(n·(R_{\max }-R_{\min })·p).$$

(15)

Since $R_{\max }-R_{\min }\le p$ in the worst case, this is bounded by $\mathcal{O}(n·p^2)$, but in practice $R_{\max }-R_{\min }\ll p$, reducing it to $\mathcal{O}\left(np\right)$.

5.4.4. Overall Complexity

Step 1 dominates Step 2 when $(R_{\max }-R_{\min })\ll p\log p$, which holds in all practical configurations, where the redundancy bounds are small relative to the number of controllers.

$$\mathcal{O}(n·p\log p).$$

(16)

If $d(·,·)$ is precomputed via all-pairs BFS at cost $\mathcal{O}\left(n\right(n+m\left)\right)$, this constitutes the true bottleneck for sparse graphs where $p\log p\ll n+m$.

The complexity of each step of the switch assignment heuristic is summarized in

Table 3. Worst-case computational complexity of the switch assignment heuristic.

Step	Complexity	Condition
Feasibility check	$\mathcal{O}\left(1\right)$	—
Step 1: Minimum redundancy	$\mathcal{O}\left(np\log p\right)$	$(R_{\max }-R_{\min })\ll p\log p$
Step 2: Extended assignment	$\mathcal{O}\left(n(R_{\max }-R_{\min })p\right)$	$R_{\max }-R_{\min }\ll p$
Overall	$\mathcal{O}\left(np\log p\right)$	Precomputed $d(·,·)$

.

5.5. Overall Complexity of the Heuristic Framework

The overall two-phase heuristic, candidate selection followed by switch assignment, is dominated by the betweenness centrality computation in the hybrid strategy ($\mathcal{O}(nm+n^2\log n)$), or by the all-pairs BFS required for Distance-Sum, Greedy Coverage, and assignment phases ($\mathcal{O}\left(n\right(n+m\left)\right)$), whichever applies. Both are computed once and are shared across all downstream steps; therefore, the marginal cost of the assignment phase remains $\mathcal{O}\left(np\log p\right)$.

6. Numerical Results

The aim of the studies presented in this section is to assess the performance of the proposed heuristics relative to the exact ILP solution, using the optimality gap defined in (17) as the primary performance indicator. Each heuristic is named according to its controller placement strategy, whereas the assignment algorithm (Algorithm 2) is kept identical across all methods. Optimal solutions are obtained using the Gurobi solver. All numerical experiments are executed on a workstation equipped with a 13th Gen Intel^® Core™ i7-1355U × 12 processor and 16 GB of RAM.

The primary metric for solution quality is the optimality gap, defined as:

$$\Delta (\%)=\left|{\displaystyle \frac{z_{\mathrm{ILP}}^{\star }-z_{\mathrm{heuristic}}}{z_{\mathrm{ILP}}^{\star }}}\right|\times 100,$$

(17)

where $z_{\mathrm{ILP}}^{\star }$ is the optimal ILP objective value and $z_{\mathrm{heuristic}}$ is the value achieved by the heuristic. The four performance metrics evaluated across all studies are the optimality gap (17), solver time, average switch-to-controller path length, and average number of assignments per switch.

All experiments share a common set of fixed parameters, as summarized in

Table 4. Fixed simulation parameters.

Parameter	Value	Description
Objective weights
$\alpha$	15	Assignment coverage and resilience weight
$\beta$	10	Controller degree weight
$\gamma$	12	Controller core number weight
$\delta$	10	Distance penalty weight
Redundancy constraints
$R_{\min }$	2	Minimum controllers per switch
$R_{\max }$	4	Maximum controllers per switch
Strategy-specific
${\omega }_{\kappa },{\omega }_d,{\omega }_b,{\omega }_c$	$0.30,0.25,0.25,0.20$	Hybrid centrality scoring weights
$d_0$	1 hop	Coverage distance threshold

. The study-specific parameters, namely the controller capacity $C_{\max }$ and the maximum number of controllers $N_{\max }^{ctrl}$, are varied independently in each subsection and described therein.

6.1. Placement Philosophy: Coverage vs. Centrality

Before presenting the quantitative results, we illustrate the qualitative differences in placement behavior between the coverage-based strategy and the four centrality-based strategies. Figure 2 shows the controller placement produced by each heuristic on a representative random network instance, compared side by side with the exact ILP solution. In each row, the left panel shows the exact placement as a reference, and the right panel shows the heuristic placement. The red nodes are selected by both the exact and heuristic solutions, the green nodes are selected by the exact solution only, the orange nodes are selected by the heuristic only, and the blue nodes are regular switches.

Two distinct placement behaviors were observed. The core-only, degree-based, hybrid, and distance-sum strategies concentrate controllers in the densely connected central region of the network, producing placements that substantially overlap with the exact solution, as evidenced by the large proportion of red nodes. In contrast, the greedy coverage strategy scatters controllers across the periphery of the network, with very few nodes in common with the exact placement. This behavior is a direct consequence of the coverage objective: by greedily maximizing the number of one-hop neighbors covered at each step, the algorithm favors nodes that are spatially spread out rather than structurally central because peripheral nodes tend to cover disjoint neighborhoods.

Although this strategy may be appropriate in scenarios where geographic coverage is the primary concern, it is poorly suited to the joint placement and assignment objective defined in (12), which rewards topological centrality, proximity, and redundancy simultaneously. Therefore, the coverage strategy is retained in the comparison for completeness and to validate this design insight but is excluded from the main axis scaling of the performance figures that follow, where its outlier behavior would obscure the differences among the remaining strategies.

6.2. Heuristic vs. Exact Controller Placement

In this study, we compare the proposed heuristics with an exact ILP solution. To obtain statistically robust results, five independent instances are generated for each network type, each with 100 nodes and comparable number of edges. All metrics are reported as averages over these five instances. Representative examples are shown in Figure 3 and Figure 4.

Two network topologies are considered:

• Random network: Generated using the Erdős–Rényi model, with approximately 295 edges and three k-core levels ($\kappa \in \{1,3,4\}$), yielding a relatively flat structure (Figure 3).
• Multi-core network: Generated using a custom procedure designed to maximize hierarchical depth, with approximately 298 edges and seven k-core levels ($\kappa \in \{1,\dots ,7\}$), providing a markedly more hierarchical structure (Figure 4).

For all experiments in this subsection, the number of controllers is fixed at $N_{\max }^{ctrl}=16$, with the controller capacity $C_{\max }$ varying from 15 to 30. These values guarantee the feasibility with respect to the minimum assignment constraint ($R_{\min }=2$) and remain below the maximum value ($R_{\max }=4$). For 100 switches, the chosen $C_{\max }$ values correspond to a total assignment capacity ranging from approximately 240 to 480, comfortably covering the expected 200–400 assignments.

Figure 5 reports the optimality gap of each heuristic as a function of $C_{\max }$. Overall, all heuristics produce near-optimal solutions, with gaps decreasing as $C_{\max }$ increases. At $C_{\max }=15$, corresponding to a controller load slightly above the minimum feasibility threshold, multi-core networks already exhibit substantially lower gaps (6.7–8.5%) than random networks.

On random networks, a clear structure sensitivity effect is observed when increasing controller capacity. They exhibit a stronger relative improvement as $C_{\max }$ increases, with gaps decreasing rapidly and reaching approximately 2.4% for the hybrid, core-only, and degree-based heuristics at $C_{\max }=30$, while the distance-sum heuristic remains an outlier. Note that the core-only and degree-based curves overlap exactly in Figure 5, making the core-only curve visually indistinguishable. This performance becomes comparable to the best result observed in multi-core networks.

In contrast, multi-core networks maintain consistently low gaps across all capacity regimes, indicating that their hierarchical structure already guides the heuristics toward near-optimal solutions even under tighter constraints. Among all methods, the degree-based strategy consistently achieves the lowest gaps across all values of $C_{\max }$, reaching 1.9% at $C_{\max }=30$. This can be attributed to the alignment between node-level structural properties and the hierarchical topology of multi-core networks, which naturally favors high-quality placements.

Figure 6 shows the solver times as a function of $C_{\max }$. All heuristics complete in less than 1 ms, which is several orders of magnitude faster than the exact ILP, which requires approximately 140 ms on average and exceeds 3 s at $C_{\max }=15$ on the multi-core network, the configuration with the highest optimality gap, confirming that combinatorial difficulty correlates with both solution quality and solver effort. These results demonstrate that the heuristics achieve near-optimal solutions at a fraction of the computational cost.

Figure 7 shows the average switch-to-controller path length, which serves as a proxy for control-plane latency (Section 3). Multi-core networks consistently exhibit slightly longer average paths than random networks across all heuristics, which is a direct consequence of their hierarchical structure forcing switches in peripheral layers to reach controllers over longer paths. The exact solution yields the shortest paths on random networks, confirming its optimality. In multi-core networks, the exact solution produces slightly longer paths than in random networks, comparable to heuristics, reflecting the inherent topological cost of the hierarchical structure rather than any suboptimality.

Figure 8 reports the average number of controller assignments per switch, which directly reflects the resilience level achieved by each method. Multi-core networks consistently achieve higher average assignments than random networks, and the degree-based heuristic produces assignment levels closest to the exact solution across both topologies. Although $R_{\min }=2$ and $R_{\max }=4$, the observed averages remain in the range 2.2–2.6, indicating that capacity constraints prevent full redundancy for all switches simultaneously. This is consistent with the assignment algorithm’s design: Algorithm 2 prioritizes feasibility and capacity balance in Step 1, and only extends assignments in Step 2 when proximity and capacity conditions are jointly satisfied.

6.3. Effect of the Number of Controllers $N_{\max }^{ctrl}$

This study analyzes the impact of the maximum number of controllers $N_{\max }^{\mathrm{ctrl}}$ on the four performance metrics. The network size is fixed at 100 nodes, while $C_{\max }$ is varied such that $N_{\max }^{\mathrm{ctrl}}\times C_{\max }=400$, ensuring a constant total assignment budget of 400, corresponding to the maximum number of assignments $R_{\max }$ per switch.

Figure 9 shows the optimality gap as a function of $N_{\max }^{\mathrm{ctrl}}$. The gap exhibits a clear non-monotonic behavior, remaining low at both extremes of the controller budget and peaking at intermediate values. At $N_{\max }^{\mathrm{ctrl}}=2$, all strategies achieve gaps below 10% on both topologies, reflecting a strongly constrained regime in which limited placement options reduce the divergence between heuristic and ILP solutions. At higher budgets, $N_{\max }^{\mathrm{ctrl}}\in \{8,10,16\}$, gaps decrease again and remain mostly below 10%, as the increased redundancy in controller placement reduces the sensitivity of the objective to exact placement decisions. Between these regimes, gaps increase significantly. In random networks, this increase is highly pronounced, with core-only and degree-based methods peaking near 48% at $N_{\max }^{\mathrm{ctrl}}=4$, while distance-sum reaches approximately 74%, indicating a strong sensitivity of the heuristic to intermediate controller budgets. In multi-core networks, the same non-monotonic pattern is observed but with a lower amplitude, where core-only peaks above 33% at $N_{\max }^{\mathrm{ctrl}}=4$, and degree-based remains the most robust strategy at approximately 15%.

This pattern can be interpreted through three interaction regimes between topology and combinatorial complexity. At low controller budgets, the solution space is highly constrained, leading to similar decisions across heuristic and exact approaches. At intermediate budgets, placement decisions have maximal marginal impact: the problem is neither over- nor under-constrained, and locally driven heuristics are more likely to diverge from the global optimum identified by the ILP. At high budgets, the system becomes increasingly insensitive to the exact controller locations, which reduces performance differences between strategies.

Two additional structural observations emerge. Firstly, core-only and degree-based approaches yield identical gap values in random networks across all controller budgets, confirming that degree and coreness rankings largely coincide in this topology class. In multi-core networks, the two strategies diverge, with degree-based consistently achieving lower gaps, suggesting that local connectivity is a slightly more informative criterion than global coreness in hierarchical structures. Secondly, multi-core networks exhibit systematically higher and sharper gap peaks than random networks, highlighting that structured topologies amplify the difficulty of the intermediate regime where placement decisions have the strongest influence on performance.

Figure 10 shows that all heuristics are complete in under 1 ms across all values of $N_{\max }^{ctrl}$, with the exception of multi-core networks at $N_{\max }^{ctrl}=5$, which corresponds to the peak combinatorial difficulty identified above. The exact ILP exhibits a similar peak in solver time for the same configuration, corroborating the interpretation that the intermediate controller counts induce the most difficult instances.

Figure 11 shows that the average path length decreases monotonically with $N_{\max }^{ctrl}$, consistently across all heuristics and for both network types. This trend is intuitive: a larger number of deployed controllers reduces the average topological distance between any switch and its nearest controller, thereby directly improving control-plane latency.

Figure 12 shows that the average number of assignments per switch increases monotonically with $N_{\max }^{ctrl}$. A larger controller pool relaxes the capacity constraints, enabling Algorithm 2 to extend the assignments further in Step 2, thereby increasing the resilience. This confirms that $N_{\max }^{ctrl}$ is a key design parameter governing the trade-off between deployment cost and fault tolerance.

6.4. Scalability Analysis

This study evaluates the behavior of the heuristics as the network size $\left|V\right|$ increases from 50 to 500 nodes, with the exact ILP serving as the benchmark where tractable. To ensure structural consistency across scales, the number of k-core hierarchy levels grows logarithmically with $\left|V\right|$ as follows:

$$\mathrm{levels}=\lfloor 5+{\log }_2\left(\right|V\left|\right)\rfloor ,$$

(18)

subject to the feasibility condition

$${\displaystyle \sum _{\ell =1}^{\mathrm{levels}}}(\ell +1)\le \left|V\right|.$$

(19)

Edge density is controlled by scaling the edge factor as

$$\mathrm{edge}\text{\_}\mathrm{factor}=\mathrm{base}\text{\_}\mathrm{factor}·{\displaystyle \frac{\log \left(\right|V\left|\right)}{\log \left(n_{\mathrm{ref}}\right)}},$$

(20)

where $n_{\mathrm{ref}}=100$ and $\mathrm{base}\text{\_}\mathrm{factor}=0.6$, preserving a comparable sparsity across scales while maintaining the hierarchical k-core structure. The controller capacity is fixed at $C_{\max }=50$ and $N_{\max }^{ctrl}$ is scaled proportionally to $\left|V\right|$ to maintain a constant controller density. Ten independent instances per network type are generated for each scale to ensure statistical robustness.

Figure 13 shows the evolution of the optimality gap with network size. Across both topology types and all strategies, gaps remain generally below 20%, confirming that the proposed heuristics achieve near-optimal solutions at a fraction of the computational cost of the exact ILP. In random networks, core-only and degree-based strategies remain below 8%, hybrid reaches approximately 12%, and distance-sum stabilizes around 18% beyond 200 nodes. In multi-core networks, degree-based consistently achieves the lowest gap, remaining below 12% up to 500 nodes, while core-only, hybrid, and distance-sum remain in the 10–15% range at larger scales. Overall, both topology types exhibit similar gap profiles across most strategies, with the notable exception of distance-sum, which performs comparatively worse on random networks.

A closer examination of individual strategies reveals two structural phenomena. First, in random networks, core-only and degree-based strategies produce identical gap values at every scale, making their curves indistinguishable in the figure. This is a structural consequence rather than a numerical artifact: in random graphs, node degree and coreness become strongly correlated, leading to highly similar rankings of candidate nodes and therefore nearly identical placement decisions. The two metrics consequently carry largely redundant information in this topology class, causing both heuristics to converge toward the same controller placements. In multi-core networks, by contrast, the hierarchical structure introduces greater differentiation between local connectivity and global coreness, allowing the two strategies to select partially distinct candidate sets and resulting in progressively different gaps at larger scales.

Second, the optimality gap in multi-core networks exhibits a steeper increase at 500 nodes than in random networks. This behavior can be explained by the expansion of structurally prominent candidate nodes in hierarchical topologies, which enlarges the decision space available to the ILP. The heuristic, however, remains guided by local selection rules and therefore becomes less competitive as the candidate space grows. In random networks, the absence of strong hierarchical organization limits this expansion, resulting in a more stable relative performance. Overall, these observations indicate that the optimality gap depends not only on network size but also on the interaction between topological structure and locality-driven decision rules.

Figure 14 shows that all heuristics remain highly efficient, with execution times below 10 ms even at 500 nodes, whereas the exact ILP exceeds 10 s for the largest instances and becomes computationally prohibitive beyond 200–300 nodes.

In a static planning context, where controller placement is decided once at the network design time, a solver time of a few seconds may be acceptable, and the computational advantage of heuristics is less critical. However, solver time is a decisive factor in three practically relevant scenarios. Firstly, in failure-driven reconfiguration: when a controller becomes unavailable and placement must be recomputed to restore the required redundancy level $R_{\min }$, the reconfiguration latency directly affects service continuity and the duration of the resilience degradation window. Secondly, in dynamically evolving networks such as data center fabrics or campus SDN infrastructures, topology changes such as node additions, link failures, or traffic-driven reconfigurations occur frequently and trigger repeated re-optimization. Thirdly, in large-scale planning studies requiring the evaluation of many configurations, such as sensitivity analyses over objective weights $(\alpha ,\beta ,\gamma ,\delta )$ or topology parameters, the ILP must be solved hundreds or thousands of times, making its per-instance cost prohibitive even when a single run is acceptable. In all three scenarios, the proposed heuristics provide a tractable alternative that scales gracefully with the network size while maintaining near-optimal solution quality.

Figure 15 presents the average path length as a function of the network size. In multi-core networks, the path length increases with $\left|V\right|$, reflecting a deeper hierarchical structure: as the number of k-core levels increases, switches in peripheral layers must traverse progressively longer paths to reach controllers in the inner core. This growth in path length also contributes to the widening optimality gap observed in Figure 13 because heuristics place controllers further from the optimal positions at larger scales. In contrast, random networks exhibit a stable average path length of approximately 1.6 regardless of $\left|V\right|$, which is consistent with their flat k-core structure and the small-world property of Erdős–Rényi graphs at the considered density.

Figure 16 shows that multi-core networks achieve higher average assignments overall, but exhibit a slight decreasing trend with $\left|V\right|$. As the network size and path lengths increase, additional assignments become less beneficial relative to their distance cost, and the threshold $d_{\max }$ (13) increasingly rejects distant candidates in Step 2 of Algorithm 2. Random networks maintain a nearly constant assignment level close to $R_{\min }=2$, reflecting their limited structural depth and the correspondingly low incentive for additional redundancy under Objective (12).

7. Conclusions and Future Work

This paper proposed a joint optimization framework for controller placement and switch assignment in resilient SDNs, formulated as a multi-objective ILP integrating topological centrality, latency, load balancing, and redundancy constraints. A two-phase heuristic framework was developed to overcome the computational limitations of exact optimization, combining topology-aware candidate selection with a capacity-driven assignment algorithm that guarantees per-switch redundancy by construction.

Experiments on random and hierarchical multi-core networks demonstrate near-optimal solutions with optimality gaps below 10%, runtimes under 10 ms enabling near real-time reconfiguration, and confirm that hierarchical k-core topologies significantly improve heuristic solution quality by reducing placement symmetry. The degree-based strategy consistently achieves the best trade-off between quality and simplicity.

Future work includes evaluating a heuristic-restricted ILP mode, extending the framework to dynamic environments with time-varying traffic particularly for IoT, VANETs, and satellite networks, and incorporating heterogeneous link capacities for broader practical applicability.