SmartFLow: A Communication-Efficient SDN Framework for Cross-Silo Federated Learning

TL;DR

SmartFLow is an SDN-based framework that dynamically optimizes network routing to significantly reduce communication latency in cross-silo federated learning, enhancing training efficiency and scalability.

Contribution

It introduces a novel SDN-driven routing adjustment method that adapts to network conditions, improving communication efficiency in federated learning environments.

Findings

Reduces synchronization time by up to 47%.

Scales effectively to 50 clients with minimal overhead.

Outperforms traditional routing methods in latency reduction.

Abstract

Cross-silo Federated Learning (FL) enables multiple institutions to collaboratively train machine learning models while preserving data privacy. In such settings, clients repeatedly exchange model weights with a central server, making the overall training time highly sensitive to network performance. However, conventional routing methods often fail to prevent congestion, leading to increased communication latency and prolonged training. Software-Defined Networking (SDN), which provides centralized and programmable control over network resources, offers a promising way to address this limitation. To this end, we propose SmartFLow, an SDN-based framework designed to enhance communication efficiency in cross-silo FL. SmartFLow dynamically adjusts routing paths in response to changing network conditions, thereby reducing congestion and improving synchronization efficiency. Experimental results show that SmartFLow decreases parameter synchronization time by up to 47% compared to shortest-path routing and 41% compared to capacity-aware routing. Furthermore, it achieves these gains with minimal computational overhead and scales effectively to networks of up to 50 clients, demonstrating its practicality for real-world FL deployments.

Tables

Table 1. TABLE I : Information stored in Client Store and Link Store for client-flows and active-links characteristics

Client Store Metrics
S2C/C2S Paths	K-shortest paths between client and server
Current S2C/C2S Path	Current route of a S2C/C2S flow
Current Recv/Send Rate	Current rate of a flow (Mbps)
Round Sent/Recv Data	Downloaded or uploaded data / round (MB)
Link Store Metrics
Default Capacity	Base capacity of the link (Mbps)
Current Throughput	Instantaneous traffic rate on the link (Mbps)
S2C/C2S Clients	Clients downloding/uploading data
Packet Loss	Measured packet loss rate in the link
Latency	Measured one-way delay of the link (ms)

Table 2. TABLE II : Comprehensive comparison of the RFWD baseline, FreeCap , and the proposed solutions S ​ m ​ a ​ r ​ t ​ F ​ L ​ o ​ w C ​ P SmartFLow_{CP} and S ​ m ​ a ​ r ​ t ​ F ​ L ​ o ​ w G ​ r ​ e ​ e ​ d ​ y SmartFLow_{Greedy} across three network setups. Metrics are divided into two categories, training-time metrics and network-stability metrics. Lower values indicate better performance, reflecting improved training speed and enhanced network stability.

Metric	Topology $E1$				Topology $E2$				Topology $E3$
	(15 switches, 15 clients)				(30 switches, 25 clients)				(50 switches, 50 clients)
	$RFWD$	$FreeCap$	$S{F}_{Greedy}$	$S{F}_{CP}$	$RFWD$	$FreeCap$	$S{F}_{Greedy}$	$S{F}_{CP}$	$RFWD$	$FreeCap$	$S{F}_{Greedy}$	$S{F}_{CP}$
Time to 60% Acc (min)	12.4	11.7	8.2	7.7	20.0	19.7	10.5	10.7	42.2	29.7	20.0	21.0
Time to 80% Acc (min)	37.2	33.5	22	21	56.0	50.7	29.6	32.1	118.3	89.5	67.7	65
Avg Round Time (sec)	53.1	46.8	32.9	32.1	67	60.8	35.6	38.5	94.6	71.6	54	52
S2C Path Reassignments	0	0	0	0	0	0	12	10	0	0	85	70
C2S Path Reassignments	0	0	0	0	0	0	30	23	0	0	119	90
gRPC Timeouts	83	42	12	7	129	94	9	15	797	651	150	143

Equations

$${\text{RTT}}_p=\sum _{l\in {\mathcal{L}}_p}\left({\text{lat}}_{l,\text{forward}}+{\text{lat}}_{l,\text{reverse}}\right).$$

$${\text{PacketLoss}}_p=1-\prod _{l\in {\mathcal{L}}_p}(1-{\text{ploss}}_l),$$

$${\text{AdjRTT}}_p={\text{RTT}}_p\cdot \sqrt{{\text{PacketLoss}}_p+ϵ},$$

$$\sum _{p\in {\mathcal{P}}_c}{x}_{c,p}=1,\forall c.$$

$${\text{ActiveFlows}}_l=\sum _c\sum _{p\in {\mathcal{P}}_c:l\in {\mathcal{L}}_p}{x}_{c,p}.$$

$${\text{FlowCap}}_{l,p}=\frac{{\text{cap}}_l}{{\text{ActiveFlows}}_l}.$$

$${\text{Throughput}}_{c,p}=\underset{l\in {\mathcal{L}}_p}{\min }\left(\frac{{\text{cap}}_l}{{\text{AdjRTT}}_p}\right).$$

$${\text{CompletionTime}}_{c,p}=\frac{D_c}{{\text{Throughput}}_{c,p}}.$$

$$T=\underset{c,p\in {\mathcal{P}}_c}{\max }\left(\frac{D_c}{{\text{Throughput}}_{c,p}}\cdot x_{c,p}\right).$$

$$\min T.$$

$$S_{\text{max}}(c)=\underset{p\in {\mathcal{P}}_c}{\max }S(p).$$

$$c_1,c_2,\dots ,c_n\text{such that}{S}_{\text{max}}(c_1)\le \cdots \le S_{\text{max}}(c_n).$$

$$x^{\prime }=\frac{x-x_{\text{min}}}{x_{\text{max}}-x_{\text{min}}},$$

$$x_{\text{min}}=\underset{p\in {\mathcal{P}}_c}{\min }S(p),x_{\text{max}}=\underset{p\in {\mathcal{P}}_c}{\max }S(p).$$

Full text

I Introduction and Motivation

In modern distributed computing, communication efficiency has overtaken processing power as the main performance bottleneck [1]. Hardware improvements have reduced local computational delays in Machine Learning (ML), but network constraints remain a major challenge, especially in federated learning (FL), where clients collaboratively train a shared model without sharing raw data. Each client updates the model using private data and periodically sends parameters to a central server, which aggregates them into a global model. While FL enhances privacy, it incurs high communication costs due to frequent transmission of large parameter sets over often unreliable networks [2, 3].

These issues intensify in cross-silo FL, where geographically distributed organizations rely on wide-area networks. Unlike centralized ML, which benefits from robust cloud infrastructure, cross-silo FL suffers from high latency, limited bandwidth, and routing inefficiencies that impair scalability [4, 5]. As shown in Figure 1, training a MobileNet Large v3 model [6] across 15 clients on a synthetic Gabriel graph topology [7] revealed communication as the dominant factor in total training time. Uneven network conditions also delay some clients disproportionately, creating synchronization bottlenecks in synchronous FL. These delays reduce efficiency and slow convergence, underscoring the need to mitigate network-related constraints.

To address these network-centric challenges, Software-Defined Networking (SDN) offers a promising solution. SDN decouples network control from data forwarding, allowing centralized and programmable network management. By providing a global network view, SDN supports dynamic routing decisions, real-time monitoring, and proactive congestion control. These capabilities align closely with the centralized coordination inherent to FL, facilitating adaptive communication strategies tailored specifically to training requirements. SDN-based traffic engineering dynamically allocates network resources, effectively reducing latency, mitigating congestion, and efficiently utilizing bandwidth [8].

In this paper, we propose SmartFLow, an SDN-integrated federated learning framework designed to enhance communication efficiency in cross-silo scenarios. By leveraging real-time network state information, SmartFLow optimizes client-server communication during training sessions. This approach reduces communication delays, alleviates network congestion, and mitigates synchronization issues commonly observed in FL deployments. Additionally, SmartFLow complements existing FL optimization techniques, such as parameter compression [9], quantization [10], and selective updates [11], broadening its applicability across various FL settings. Experimental evaluations demonstrate that SmartFLow significantly reduces overall training time, achieving up to 47% improvement compared to other routing approaches.

II Related Work

Research on the integration of SDN and federated learning is still in its early stages. Ma et al. [12] conducted a comprehensive survey outlining key challenges in SDN-based FL environments, such as incentive design, privacy concerns, and efficient model aggregation. Mahmod et al. [13] proposed an SDN-enabled approach tailored for time-sensitive FL applications, using dynamic network adaptation to reduce communication delays by mitigating overload conditions. Other efforts, such as those by Sabah et al. [14], focused on reducing communication overhead through methods like model compression, client selection, and asynchronous updates. Similarly, Konečný et al. [15] introduced techniques such as structured updates and sketching to reduce uplink costs. However, these studies either omit SDN altogether or do not address network-layer inefficiencies like latency and congestion.

Our work complements and extends these contributions by emphasizing dynamic routing optimization as a central mechanism. While prior approaches mainly address communication at the protocol or model level, they do not fully exploit SDN’s capabilities for real-time network adaptation. By introducing SDN-enabled routing strategies, our framework targets latency reduction and improved scalability, directly addressing communication bottlenecks in cross-silo FL systems and filling a critical gap in the current literature.

III System Overview

We implemented SmartFLow within the SDN ONOS controller [16], using two data stores and three services to monitor network status and make routing decisions. The Stats Parser processes OpenFlow statistics and updates the Client Store, which holds dynamic, client-specific routing and traffic metrics, and the Link Store, which captures performance and load conditions across network links. The Flow Scheduler uses information from both stores to select efficient paths for each client and adjusts them as conditions change. It operates in coordination with the Progress Tracker, which monitors data transfers and signals when updates complete. Figure 2 shows the system architecture. The implementation is available as open-source at [17].

III-A Stats Parser

The Stats Parser periodically collects and analyzes OpenFlow statistics from network devices to optimize utilization and enhance active flows. Collected metrics include port statistics for link congestion assessment and flow statistics to estimate throughput per flow. This allows SmartFLow to track FL client and server progress in transmitting model weights relative to the model size. By default, the SDN server polls these statistics from each client’s edge switch every five seconds.

This service includes a subcomponent that monitors one-way link delays and packet losses using Metter’s method [18]. It dispatches 10 Ethernet probe packets per link every second, each containing a link ID, sequence number, and timestamp. The controller computes one-way delays based on transmission, propagation, processing, and queuing times, using packet timestamps and arrival times. Packet loss rates, calculated over a sliding window of the last 100 probes, equal one minus the reception rate. These metrics are stored in the Link Store, while the service runs efficiently in the background.

III-B Client and Link Stores

The Client Store maintains client-specific data, as summarized in TABLE I. Upon client joining, the system calculates the K-shortest server-to-client (S2C) and client-to-server (C2S) paths using ONOS’s routing functionality, storing them for future use. The parameter $K$ is configurable based on network topology size. The store also tracks active paths adjusted by the Flow Scheduler, monitors real-time throughput, and records data transfer volume per training round.

The Link Store maintains detailed link statistics, including Default Capacity and Current Throughput. It identifies active client sets for C2S and S2C communications, informing potential rerouting impacts. Crucial metrics such as Packet Loss and Link Latency, affecting TCP efficiency [19], are tracked. To maintain stability despite measurement fluctuations, the store uses weighted averages of the three most recent latency and loss values.

III-C Flow Scheduler

The Flow Scheduler is a core component of SmartFLow, responsible for managing path assignments in C2S and S2C communications. In S2C, the server broadcasts model weights to all clients simultaneously, whereas in C2S, each client uploads its updated model independently after completing local training. Despite this directional difference, both follow the same general scheduling process. In synchronous federated learning, the server must wait for all clients to finish uploading before proceeding to the next round [20]. The overall workflow of the Flow Scheduler is defined in Algorithm 1.

At the start of each training round, the scheduler enqueues clients to the Phase 1 queue ($Q_{p1}$) from the waiting queue ($Q_{wait}$), initiating Phase 1. In this phase, it retrieves each client’s precomputed K-shortest paths from the Client Store and selects the optimal path using a user-defined path selection strategy ($PSS$). Upon assignment, clients are enqueued to the Phase 2 queue ($Q_{p2}$). The scheduler then schedules Phase 2 to execute asynchronously after a configurable delay $S$ (default: five seconds), and returns to its main loop to monitor $Q_{wait}$ for newly arrived flows. Once the delay elapses, Phase 2 is triggered to process clients in $Q_{p2}$. In this phase, the scheduler updates client progress using metrics from the Client Store and estimates completion times based on current throughput. Clients that complete their transfers are marked Done, while those still in progress may re-enter $Q_{p1}$ for potential path reassignment if improved routes become available. Otherwise, they continue to Phase 2 until their transmissions conclude.

We implemented two $PSS$ variants, Constraint Optimization and Greedy, to showcase the flexibility of the framework. Although these serve as concrete examples, the system is designed to support any decision-making model. For instance, reinforcement learning can be integrated directly into the scheduling process without requiring any modifications to the core system.

IV Path Selection and Switching Strategies

IV-A Constraint Optimization Model

In this model, path assignment for weight communication is formulated as an optimization problem, aiming to minimize the longest completion time among all clients receiving model weights from the FL server. This objective is particularly important in synchronous FL, where the next training round cannot begin until every client completes the weight exchange.

High latency increases RTT, which slows the growth of TCP’s congestion window, while packet loss leads to retransmissions and reduced throughput due to window backoff mechanisms [19]. These effects become more pronounced when multiple flows compete over congested links, reducing per-flow bandwidth and further extending transfer times. Effective path selection, therefore, must consider not only available capacity but also the compounded impact of latency and loss on performance.

The constraint optimization model accounts for these factors explicitly, allowing the scheduler to assign paths that minimize bottlenecks and maintain consistency across the network. For each client, it retrieves candidate paths from the Client Store and gathers link-specific metrics from the Link Store, ensuring that decisions are guided by both topology and real-time conditions.

For every candidate path $p$, defined as a sequence of directed links $\mathcal{L}_{p}$, we compute the effective RTT by summing the one-way delay of each link in both the forward direction for data transmission and the reverse direction for acknowledgments:

[TABLE]

The end-to-end packet loss for path $p$ is calculated under the assumption of independent link failures:

[TABLE]

where $\text{ploss}_{l}$ denotes the packet loss probability of link $l$.

TCP Cubic has been the default congestion control algorithm in the Linux kernel since version 2.6.19 [21]. It is also the default in Windows and Apple’s operating systems [22]. Compared to TCP Reno [23], Cubic reacts less aggressively to packet loss, yet throughput still degrades when losses occur. To approximate this effect, we adjust RTT by scaling it with the square root of the packet loss rate, providing a tractable estimation of its impact on flow completion time [24]:

[TABLE]

where $\epsilon$ is a small constant for numerical stability.

To model path assignments, we define binary decision variables $x_{c,p}\in\{0,1\}$, indicating whether path $p$ is assigned to client $c$. Each client must select exactly one path:

[TABLE]

To model link utilization, we introduce the variable $\text{ActiveFlows}_{l}$, representing the number of active client flows traversing link $l$:

[TABLE]

Given $\text{cap}_{l}$ as the estimated available capacity of link $l$, the per-flow capacity along link $l$ becomes:

[TABLE]

A client’s throughput on path $p$ is determined by the bottleneck link along that path, considering both capacity and latency penalties:

[TABLE]

The remaining data volume to be transmitted for each client $c$ is denoted as $D_{c}$, which may vary across clients. The completion time for client $c$ using path $p$ is:

[TABLE]

To model the worst-case scenario, we define a bottleneck variable $T$ as the maximum completion time over all clients and their selected paths:

[TABLE]

The optimization objective is to minimize the maximum completion time:

[TABLE]

Using this model, ComputePaths processes all clients concurrently, generating a new map that assigns each client to its optimal path based on the available candidates. SmartFLow then installs the corresponding flow rules on the network switches along the selected routes. To maintain stability, SwitchPaths updates a client’s path only if two conditions are met: the recommended path differs from the current one, and at least two OpenFlow statistics polling intervals have elapsed since the last change. This conservative strategy reduces unnecessary switching, preserves measurement accuracy, and prevents disruptive oscillations in the network.

We implement this model using Google’s CP-SAT solver [25], a constraint programming (CP) solver based on satisfiability (SAT) techniques. It exhaustively searches all feasible solutions, guaranteeing globally optimal results under defined constraints. Our implementation uses the OR-Tools Java API, version 9.12.

IV-B Greedy Model

Although the CP model offers globally optimal solutions, its computational cost scales poorly with network size, which can limit its practicality in larger deployments. To address this, we implement a Greedy PSS, a more efficient alternative that makes locally optimal decisions at each step. While it does not ensure a global optimum, it delivers solid approximations with significantly lower overhead, making it well-suited for federated learning environments.

For each client $c$, the algorithm considers a set of $K$-shortest candidate paths $\mathcal{P}_{c}=\{p_{1},p_{2},\dots,p_{K}\}$. Each path $p\in\mathcal{P}_{c}$ is assigned a score $S(p)$, reflecting its expected performance based on available capacity, active flows, and latency penalties, computed similarly to the throughput formulation in equation (7).

To prioritize clients effectively, the algorithm first computes the best available path score for each client:

[TABLE]

The clients are then sorted in ascending order of their $S_{\text{max}}(c)$ values:

[TABLE]

This sorting ensures that clients with weaker path options are prioritized, securing the best possible paths before network resources become saturated.

For each candidate path, we normalize the scores using min-max normalization to ensure fair comparisons across different metrics:

[TABLE]

where:

[TABLE]

In ComputePaths, the model processes clients one at a time, selecting for each the candidate path with the highest normalized score. SmartFLow then installs the corresponding flow rules along the selected path in the network. To prevent instability, SwitchPaths triggers only when the new path offers at least a 30% improvement in score and two OpenFlow polling intervals have passed since the last change.

V Experimental Results

We evaluate two variations of SmartFLow that explore different flow scheduling strategies. The first, $SmartFLow_{CP}$, uses the CP model for S2C communication to enable globally coordinated updates, and the Greedy model for C2S communication to match the clients’ asynchronous behavior. The second, $SmartFLow_{Greedy}$, applies the Greedy model to both S2C and C2S, offering a fully lightweight option with minimal scheduling overhead. We benchmark both $SmartFLow_{CP}$ and $SmartFLow_{Greedy}$ against the reactive forwarding method (RFWD), which uses the built-in shortest-path algorithm of ONOS, and FreeCap [13], which forwards traffic through the path with the freest bottleneck link capacity.

V-A Testbed

To evaluate our approach, we built a modular testbed that emulates diverse network scenarios with varying complexity, topology, traffic patterns, and numbers of FL clients. It comprises three components, Topology Creator, Congestion Simulator, and Experiment Runner, coordinated by a central module for streamlined configuration. The testbed supports customizable topologies via the TopoHub repository, emulates congestion with containerized iperf3 flows, and tracks real-time training and network metrics through an automated FL pipeline. For more details about the testbed, check [26].

V-B Experiments

We evaluated our solution on Gabriel network topologies of varying complexity, client count, and traffic. We used three topologies from Topohub [27]: $E1$ (15 nodes, 9 variations, 15 FL clients), $E2$ (30 nodes, 7 variations, 25 clients), and $E3$ (50 nodes, 8 variations, 50 clients). Federated training used Flower AI [28] with PyTorch [29], exchanging model updates over gRPC. To simulate congestion, we deployed iperf3 servers and clients in containers at both ends of each link, generating sequential TCP flows based on a Poisson distribution $X\sim\text{Poisson}(\lambda)$, where $\lambda$ reflects the ECMP utilization from the Topohub configs file.

We trained on the CIFAR-10 dataset [30] with centralized evaluation at the server. We deliberately used a single model and dataset, as the model size, being the dominant factor in data exchange per round, has a greater impact on network performance than the specific architecture or dataset. Training spanned 40 rounds for $E1$, 50 for $E2$, and 75 for $E3$, with one local epoch per round. To ensure fair comparison, the number of stored K-shortest paths in the Client Store was capped at 10, 15, and 25 for $E1$, $E2$, and $E3$, respectively.

TABLE II summarizes the performance across evaluated metrics, grouped into two categories: (1) training-time metrics, including the time to reach 60% and 80% accuracy and average round time, and (2) network-stability metrics, including S2C and C2S path reassignments and gRPC timeouts. Path reassignments measure the frequency of route updates, impacting network stability if excessive. Similarly, gRPC timeouts, arising from request delays, degrade training efficiency and system reliability if frequent.

In topology $E1$, SmartFLow significantly outperformed RFWD and FreeCap in training-time metrics. $SmartFLow_{CP}$ reached 80% accuracy in 21 minutes, representing a 43% improvement over RFWD and 37% over FreeCap. Average round time dropped to 32 seconds, compared to 53 seconds for RFWD and 46.8 seconds for FreeCap. Compared to $SmartFLow_{Greedy}$, $SmartFLow_{CP}$ achieved a modest improvement of approximately 5%. Network stability also improved significantly, with only 7 gRPC timeouts, an 83% reduction relative to FreeCap.

In the more complex topology $E2$, the advantages became clearer. $SmartFLow_{Greedy}$ reached 80% accuracy in 29.6 minutes, representing a notable reduction of 47% and 41.5% compared to RFWD and FreeCap, respectively. Average round time decreased notably to 35 seconds, down from 67 seconds with RFWD and 60 seconds with FreeCap. Network stability remained robust, with fewer path reassignments, 42 for $SmartFLow_{Greedy}$ and 33 for $SmartFLow_{CP}$, and substantially fewer gRPC timeouts: 9 for $SmartFLow_{Greedy}$ and 15 for $SmartFLow_{CP}$, compared to 94 for FreeCap and 129 for RFWD.

With topology $E3$ nearly double the size of $E2$, complexity grew significantly. Nevertheless, $SmartFLow_{CP}$ reached the target accuracy in 65 minutes, reducing training time by 45% compared to RFWD and by 27% compared to FreeCap. The average round time also improved notably, dropping to 52 seconds for $SmartFLow_{CP}$ and 54 seconds for $SmartFLow_{Greedy}$, whereas FreeCap required 71 seconds per round. Although the larger scale led to more frequent path reassignments, network reliability improved substantially. The number of gRPC timeouts dropped to 143, representing an 82% reduction relative to RFWD.

While $SmartFLow_{CP}$ consistently outperformed the baselines, its advantage over $SmartFLow_{Greedy}$ depended on network size and dynamics. In $E1$, the small network let $SmartFLow_{CP}$ compute optimal paths quickly, giving it a slight edge. In $E2$, the increased dynamics favored $SmartFLow_{Greedy}$, whose fast, low-overhead updates outpaced $SmartFLow_{CP}$ ’s slower route computations. In $E3$, $SmartFLow_{CP}$ ’s global optimization had a stronger impact, as the benefits of better paths outweighed its initial delays. Overall, $SmartFLow_{CP}$ is better for large, complex networks where path quality matters, while $SmartFLow_{Greedy}$ is better for fast-changing or resource-limited environments.

Figure 3 compares the computational overhead of $SmartFLow_{Greedy}$ and $SmartFLow_{CP}$ during Phases 1 and 2 across topologies $E1$–$E3$. In $E1$, $SmartFLow_{Greedy}$ stayed near 10 ms, while $SmartFLow_{CP}$ was higher at  35 ms. In $E2$, overhead grew to  15 ms for $SmartFLow_{Greedy}$ and  90 ms for $SmartFLow_{CP}$, with spikes near 100 ms. Under the most demanding $E3$, $SmartFLow_{Greedy}$ reached  40 ms, whereas $SmartFLow_{CP}$ averaged 200 ms and peaked at 400 ms. These results underscore $SmartFLow_{CP}$ ’s scalability issues and $SmartFLow_{Greedy}$ ’s ability to maintain low overhead.

VI conclusion

In this paper, we address communication inefficiencies in cross-silo FL, mainly caused by network congestion and client stragglers, which limit training performance and system scalability. To tackle this, we propose SmartFLow, an SDN-integrated framework that dynamically optimizes client-server communication paths based on real-time network conditions. By carefully balancing network utilization and stability, SmartFLow reduces communication time by up to 47% compared to existing routing methods, with minimal overhead. This efficiency makes it suitable for practical deployment in large-scale and heterogeneous FL topologies, overcoming critical bottlenecks in real-world systems.