FedDCS: Semi-Asynchronous Federated Learning Optimization Based on Dynamic Client Selection

Abstract

Federated Learning (FL) represents a promising paradigm for collaborative model training across numerous devices, preserving data locality and offering potential privacy benefits for industries such as finance, healthcare, and Internet of Things (IoT). Nonetheless, real-world deployments of FL encounter challenges arising from dynamic and diverse environments, which adversely affect training speed and model convergence. To address these issues, this paper introduces FedDCS, an adaptive federated learning framework that effectively manages resources during training through two primary innovations. First, it establishes a reliable method for predicting client training durations, estimating completion times while filtering noise and detecting performance variations. Second, it implements a two-stage adaptive waiting strategy that dynamically determines the optimal timing and selection of client batches for aggregation, thereby balancing collection efficiency with model accuracy. This approach optimizes the trade-off between efficiency and accuracy in heterogeneous settings. Extensive evaluations on datasets such as Fashion-MNIST and CIFAR-10/100, incorporating simulated device and data heterogeneity, demonstrate that FedDCS consistently achieves superior time efficiency and higher global model accuracy compared to state-of-the-art (e.g., synchronous, asynchronous, and semi-asynchronous) baselines. Its robustness and versatility render it effective across various complex and heterogeneous environments.

1. Introduction

Amid increasingly stringent data privacy regulations and the exponential growth of data generated at the network edge, Federated Learning (FL) has emerged as a successful and promising distributed machine learning paradigm [1]. It enables multiple clients to collaboratively train a global machine learning model while keeping all raw data localized. By updating model parameters instead of raw datasets, FL preserves data privacy and effectively leverages the computational resources of each client. It offers viable, practical technical pathways for deploying artificial intelligence in privacy-sensitive domains, such as finance, healthcare, and Internet of Things (IoT).

To satisfy the dual demands of efficiency and system performance in practical deployments, FL has evolved through distinct training paradigms. The synchronous paradigm [1,2,3,4,5] ensures stable client model updates but suffers from the straggler problem and low resource utilization. Conversely, the asynchronous paradigm [6,7,8,9] maximizes hardware utilization but risks model instability due to stale updates. To balance these extremes, semi-asynchronous paradigms [10,11,12,13] have emerged as a promising middle ground, employing mechanisms like server-side buffering to aggregate a subset of timely updates, thereby mitigating the key limitations of both extremes.

However, the system performance of FL is fundamentally limited by two intertwined challenges. First, device heterogeneity [14]—stemming from diverse device capabilities and unstable networks—creates the straggler problem and volatile client availability, crippling time efficiency. Second, data heterogeneity [15] inherent in distributed sources leads to non-IID client data, which biases local client training, impedes global model convergence, and degrades final model accuracy.

In addition, common semi-asynchronous methods typically rely on static aggregation policies, such as fixed buffer sizes [16]. The rigidity cannot adapt to the dynamic environments described above: a high threshold reverts the method to inefficient synchronous waiting, while a low threshold exposes it to the instability of asynchronous updates. Consequently, the absence of an adaptive FL strategy that dynamically responds to real-time system and data states remains a pivotal gap, limiting the robustness and performance of FL in real-world heterogeneous settings.

To this end, this paper proposes FedDCS, a semi-asynchronous FL framework designed to dynamically adapt to the evolving training environment. It develops efficient, predictive, server-side orchestration strategies for real-time aggregation decisions that balance efficiency and robustness across device and data heterogeneity. Our contributions are summarized as follows:

• We propose an adaptive method for predicting client completion times to optimize aggregation scheduling. This approach uses a refined exponential smoothing prediction model, with key innovations including outlier filtering and change-point detection. This combined design offers robust predictions that are resistant to outlier interference while maintaining continuous adaptability to dynamic environmental changes.
• We propose a two-stage waiting mechanism grounded in the prediction of client completion times. Building upon adaptive prediction techniques, the server orchestrates the aggregation process dynamically. It intelligently adjusts the waiting time across two distinct stages, thereby optimizing the trade-off between the number of aggregated client updates and the overall aggregation duration. This design allows FedDCS to independently balance time efficiency and model quality within heterogeneous environments.
• We provide a convergence analysis for FedDCS in the smooth non-convex setting and evaluate FedDCS across a variety of highly diverse and challenging environments. The experimental results show that FedDCS consistently outperforms leading synchronous, asynchronous, and semi-asynchronous baselines in both convergence speed and final model accuracy. It also demonstrates exceptional robustness under extreme conditions with severe client staleness or highly skewed data distributions.

2. Related Work

Heterogeneity has been a fundamental challenge since the inception of FL. Existing research can be broadly categorized into three types, namely synchronous FL, asynchronous FL, and semi-asynchronous FL.

Numerous efforts within the synchronous paradigm have attempted to address it. For instance, TiFL [17] employs a tiering strategy that groups clients with similar performance profiles and samples clients from the same tier per round to mitigate stragglers, adjusting the sampling probability per tier based on its performance. FedAnp [18] adopts a dynamic sampling strategy, starting with the fastest clients and progressively doubling the participant pool as performance thresholds are met. To tackle statistical heterogeneity, FedProx [19] modifies the local objective function by adding a correction term that penalizes deviation from the global model, thereby reducing client drift. From a different perspective, InclusiveFL [20] assigns models of varying sizes to devices based on capability and employs knowledge distillation from stronger to weaker devices. While these synchronous methods introduce valuable innovations for handling specific aspects of heterogeneity, they often address one dimension at the expense of another or introduce new overheads, and their core design remains bound to the inefficient round-based synchronization barrier.

To fundamentally circumvent the straggler problem, asynchronous paradigms were proposed. Similar asynchronous methods have been leveraged in fields such as UAV-assisted computing [21] to handle device heterogeneity by triggering decisions per task arrival rather than on fixed timelines. To address the critical issue of staleness, a temporally weighted aggregation strategy assigns layer-wise weights when aggregating on shallow and deep layers to dampen the impact of stale gradients [22]. FedFa [23] employs a sliding window of historical models; each new update triggers an aggregation of all models within the window to mitigate bias from any single client. Beyond server-side scheduling, client-initiated protocols such as TEA-Fed [24] offer flexibility by enabling idle clients to request training tasks from the server proactively. Similarly, FAVANO [25] has all clients train concurrently, with the server randomly sampling clients whose updates are uploaded and aggregated immediately; the sampled clients then restart local training with the fresh global model. Another method [26] employs a probabilistic upload mechanism in which the server computes an upload probability for each client, and the client decides whether to transmit its update upon completion based on this probability. In summary, while these asynchronous and hybrid methods effectively eliminate idle waiting and offer greater design flexibility, they still fail to fully resolve the convergence instability issues associated with asynchronous updates.

To mitigate the aforementioned issues, semi-asynchronous approaches are proposed. For example, one method employs GANs to generate synthetic data, balances node capacity, and uses a priority function to select clients for aggregation while other clients continue local training [27]. HySync [28] maintains a dynamic aggregation window triggered by an update and aggregates all receipts within a preset timeframe. FedAT [29] groups clients by performance for intra-group synchronous training and inter-group asynchronous aggregation. CE-AFL [30] proposes an SQP-PA algorithm to determine an optimal buffer size for specific scenarios. ASAFL [31] further uses environmental information to dynamically adjust the aggregation size per round. FedSA [12] divides training into two phases: multi-epoch local training under semi-asynchronous aggregation, followed by fewer epochs with asynchronous updates. Other methods introduce novel aggregation rules. Port [13] determines client aggregation weights based on the cosine similarity between the client update and the global model update. ASFL [32] defines a staleness tolerance, requiring clients that exceed this threshold to restart training with the latest global model. CA2FL [11] enhances FedBuff [10] by maintaining a cache of the most recent model from each client and by aggregating only model deltas to mitigate staleness. From a systems perspective, Fed-SASL [33] employs split learning, deploying edge servers to assist stragglers in completing training for later DNN layers. While these methods demonstrate the flexibility of the semi-asynchronous design space, a common and critical limitation persists: they predominantly rely on predefined, static parameters (e.g., fixed group sizes, tolerance thresholds, phase durations). Consequently, they may lack the ability to adapt dynamically and holistically to the continuously evolving training environment characterized by both device and data heterogeneity. To address these limitations, we propose FedDCS, a novel semi-asynchronous FL framework that reduces reliance on static configurations. Unlike the aforementioned methods, FedDCS dynamically determines round-specific training parameters through a predictive, adaptive mechanism that continuously learns from client behavior, enabling robust performance in dynamically heterogeneous environments.

3. Methodology

The proposed FedDCS (Federated learning based on Dynamic Client Selection) framework leverages an adaptive two-stage waiting mechanism to predict client training time, enabling real-time decision-making and dynamically balancing the trade-off between training speed and model quality. As illustrated in the framework diagram, Figure 1. FedDCS operates through four coordinated stages: (1) It estimates each client’s completion time using a robust prediction model resistant to outliers and change points. (2) It determines the optimal buffer size by identifying a cohort of the fastest clients. (3) It selects clients for aggregation in this round by using a two-stage waiting mechanism. (4) It assigns aggregation weights by jointly considering client staleness and data volume to update the global model.

The following sections detail each component. For clarity, frequently used notations are summarized in

Table 1. Symbols and their descriptions.

Notation	Description
$\mathrm{N}$	The number of clients participating in aggregation
$\mathrm{t}$	Round $\mathrm{t}$ of training
$\mathrm{v}$	The current version of the global model
${\mathrm{v}}_{\mathrm{i}}$	The local model version of the client $\mathrm{i}$
${\mathsf{\theta }}_{\mathrm{i}}$	The aggregation weight of the client $\mathrm{i}$
${\mathsf{\theta }}_{\mathrm{g}}$	The global model’s aggregation weight
$\mathsf{\alpha }$	Data heterogeneity coefficient
${\mathrm{p}}_{\mathrm{i}}^{\mathrm{t}}$	Predicted completion time of client $\mathrm{i}$ in round t
${\mathrm{o}}_{\mathrm{i}}^{\mathrm{t}}$	Actual completion time of client $\mathrm{i}$ in round t
$\mathsf{\eta }$	Exponential smoothing coefficient
${\mathrm{e}}_{\mathrm{i}}^{\mathrm{t}}$	The prediction residual of the client $\mathrm{i}$ in round t
$\mathsf{\lambda }$	Cumulative Sum sensitivity parameter
${\mathsf{\mu }}_{\mathrm{i}}^{\mathrm{e}}$	The mean of ${\mathrm{e}}_{\mathrm{i}}^{\mathrm{t}}$
${\mathsf{\sigma }}_{\mathrm{i}}^{\mathrm{e}}$	The standard deviation of ${\mathrm{e}}_{\mathrm{i}}^{\mathrm{t}}$
$\mathrm{K}$	Dynamic buffer size
$\mathsf{\rho }$	The dynamic segment threshold coefficient
${\mathrm{T}}_1$	Waiting time of the first stage
${\mathrm{T}}_2$	Waiting time of the second stage
$\mathsf{\phi }$	The decay factor of ${\mathrm{T}}_1$
$\mathsf{\beta }$	The Monte Carlo reward weight of the second-stage waiting mechanism
$\mathsf{\gamma }$	The staleness decay coefficient of the POLY-rule function

.

3.1. Client Training Time Prediction

Accurate prediction of client completion time is the foundation of dynamic client scheduling in this study. To enhance prediction accuracy and ensure robustness against real-world noise and performance shifts, we propose an adaptive exponential smoothing model that integrates outlier filtering and change-point detection. For a given client $\mathrm{i}$, the predicted completion time for round $\mathrm{t}$, denoted as ${\mathrm{p}}_{\mathrm{i}}^{\mathrm{t}}$, is computed based on the previous prediction ${\mathrm{p}}_{\mathrm{i}}^{\mathrm{t}-1}$ and the newly observed completion time ${\mathrm{o}}_{\mathrm{i}}^{\mathrm{t}}$:

$${\mathrm{p}}_{\mathrm{i}}^{\mathrm{t}}=\mathsf{\eta }\cdot {\mathrm{o}}_{\mathrm{i}}^{\mathrm{t}}+(1-\mathsf{\eta })\cdot {\mathrm{p}}_{\mathrm{i}}^{\mathrm{t}-1}$$

(1)

Here, $\mathsf{\eta }$ is the smoothing coefficient ($0\le \mathsf{\eta }\le 1$), which governs the model’s sensitivity to recent observations. A fixed $\mathsf{\eta }$, however, struggles to adapt to complex, dynamic environments. To address this, we design a dynamic adjustment mechanism that allows $\mathsf{\eta }$ to switch adaptively among three predefined states based on the identified system condition:

$$\mathsf{\eta }=\left\{\begin{array}{c}0 \mathrm{if} \mathrm{outlier} \mathrm{is} \mathrm{detected}\\ {\mathsf{\eta }}_{\mathrm{m}\mathrm{u}\mathrm{t}\mathrm{a}\mathrm{t}\mathrm{i}\mathrm{o}\mathrm{n}} \mathrm{if} \mathrm{change} \mathrm{point} \mathrm{is} \mathrm{detected}\\ {\mathsf{\eta }}_{\mathrm{n}\mathrm{o}\mathrm{r}\mathrm{m}\mathrm{a}\mathrm{l}} \mathrm{under} \mathrm{normal} \mathrm{conditions}\end{array}\right.$$

(2)

To prevent prediction deviation caused by transient fluctuations in client performance (e.g., brief network interruptions or resource contention), this study incorporates an outlier detection mechanism based on the Interquartile Range (IQR) [34]. Upon receiving a new actual completion time ${\mathrm{o}}_{\mathrm{i}}^{\mathrm{t}}$ for a client $\mathrm{i}$, the server first verifies the sufficiency of that client’s historical time records. If sufficient data are available, the following procedure is executed: the first quartile ${\mathrm{Q}}_1$ and the third quartile ${\mathrm{Q}}_3$ of the historical completion times are calculated, yielding the IQR.

$$\mathrm{I}\mathrm{Q}\mathrm{R}={\mathrm{Q}}_3-{\mathrm{Q}}_1$$

(3)

The normal value range is defined as $[{\mathrm{Q}}_1-1.5\cdot \mathrm{I}\mathrm{Q}\mathrm{R},{\mathrm{Q}}_3+1.5\cdot \mathrm{I}\mathrm{Q}\mathrm{R}]$. If ${\mathrm{o}}_{\mathrm{i}}^{\mathrm{t}}$ falls outside this interval, it is flagged as an outlier. In such a case, the smoothing coefficient $\mathsf{\eta }$ is temporarily set to 0, effectively filtering out this temporary disturbance by ignoring the anomalous observation in the prediction update.

To enable the prediction model to quickly adapt to new states when a client’s computational or network environment undergoes a persistent change (e.g., a permanent increase in device load or a network bandwidth upgrade), this study employs a Cumulative Sum (CUSUM) [35] for change point detection. Specifically, the prediction residual of the client $\mathrm{i}$ in the current round is first calculated as:

$${\mathrm{e}}_{\mathrm{i}}^{\mathrm{t}}={\mathrm{o}}_{\mathrm{i}}^{\mathrm{t}}-{\mathrm{p}}_{\mathrm{i}}^{\mathrm{t}-1}$$

(4)

and the mean ${\mathsf{\mu }}_{\mathrm{i}}^{\mathrm{e}}$ and standard deviation ${\mathsf{\sigma }}_{\mathrm{i}}^{\mathrm{e}}$ of the residuals are updated online. Subsequently, the positive and negative cumulative deviations, ${\mathrm{S}}_{\mathrm{t}}^{+}$ and ${\mathrm{S}}_{\mathrm{t}}^{-}$, are computed as follows:

$$\left\{\begin{array}{c}{{\mathrm{S}}_{\mathrm{t}}}^{+}=\max (0,{{\mathrm{S}}_{\mathrm{t}-1}}^{+}+\mathrm{\lambda }{\mathrm{e}}_{\mathrm{i}}^{\mathrm{t}}-{\mathsf{\sigma }}_{\mathrm{i}}^{\mathrm{e}})\\ {{\mathrm{S}}_{\mathrm{t}}}^{-}=\min (0,{{\mathrm{S}}_{\mathrm{t}-1}}^{-}+\mathrm{\lambda }{\mathrm{e}}_{\mathrm{i}}^{\mathrm{t}}+{\mathsf{\sigma }}_{\mathrm{i}}^{\mathrm{e}})\end{array}\right.$$

(5)

where $\mathrm{\lambda }$ is a sensitivity parameter.

Formally, this can be framed as a hypothesis test where the null hypothesis ${\mathrm{H}}_0$ assumes no persistent change in the client’s performance. The test statistics are ${\mathrm{S}}_{\mathrm{t}}^{+}$ and ${\mathrm{S}}_{\mathrm{t}}^{-}$ themselves. The decision rule is to reject ${\mathrm{H}}_0$ if ${\mathrm{S}}_{\mathrm{t}}^{+}>3\cdot {\mathsf{\sigma }}_{\mathrm{i}}^{\mathrm{e}}$ or ${\mathrm{S}}_{\mathrm{t}}^{-}<-3\cdot {\mathsf{\sigma }}_{\mathrm{i}}^{\mathrm{e}}$. Under the assumption that the prediction residuals are approximately i.i.d. and normally distributed around zero under ${\mathrm{H}}_0$, this threshold corresponds to a theoretical false alarm rate with Type I error of about 0.27% per test, given that $\mathrm{P}\left(\left|\mathrm{N}\left(\mathrm{0,1}\right)\right|>3\right)$ is approximately 0.0027. This provides a statistically grounded balance between sensitivity and robustness against random fluctuations.

A change point is flagged if ${\mathrm{S}}_{\mathrm{t}}^{+}$ exceeds a threshold $3\cdot {\mathsf{\sigma }}_{\mathrm{i}}^{\mathrm{e}}$ or if ${\mathrm{S}}_{\mathrm{t}}^{-}$ falls below $-3\cdot {\mathsf{\sigma }}_{\mathrm{i}}^{\mathrm{e}}$. Upon detecting a change point, the server sets the smoothing coefficient $\mathsf{\eta }$ to a higher value ${\mathsf{\eta }}_{\mathrm{mutation}}$ for several subsequent rounds. This allows the exponential smoothing model to rapidly adjust by assigning greater weight to recent observations. Concurrently, the majority of clients’ historical completion records are purged to facilitate quick “forgetting” of the outdated pattern and adaptation to the new environment.

If neither outlier detection nor change point detection is triggered, the prediction model updates smoothly using the standard coefficient ${\mathsf{\eta }}_{\mathrm{normal}}$.

3.2. Early-Batch Segmentation for Dynamic Buffer Sizing

With the predicted training times for all clients obtained, the next step is to intelligently determine the dynamic buffer size for each training round. Traditional clustering algorithms (e.g., K-means [36]) can group clients but incur high computational overhead and require a preset number of clusters, making them unsuitable for the real-time demands of FL. To address this, we propose an Early-Batch Segmentation Algorithm designed to efficiently identify a cohort of clients predicted to finish training earliest and to derive the buffer size from this cohort. The algorithm operates as outlined in Algorithm 1. The algorithm takes as input the set of predicted completion times for all clients and a positive hyperparameter $\mathsf{\rho }$. It outputs two key parameters for the first-stage waiting mechanism: the dynamic buffer size $\mathrm{K}$ (the number of clients in the fastest batch) and the maximum waiting time $\mathrm{T}$ for this batch.

The procedure begins by sorting the predicted times in ascending order. It then calculates the sequence of gaps $\mathsf{\delta }$ between consecutive sorted times. A dynamic threshold $\mathsf{\tau }$ is computed as $\mathsf{\rho }$ times the average of these gaps. The algorithm then iterates through the sorted list, incrementally building the first batch. A client is included in the batch if the gap between its predicted time and the previous one does not exceed $\mathsf{\tau }$. The iteration stops at the first gap that exceeds $\mathsf{\tau }$, identifying a natural performance boundary. At this point, $\mathrm{K}$ is set to the count of clients included so far, and $\mathrm{T}$ is derived from the predicted completion time of the last client in this batch.

Algorithm 1 Early-Batch Segmentation Algorithm

Input: Predicted training completion times of clients end_training_time = $\{t_1,t_2,\dots ,t_n\}$, Hyperparameter for segmentation threshold $\rho \in {\mathbb{R}}^{+}(\rho >0)$ Output: Number of clients in the fastest batch $K\in \mathbb{N}$, Maximum waiting time for the batch $T$   1: n ⟵ Num(end_training_time)   2: $Tsorted ⟵SORT\left(en{d}_{trainin{g}_{time}}\right)$ // Sort in ascending order ${Tsorted}_1 \le {Tsorted}_2\le \cdots \le {Tsorted}_n$   3: $\delta ⟵\varnothing$   4: $\mathbf{for} i⟵2$$\mathbf{to} n$ do   5: ${\delta }_i⟵{Tsorted}_i-{Tsorted}_{i-1}$   6: $G⟵G\cup \left\{{\delta }_i\right\}$   7: end for   8: $\mu ⟵{\displaystyle \frac{1}{\left|\delta \right|}}{\sum }_{\tilde{\delta }\in \delta }\tilde{\delta }$   9: $\tau ⟵\rho \cdot \mu$ 10: $K⟵1$, $T⟵0$ 11: $\mathbf{for} j⟵2$ to $n$ do 12:      $\mathbf{if} {\delta }_j\le \tau$ then 13:          $K⟵K+1$ 14:      else 15:          $T⟵{Tsorted}_{j-1}-current time$ 16:          Exit the loop 17:      end if 18: end for 19: $\mathbf{return} K$, $T$

The computational complexity of the Early-Batch Segmentation Algorithm is dominated by the sorting operation, which takes $\mathrm{O}(\mathrm{n}\cdot \log \mathrm{n})$ time for $\mathrm{n}$ clients. The subsequent steps—calculating gaps $\mathsf{\delta }$, computing the dynamic threshold $\mathsf{\tau }$, iterating to get $\mathrm{K}$ and $\mathrm{T}$—each require only a single linear pass over the data, incurring $\mathrm{O}\left(\mathrm{n}\right)$ overhead. Thus, the algorithm has an overall time complexity of $\mathrm{O}(\mathrm{n}\cdot \log \mathrm{n})$.

3.3. The Two-Stage Waiting Mechanism

After obtaining the dynamic buffer size $\mathrm{K}$, this study employs an innovative Two-Stage Waiting Mechanism to execute the client model collection process. The mechanism is designed to precisely control the waiting time per round, aiming to optimally balance the trade-off between “avoiding prolonged idle waits for slow clients” and “maximizing the number of client updates collected.” This balance aims to maximize the training efficiency of each communication round. The complete procedure is outlined in Algorithm 2.

The algorithm comprises two consecutive stages with distinct objectives:

• First-Stage Waiting Mechanism: The first-stage wait is the primary period for client model collection, during which the server actively receives client updates. The value of ${\mathrm{T}}_1$ is the $\mathrm{T}$ output by Algorithm 1, set to the maximum predicted completion time among the clients in the identified fastest batch. As detailed in Algorithm 2, the server initiates a countdown timer for ${\mathrm{T}}_1$ and begins receiving incoming client updates. This stage is designed to be adaptive through three core rules: (1) Upon receiving an update, the remaining wait time ${\mathrm{T}}_1$ is reduced by a decay factor $\mathrm{\phi }$, dynamically shortening the wait as client update arrive; (2) The wait terminates immediately if the buffer reaches its target capacity $\mathrm{K}$, preventing unnecessary delay; (3) If the timer expires before the buffer is full, the stage ends forcefully to avoid indefinite stalling caused by extremely slow or unresponsive clients. These rules collectively ensure that the system is neither idle nor stalled, proactively advancing the training process.
• Second-Stage Waiting Mechanism: Empirical observation reveals that a cluster of clients may complete training shortly after the buffer is full. To harness these “following” clients, the second-stage wait is triggered upon completion of the first stage. ${\mathrm{T}}_2$ is implemented as a short, resettable timer. Its core logic is to dynamically extend the collection window: whenever a new client update arrives within the current T₂ window, the timer is reset. This creates a rolling window that persists as long as clients complete in close temporal succession, effectively capturing a naturally occurring cohort of clients. The stage concludes when a full ${\mathrm{T}}_2$ duration elapses without any new arrival, signaling that the trailing cluster has been fully collected. The settings of ${\mathrm{T}}_2$ are critical; an optimal value must balance the benefit of collecting additional clients against the cost of added latency.

Algorithm 2 Two-Stage Waiting Algorithm for Client Selection

Input: First-stage waiting time $T_1$, Second-stage waiting time $T_2$, Buffer size $K$, Time decay coefficient $\phi$ Output: Collected client set $\mathcal{B}$ and the number of clients n   1: $\mathcal{B}⟵\mathrm{\varnothing }$, $n⟵0$   2: $T_1^{remain}⟵T_1$   3: $t_{start}⟵current time$   4: $\mathbf{while} n<K$ and $T_1^{remain}>0$ do   5:      Wait for client arrival event   6:      $\mathbf{if} \mathrm{Client} i$ $\mathrm{completes} \mathrm{training} \mathrm{at} \mathrm{time} t_i$ then   7:          $t_{wait}⟵{t_i-t}_{start}$   8:          $T_1^{remain}⟵T_1^{remain}- \phi \cdot t_{wait}$   9:          $\mathcal{B}⟵\mathcal{B}\cup \left\{{client}_i\right\}$ 10:        $n⟵n+1$ 11:        $t_{start}⟵t_i$ //Reset reference time for next wait 12:    end if 13: end while 14: $\mathbf{if} n>0$ then 15: $hasNewClient⟵True$ 16:    $\mathbf{while} hasNewClient$ do 17:        $hasNewClient⟵False$ 18:        $\mathbf{while} \mathrm{within} T_2$ time do 19:            $\mathbf{if} \mathrm{New} \mathrm{client} j$ completes training then 20:                $\mathcal{B}⟵\mathcal{B}\cup \left\{{client}_j\right\}$ 21:                $n⟵n+1$ 22:                $hasNewClient⟵True$ 23:                break 24:            end if 25:        end while 26:      end while 27: end if 28: $\mathbf{return} \mathcal{B}$, $n$

To address this, we introduce a Monte Carlo simulation optimization method [37] to determine the most effective ${\mathrm{T}}_2$ value for the current training environment. This process consists of the following 3 steps: (1) For each client $\mathrm{i}$, based on its current predicted time ${\mathrm{p}}_{\mathrm{i}}^{\mathrm{t}}$ and the historical mean ${\mathsf{\mu }}_{\mathrm{i}}^{\mathrm{e}}$ and standard deviation ${\mathsf{\sigma }}_{\mathrm{i}}^{\mathrm{e}}$ of the prediction residuals, we model the client’s next-round completion time as a random variable drawn from a normal distribution: $\mathcal{N}({\mathrm{p}}_{\mathrm{i}}^{\mathrm{t}}+{\mathsf{\mu }}_{\mathrm{i}}^{\mathrm{e}},{\mathsf{\sigma }}_{\mathrm{i}}^{\mathrm{e}})$. By performing independent sampling for all clients, we generate one possible realization of completion times for the next round. Repeating this process thousands of times yields a diverse set of plausible future scenarios, capturing the inherent uncertainty and variability in client performance. (2) A set of candidate ${\mathrm{T}}_2$ values is generated within a plausible range. For a given candidate T₂ value, we simulate the execution of the complete two-stage waiting mechanism over all generated scenarios. For each scenario, we record two key outcomes: the total number of clients collected $\mathrm{n}$ and the total wall-clock waiting time $\mathrm{w}$. We then compute the average number of clients collected $\overline{\mathrm{n}}$, and the average total waiting time $\overline{\mathrm{w}}$, across all scenarios. (3) We define a reward function $\mathrm{R}$:

$$\mathrm{R}\left({\mathrm{T}}_2\right)=\mathsf{\beta }\cdot \overline{\mathrm{n}}+(1-\mathsf{\beta })\cdot (-\overline{\mathrm{w}})$$

(6)

where $\mathsf{\beta }\in \left(\mathrm{0,1}\right)$ is a tunably trade-off parameter that controls the relative importance of collection efficiency versus latency. A higher $\mathsf{\beta }$ prioritizes gathering more client updates, while a lower $\mathsf{\beta }$ emphasizes faster round completion. The optimal ${\mathrm{T}}_2^{\mathrm{*}}$ for the upcoming rounds is selected as the value that maximizes the expected reward:

$${\mathrm{T}}_2^{\mathrm{*}}=\mathrm{a}\mathrm{r}\mathrm{g} \underset{{\mathrm{T}}_2}{\mathrm{m}\mathrm{a}\mathrm{x}}\hspace{0.17em}\mathbb{E}[\mathrm{R}({\mathrm{T}}_2)]$$

(7)

This data-driven approach ensures that T₂ is dynamically tailored to maximize the expected utility of each communication round under the current estimated client performance profile.

The time complexity of the Monte Carlo optimization process is as follows. Considering a training round with $\mathrm{n}$ clients, for each of the $\mathrm{x}$ simulated scenarios: generating a completion time sample for each client takes $\mathrm{O}\left(\mathrm{n}\right)$ time; sorting these $\mathrm{n}$ samples for the two-stage waiting algorithm requires $\mathrm{O}(\mathrm{n}\cdot \log \mathrm{n})$ time. For a specific candidate ${\mathrm{T}}_2$ value, running the two-stage waiting algorithm on the sorted data also takes $\mathrm{O}\left(\mathrm{n}\right)$ time. With $\mathrm{m}$ candidate values (a small constant, such as $\mathrm{m}\le 30$), the cost per scenario becomes $\mathrm{O}(\mathrm{n}\cdot \log \mathrm{n}+\mathrm{n}\cdot \mathrm{m})$. Thus, the total complexity over $\mathrm{x}$ simulations is $\mathrm{O}(\mathrm{x}\cdot \mathrm{n}\cdot (\log \mathrm{n}+\mathrm{m}\left)\right)$.

In real-world deployments, the client cohort size per round, $\mathrm{n}$, is typically limited to tens to a few hundred. The complexity estimate, $\mathrm{O}(\mathrm{x}\cdot \mathrm{n}\cdot (\log \mathrm{n}+\mathrm{m}\left)\right)$, should be considered within this scale. Importantly, in large-scale federated learning, the main bottleneck is network communication and synchronization delays, not server-side processing. As a result, the computational effort for this online optimization is reasonable and worthwhile, given the substantial gains in training efficiency it provides.

3.4. Asynchronous Aggregation

In asynchronous FL paradigm, model updates from different clients are based on different versions of the global model, a difference known as staleness. To mitigate the negative impact of high-staleness client updates on global model convergence, FedDCS employs a dynamic weighting mechanism based on a POLY-rule function, which jointly considers a client’s staleness and its data quantity contribution.

Formally, let the current global model version on the server be $\mathrm{v}$, and let client $\mathrm{i}$’s local model be trained based on version ${\mathrm{v}}_{\mathrm{i}}$. The staleness of this client’s update is then defined as

$${\mathsf{\tau }}_{\mathrm{i}}=\mathrm{v}-{\mathrm{v}}_{\mathrm{i}}$$

(8)

Intuitively, a model update with higher staleness is based on an older global model and may deviate more from the current optimization direction. Therefore, it should be assigned lower weight during aggregation.

Our method employs the POLY-rule function to quantify the impact of staleness on aggregation weight. For client $\mathrm{i}$, the staleness-based weight decay factor ${\mathrm{d}}_{\mathrm{i}}$ is calculated as:

$${\mathrm{d}}_{\mathrm{i}}= {({\mathsf{\tau }}_{\mathrm{i}} +1)}^{-\mathsf{\gamma }}$$

(9)

where $\mathsf{\gamma }(\mathsf{\gamma }>0)$ is the decay coefficient that controls how rapidly the weight diminishes as staleness increases and a larger $\mathsf{\gamma }$ imposes a heavier penalty on stale updates. To simultaneously account for the data contribution from different clients, the final aggregation weight ${\mathsf{\theta }}_{\mathrm{i}}$ is jointly determined by the staleness decay factor ${\mathrm{d}}_{\mathrm{i}}$ and the client’s data proportion:

$${\mathsf{\theta }}_{\mathrm{i}}=(1-\mathrm{g})\cdot {\mathrm{d}}_{\mathrm{i}}\cdot {\displaystyle \frac{{\mathrm{n}}_{\mathrm{i}}}{{\sum }_{\mathrm{i}=1}^{\mathrm{N}}{\mathrm{n}}_{\mathrm{i}}}}$$

(10)

Here, ${\mathrm{n}}_{\mathrm{i}}$ denotes the local data size of client $\mathrm{i}$, and $\mathrm{N}$ represents the number of clients participating in aggregation during this round. The term $\mathrm{g}$ is a global model weight coefficient governing the influence of the previous global model in the aggregation. Specifically, ${\mathsf{\theta }}_{\mathrm{g}}$ is set to $\mathrm{g}$ only if all participating clients have zero staleness. Otherwise,

$${\mathsf{\theta }}_{\mathrm{g}}=1-{\sum }_{\mathrm{i}=1}^{\mathrm{N}}{\mathsf{\theta }}_{\mathrm{i}}$$

(11)

to ensure a convex combination of all components. The weight formula inherently respects the underlying data distribution while intelligently regulating the influence based on update timeliness.

After obtaining the normalized weights for all selected clients, the server performs a weighted average to generate the new global model ${\mathrm{w}}^{\mathrm{t}+1}$:

$${\mathrm{w}}^{\mathrm{t}+1}={\displaystyle {\sum }_{\mathrm{i}=1}^{\mathrm{N}}}{\mathsf{\theta }}_{\mathrm{i}}\cdot {\mathrm{w}}_{\mathrm{i}}^{\mathrm{local}}+{\mathsf{\theta }}_{\mathrm{g}}\cdot {\mathrm{w}}^{\mathrm{t}}$$

(12)

where ${\mathrm{w}}_{\mathrm{i}}^{\mathrm{local}}$ denotes the local model parameters uploaded by client $\mathrm{i}$.

Including the historical global model in the aggregation further enhances stability by preventing the new global model from being excessively swayed by the potentially biased updates from a newly sampled subset of clients. The decay coefficient $\mathsf{\gamma }$ is a pivotal hyperparameter in this scheme. Its value embodies a trade-off: a smaller $\mathsf{\gamma }$ is more tolerant of stale updates, facilitating the utilization of information from slower clients, whereas a larger $\mathsf{\gamma }$ prioritizes convergence stability by aggressively discounting outdated information. An appropriate $\mathsf{\gamma }$ is therefore crucial for balancing these competing objectives in heterogeneous environments.

3.5. Convergence Analysis

Building on the seminal work in [10,38], FedDCS can be viewed as an enhanced variant of FedBuff featuring a dynamic buffer size. The modifications are confined to the server-side strategy, rather than altering the client’s local training procedure. Consequently, it extends the established proof methodology of FedBuff by formalizing the server’s variable aggregation size.

We consider the standard federated optimization problem, where the goal is to find a global model parameter $w\in {\mathbb{R}}^d$ that minimizes the following objective:

$$\underset{\mathrm{w}}{\mathrm{m}\mathrm{i}\mathrm{n}} \mathrm{f}(\mathrm{w}):={\displaystyle \frac{1}{\mathrm{n}}} {\sum }_{\mathrm{i}=1}^{\mathrm{n}}{\mathrm{p}}_{\mathrm{i}}{\mathrm{F}}_{\mathrm{i}}(\mathrm{w})$$

(13)

Here, $\mathrm{n}$ is the total number of clients, ${\mathrm{F}}_{\mathrm{i}}\left(\mathrm{w}\right)$ denotes the expected loss over the local data distribution of client $\mathrm{i}$, and ${\mathrm{p}}_{\mathrm{i}}>0$ is the weight assigned to client $\mathrm{i}$. The local functions ${\mathrm{F}}_{\mathrm{i}}(\cdot )$ are only accessible by their respective client $\mathrm{i}$.

Our analysis is based on the following standard assumptions:

Assumption 1.

Unbiased Stochastic Gradients: The client’s stochastic gradient estimator is unbiased.

$${\mathbb{E}}_{{\mathsf{\varsigma }}_{\mathrm{i}}}\left[{\mathrm{g}}_{\mathrm{i}}\right(\mathrm{w};{\mathsf{\varsigma }}_{\mathrm{i}}\left)\right]=\nabla {\mathrm{F}}_{\mathrm{i}}\left(\mathrm{w}\right),\forall \mathrm{i}\in \left[\mathrm{n}\right]$$

(14)

Assumption 2.

Bounded Local and Global Variance: The variance of the stochastic gradients is bounded.

$${\mathbb{E}}_{{\mathsf{\varsigma }}_{\mathrm{i}}}[{\parallel {\mathrm{g}}_{\mathrm{i}}(\mathrm{w};{\mathsf{\varsigma }}_{\mathrm{i}})-\nabla {\mathrm{F}}_{\mathrm{i}}\left(\mathrm{w}\right)\parallel }^2]\le {\mathsf{\sigma }}_{\mathcal{l}}^2,\forall \mathrm{i},\mathrm{w}$$

(15)

$${\displaystyle \frac{1}{\mathrm{n}}}{\sum }_{\mathrm{i}=1}^{\mathrm{n}}{\parallel \nabla {\mathrm{F}}_{\mathrm{i}}\left(\mathrm{w}\right)-\nabla \mathrm{f}\left(\mathrm{w}\right)\parallel }^2\le {\mathsf{\sigma }}_{\mathrm{g}}^2,\forall \mathrm{w}$$

(16)

Assumption 3.

Bounded Gradient: The local gradient norm is uniformly bounded.

$${\parallel \nabla {\mathrm{F}}_{\mathrm{i}}\left(\mathrm{w}\right)\parallel }^2\le \mathrm{G},\forall \mathrm{i}\in \left[\mathrm{n}\right]$$

(17)

Assumption 4.

Lipschitz gradient: Each local objective function is L-smooth.

$${\parallel \nabla {\mathrm{F}}_{\mathrm{i}}\left(\mathrm{w}\right)-\nabla {\mathrm{F}}_{\mathrm{i}}\left({\mathrm{w}}^{\prime }\right)\parallel }^2\le \mathrm{L}{\parallel \mathrm{w}-{\mathrm{w}}^{\prime }\parallel }^2,\forall \mathrm{i}\in [\mathrm{n}]$$

(18)

Assumption 5.

Bounded Staleness: In the asynchronous execution, the staleness ${\tau }_i\left(t\right)$ of an update from client $i$ used in the server’s $t^{th}$ aggregation step is bounded.

$$1\le {\mathsf{\tau }}_{\mathrm{i}}\left(\mathrm{t}\right)\le {\mathsf{\tau }}_{\mathrm{m}\mathrm{a}\mathrm{x}}$$

(19)

The existence of this bound ${\mathsf{\tau }}_{\mathrm{m}\mathrm{a}\mathrm{x}}$ is guaranteed as the server performs aggregation at least once every fixed maximum waiting period, and the number of concurrent clients is finite.

Having established the standard assumptions, we proceed to derive the convergence guarantees for FedDCS. Given that our client-side optimization remains unchanged from FedBuff, we can directly leverage its core convergence results. The primary distinction lies in the server-side aggregation, where the fixed buffer size $\mathrm{K}$ in FedBuff is replaced by a dynamic buffer size ${\mathrm{N}}_{\mathrm{t}}$ in each round.

Lemma 1. 

Under Assumptions, choosing constant local learning rate ${\mathsf{\eta }}_{\mathrm{g}}$ and ${\mathsf{\eta }}_{\mathcal{l}}$, and if the learning rates satisfy ${\mathsf{\eta }}_{\mathrm{g}}\cdot {\mathsf{\eta }}_{\mathcal{l}}^{\left(q\right)}\cdot \mathrm{Q}\le {\displaystyle \frac{1}{\mathrm{L}}}$, the global model iterates of FedBuff are bounded by

$$\begin{gathered} {\displaystyle \frac{1}{\mathrm{T}}}\sum _{\mathrm{t}=0}^{\mathrm{T}-1}\mathbb{E}{[\Vert \nabla \mathrm{f}\left({\mathrm{w}}^{\mathrm{t}}\right)\Vert }^2]\le {\displaystyle \frac{2\left(\mathrm{f}\left({\mathrm{w}}^0\right)-{\mathrm{f}}^{\mathrm{*}}\right)}{{\mathsf{\eta }}_{\mathrm{g}}{\mathsf{\eta }}_{\mathcal{l}}\mathrm{Q}\mathrm{T}}}+{\displaystyle \frac{\mathrm{L}}{2}}{\mathsf{\eta }}_{\mathrm{g}}{\mathsf{\eta }}_{\mathcal{l}}{\mathsf{\sigma }}_{\mathcal{l}}^2 \\ +3{\mathrm{L}}^2{\mathrm{Q}}^2{\mathsf{\eta }}_{\mathcal{l}}^2({\mathsf{\eta }}_{\mathrm{g}}^2{\mathsf{\tau }}_{\mathrm{m}\mathrm{a}\mathrm{x}}^2+1)({\mathsf{\sigma }}_{\mathcal{l}}^2+{\mathsf{\sigma }}_{\mathrm{g}}^2+\mathrm{G}) \end{gathered}$$

(20)

where $\mathrm{T}$ is the total number of server communication rounds. $\mathrm{Q}$ is the number of local steps taken by each client. $[\mathrm{f}\left({\mathrm{w}}^0\right)-{\mathrm{f}}^{\mathrm{*}}]$ is the initial objective gap. ${\mathsf{\eta }}_{\mathrm{g}}$ and${\mathsf{\eta }}_{\mathcal{l}}$ are the server and client learning rates, respectively.

Building upon Lemma 1, we present the convergence theorem for the proposed FedDCS framework. The key adaptation stems from replacing the fixed buffer size $\mathrm{K}$ with the average dynamic buffer size as:

$$\overline{\mathrm{N}}=\mathbb{E}\left[{\mathrm{N}}_{\mathrm{t}}\right]$$

(21)

where ${\mathrm{N}}_{\mathrm{t}}$ is the number of clients aggregated in round $\mathrm{t}$. Under the assumption that client completion times are independent of local data distributions, we can treat the sequence $\left\{{\mathrm{N}}_{\mathrm{t}}\right\}$ as a stationary stochastic process with bounded variance.

Under Assumptions 1–5 and given that the dynamic buffer size ${\mathrm{N}}_{\mathrm{t}}$ is a stationary stochastic process with expectation $\overline{\mathrm{N}}=\mathbb{E}\left[{\mathrm{N}}_{\mathrm{t}}\right]$ and bounded variance $\mathrm{Var}\left[{\mathrm{N}}_{\mathrm{t}}\right]\le \mathrm{V}$, the global model iterates of FedDCS satisfy the following inequality for any choice of learning rates ${\eta }_g$ and ${\eta }_l$ satisfying ${\eta }_g{\eta }_{l}Q\le 1/L$:

$$\begin{array}{c}{\displaystyle \frac{1}{\mathrm{T}}}{\displaystyle }\mathbb{E}{[\Vert \nabla \mathrm{f}\left({\mathrm{w}}^{\mathrm{t}}\right)\Vert }^2]\le {\displaystyle \frac{2\left(\mathrm{f}\left({\mathrm{w}}^0\right)-{\mathrm{f}}^{\mathrm{*}}\right)}{{\mathsf{\eta }}_{\mathrm{g}}{\mathsf{\eta }}_{\mathcal{l}}\mathrm{Q}\mathrm{T}}}+{\displaystyle \frac{\mathrm{L}}{2}}{\mathsf{\eta }}_{\mathrm{g}}{\mathsf{\eta }}_{\mathcal{l}}{\mathsf{\sigma }}_{\mathcal{l}}^2\\ +3{\mathrm{L}}^2{\mathrm{Q}}^2{\mathsf{\eta }}_{\mathcal{l}}^2\left({\mathsf{\eta }}_{\mathrm{g}}^2{\mathsf{\tau }}_{\mathrm{m}\mathrm{a}\mathrm{x}}^2+1\right)\left({\mathsf{\sigma }}_{\mathcal{l}}^2+{\mathsf{\sigma }}_{\mathrm{g}}^2+\mathrm{G}\right)+C{\mathsf{\eta }}_{\mathrm{g}}^2{\mathsf{\eta }}_{\mathcal{l}}^2{\displaystyle \frac{V}{{\overline{N}}^4}}\end{array}$$

(22)

The constant $\mathrm{C}>0$ and the structure of the final term arise from bounding the impact of the variance of the dynamic buffer size. As shown in the inequality, the final term $\mathrm{C}{\mathsf{\eta }}_{\mathrm{g}}^2{\mathsf{\eta }}_{\mathcal{l}}^2{\displaystyle \frac{\mathrm{V}}{{\overline{\mathrm{N}}}^4}}$ quantifies the additional error due to the randomness of the dynamic buffer size. This term arises because the convergence proof involves bounding the second moment of the aggregated update, where the weighting factor ${\displaystyle \frac{1}{{\mathrm{N}}_{\mathrm{t}}^2}}$ appears. By performing a Taylor expansion of $\mathbb{E}[{\displaystyle \frac{1}{{\mathrm{N}}_{\mathrm{t}}^2}}]$ around $\overline{\mathrm{N}}$, the deviation from the fixed-weight case is proportional to ${\displaystyle \frac{\mathrm{V}\mathrm{a}\mathrm{r}\left({\mathrm{N}}_{\mathrm{t}}\right)}{{\overline{\mathrm{N}}}^4}}$. When combined with the squared learning rates ${\mathsf{\eta }}_{\mathrm{g}}^2{\mathsf{\eta }}_{\mathcal{l}}^2$ from the update magnitude, this yields the term $\mathrm{C}{\mathsf{\eta }}_{\mathrm{g}}^2{\mathsf{\eta }}_{\mathcal{l}}^2{\displaystyle \frac{\mathrm{V}}{{\overline{\mathrm{N}}}^4}}$. This term remains bounded and controlled in practice, as the variance V is finite and is suppressed by both ${\overline{\mathrm{N}}}^4$ and the learning rates.

Corollary 1. 

By selecting the learning rates as:

$$\begin{gathered} {\mathsf{\eta }}_{\mathcal{l}}=\mathsf{\Theta }({\displaystyle \frac{1}{\overline{\mathrm{N}}\sqrt{\mathrm{T}\mathrm{Q}}}}) \\ {\mathsf{\eta }}_{\mathrm{g}}=\mathsf{\Theta }(\overline{\mathrm{N}}) \\ {\mathsf{\sigma }}^2={\mathsf{\sigma }}_{\mathcal{l}}^2+{\mathsf{\sigma }}_{\mathrm{g}}^2+\mathrm{G} \\ {\mathsf{\eta }}_{\mathrm{g}}\cdot {\mathsf{\eta }}_{\mathcal{l}}^{\left(q\right)}\cdot \mathrm{Q}\le {\displaystyle \frac{1}{\mathrm{L}}} \end{gathered}$$

(23)

The bound in Formula (22) simplifies to

$$\begin{gathered} {\displaystyle \frac{1}{\mathrm{T}}}\sum _{\mathrm{t}=0}^{\mathrm{T}-1}\mathbb{E}{[\Vert \nabla \mathrm{f}\left({\mathrm{w}}^{\mathrm{t}}\right)\Vert }^2]\le \mathcal{O}\left({\displaystyle \frac{\mathrm{f}\left({\mathrm{w}}^0\right)-{\mathrm{f}}^{\mathrm{*}}}{\sqrt{\mathrm{T}\mathrm{Q}}}}\right)+\mathcal{O}\left({\displaystyle \frac{{\mathsf{\sigma }}_{\mathcal{l}}^2}{\sqrt{\mathrm{T}\mathrm{Q}}}}\right) \\ +\mathcal{O}({\displaystyle \frac{\mathrm{Q}{\mathsf{\sigma }}^2(1+{\mathsf{\tau }}_{\mathrm{m}\mathrm{a}\mathrm{x}}^2)}{\mathrm{T}{\mathrm{K}}^2}})+\mathcal{O}({\displaystyle \frac{\mathrm{V}}{\mathrm{T}{\overline{\mathrm{N}}}^4\mathrm{Q}}}) \end{gathered}$$

(24)

The corollary establishes the theoretical foundation for FedDCS. The derived bound confirms that our algorithm converges to a stationary point of the non-convex objective under standard assumptions. Critically, the asymptotic convergence rate, dominated by the $\mathcal{O}({\displaystyle \frac{1}{\sqrt{\mathrm{T}\mathrm{Q}}}})$ term, matches that of the FedBuff baseline. The terms involving $\overline{\mathrm{N}}$ demonstrate that a larger average cohort size improves convergence, analogous to increasing the fixed buffer size $\mathrm{K}$ in FedBuff. The final term $\mathcal{O}({\displaystyle \frac{\mathrm{V}}{\mathrm{T}{\overline{\mathrm{N}}}^4\mathrm{Q}}})$ quantifies the cost of the dynamic buffer’s variability. This term decays to zero as $\mathrm{T}\to \mathrm{\infty }$ and is heavily suppressed by ${\overline{\mathrm{N}}}^4$, confirming that the inherent randomness in our adaptive cohort formation does not compromise final convergence. In summary, the provided confident evidence validate the convergence properties of this FedDCS approach.

4. Experimental Results and Discussion

4.1. Evaluation

4.1.1. Simulation of Heterogeneity

Our experimental setup simulates a federated system with 100 clients. In each communication round, the server uniformly at random selects 30 clients to participate in the training. To rigorously evaluate the robustness of the FL methods, we explicitly simulate training environments with both device and data heterogeneity, aiming to replicate the challenges posed by real-world variations in user device capabilities and network conditions.

Device Heterogeneity. To emulate the hardware and computational diversity of real-world devices, we stratify the 100 clients into four performance tiers: 50% fast, 20% medium, 20% slow, and 10% extremely slow. This stratification serves as the baseline for systemic variation in performance. To simulate unstable network conditions during training, each client has a 4% probability of incurring an additional random network delay of 5–12 s before its update is received by the server. Furthermore, to reflect dynamic resource contention in real environments (e.g., from background processes), each client in every round has a 1% probability of experiencing a performance shift. When triggered, the client’s local training time is randomly increased or decreased by a duration between 0 and 10 s. As illustrated in Figure 2, which shows the distribution of client training times from a single experimental run, these combined factors result in a pronounced long-tail distribution of training times.

Data Heterogeneity. To simulate data heterogeneity, we partition the dataset using a label distribution skew approach based on the Dirichlet distribution [39]. For a dataset with $\mathrm{K}$ classes, we sample a probability vector ${\mathrm{p}}_{\mathrm{k}}\sim {\mathrm{Dir}}_{\mathrm{K}}\left(\mathsf{\alpha }\right)$ for each client $\mathrm{k}$, which defines the proportion of each class in its local dataset. The concentration parameter $\mathsf{\alpha }>0$ controls the degree of heterogeneity: a smaller $\mathsf{\alpha }$ leads to a more skewed distribution, where clients likely hold data from only a few classes, while a larger $\mathsf{\alpha }$ results in a more IID-like distribution. To investigate model performance across various heterogeneity levels, we employ three representative values, namely $\mathsf{\alpha }=0.1$ (highly heterogeneous), $\mathsf{\alpha }=0.5$ (moderately heterogeneous), and $\mathsf{\alpha }=1.0$ (mildly heterogeneous). Examples of the resulting client data distributions for different $\alpha$ values are visualized in Figure 3.

4.1.2. Datasets

To comprehensively evaluate the performance of FedDCS in addressing heterogeneity, we select three widely adopted benchmark datasets with varying complexity and characteristics in FL research, namely Fashion-MNIST [40], CIFAR-10 [41], and CIFAR-100 [41] as shown in

Table 2. Benchmark datasets.

Dataset Title	Dataset Description	Data Scale
Fashion-MNIST [40]	Fashion-MNIST (FMNIST) is a widely used benchmark dataset for image classification tasks, often regarded as an alternative to the traditional MNIST handwritten digit dataset.	70,000 28 × 28-pixel images across 10 categories.
CIFAR-10 [41]	CIFAR-10 is a benchmark dataset that encompasses a wide variety of scenes and objects, ranging from natural landscapes to man-made objects, offering high diversity.	60,000 32 × 32-pixel color natural images across 10 categories.
CIFAR-100 [41]	CIFAR-100 is an extension of the CIFAR-10 dataset and is frequently used to evaluate algorithm performance on highly heterogeneous data that require strong generalization capabilities. It features a more granular and complex classification structure.	60,000 32 × 32-pixel color images across 100 categories.

.

4.1.3. Baselines

To comprehensively evaluate the performance of our proposed method, we select five representative FL methods as baselines, encompassing the primary synchronous, asynchronous, and semi-asynchronous training paradigms:

• FedAvg [1]: The foundational synchronous FL method.
• FedAnp [18]: An adaptive synchronous method that employs dynamic client sampling to improve efficiency against system heterogeneity.
• FedAsync [6]: A canonical asynchronous method where the server aggregates the global model immediately upon receiving any client update.
• FedFa [23]: An enhanced asynchronous method that maintains a buffer, enabling “single-client triggering, multi-client aggregation”.
• FedBuff [10]: A semi-asynchronous method that aggregates a subset of faster clients per round.

4.1.4. Evaluation Metrics

To comprehensively evaluate the performance of FedDCS, we use the following three metrics: test accuracy, F1-score (F1), and time efficiency. Test accuracy measures the overall classification correctness of the global model on a held-out test set. F1 is the harmonic mean of precision and recall. It provides a balanced assessment of model performance, which is particularly crucial under non-IID or class-imbalanced data distributions. Time efficiency is evaluated from two practical perspectives: (1) the trajectory of test accuracy versus wall-clock training time, illustrating the convergence speed; (2) the total time required to reach a pre-defined target accuracy, reflecting the overall computational cost.

4.2. Experimental Setup

4.2.1. Implementation Setting

The server we used was equipped with an Intel(R) Xeon(R) Platinum 8173 M CPU (16 cores), 32 GB of RAM, and an NVIDIA GeForce RTX 3090 GPU for accelerated training, running Ubuntu 22.04. All models were built, trained, and evaluated using the PyTorch 2.8.0 deep learning framework with CUDA 12.1.1 support. To mitigate the impact of randomness and ensure statistical reliability, each experiment was independently conducted 5 times with different random seeds.

4.2.2. Model and Training Configuration

We design dedicated Convolutional Neural Network (CNN) models for each image classification task. For the Fashion-MNIST dataset, we employ a lightweight CNN comprising two convolutional layers followed by two fully connected layers to process single-channel 28 × 28 grayscale images. For the more complex CIFAR-10 dataset, the model architecture is adapted by increasing the number of input channels to 3 for RGB images and adjusting the feature map dimensions accordingly. To handle the fine-grained 100-class CIFAR-100 dataset, we utilize a deeper and wider network with three convolutional layers and larger fully connected layers to enhance its feature extraction and representation capacity. All models use ReLU activation and incorporate dropout with a rate of 0.5 in the fully connected layers to prevent overfitting.

In federated training, all clients share identical local training hyperparameters. Specifically, we use the Adam optimizer with an initial learning rate of 0.001 and the cross-entropy loss function. In each federated round, every participating client performs 5 local training epochs on its private data with a batch size of 64. Here, according to previous pilot test and empirical analysis, we set the key hyperparameters of FedDCS as CUSUM sensitivity $\lambda =1.0$, the segmentation threshold coefficient $\rho =1.5$, the first-stage ${\mathrm{T}}_1$ decay factor $\phi =0.7$, the Monte Carlo reward weight $\beta =0.4$, and the staleness decay coefficient $\gamma =0.7$.

4.3. Results and Analysis

4.3.1. Convergence Performance

To investigate the performance of FedDCS across different data-heterogeneity settings, we conduct experiments on the CIFAR-10 dataset, simulating non-IID data of varying severity by varying the Dirichlet distribution parameter $\mathsf{\alpha }$. Figure 4 illustrates the convergence timeline for all compared methods, including our proposed FedDCS, across three heterogeneity levels.

As illustrated in the figure, FedDCS outperforms the other methods in robustness and time efficiency across all levels of heterogeneity. Its test accuracy curve climbs the fastest, exhibits stable convergence, and consistently achieves and maintains the highest final accuracy. FedAvg, while capable of reaching a high final accuracy, suffers from severe efficiency degradation due to the straggler effect. Its convergence rate is the slowest among all methods, as it is bottlenecked by the slowest client in each training round. The performance of FedAnp and FedBuff shows greater sensitivity to data heterogeneity. Their time efficiency fluctuates noticeably across different $\mathsf{\alpha }$ settings.

To evaluate the generalizability of our method across varying task complexities, we conduct extended experiments on the Fashion-MNIST and CIFAR-100 datasets, using a Dirichlet parameter $\mathsf{\alpha }=0.5$ to simulate a representative non-IID setting. Figure 5 depicts the convergence timeline for all compared methods and FedDCS.

Overall, FedDCS consistently achieves the best performance on all datasets, characterized by the fastest initial convergence rate and the highest stable accuracy plateau, confirming its dual advantages in efficiency and robustness.

On Fashion-MNIST, all methods eventually converge. Among these, FedDCS outperforms all baselines in both final accuracy and convergence speed. Notably, the semi-asynchronous baseline FedBuff demonstrates acceptable performance here, yet its convergence trajectory remains slower and less accurate than that of FedDCS.

Compared with the previous example, the model performances on the more challenging benchmark dataset of CIFAR-100 vary. FedDCS still maintains a significant lead, achieving the fastest convergence and the highest stable accuracy, which underscores the strong adaptability of its design to high-complexity tasks. In contrast, while FedAvg can reach a respectable final accuracy, its convergence process is prohibitively slow. FedBuff suffers from reduced time efficiency when facing this complex task. The asynchronous methods (FedAsync, FedFa) fail to adapt effectively, exhibit extremely low efficiency, and struggle to converge.

Integrating the experimental results from Figure 4 and Figure 5, our proposed FedDCS strategy demonstrates robust and efficient performance when handling federated learning tasks characterized by dynamic heterogeneity. Notably, FedDCS consistently maintains high time efficiency across a wide spectrum of experimental conditions—from mild (α = 1.0) to high (α = 0.1) data heterogeneity, and from the relatively simple Fashion-MNIST to the complex CIFAR-100 classification task. These observations comprehensively validate that its core design exhibits strong, generalizable adaptability to environmental variations across dimensions and severity levels.

4.3.2. Accuracy and F1 Score

To comprehensively evaluate the final model quality and training stability of each method,

Table 3. Final performance comparison across multiple dataset configurations.

Dataset	Metrics *	FedAvg	FedAnp	FedAsync	FedFa	FedBuff	FedDCS
FMNIST $(\alpha =0.5$)	Acc (%)	88.7 ± 0.2	88.0 ± 0.5	84.0 ± 0.5	83.1 ± 0.4	88.7 ± 0.2	89.0 ± 0.3
	F1 (%)	88.6 ± 0.2	87.9 ± 0.5	83.7 ± 0.5	82.9 ± 0.5	88.7 ± 0.2	88.9 ± 0.3
CIFAR10 $(\alpha =1.0$)	Acc (%)	70.9 ± 0.4	69.3 ± 0.4	54.5 ± 0.7	52.8 ± 1.8	68.9 ± 0.2	70.3 ± 0.3
	F1 (%)	70.8 ± 0.5	69.1 ± 0.6	54.3 ± 0.9	52.4 ± 2.0	68.8 ± 0.3	70.2 ± 0.3
CIFAR10 $(\alpha =0.5$)	Acc (%)	69.5 ± 0.4	67.7 ± 1.5	50.3 ± 0.6	49.7 ± 1.6	68.2 ± 0.5	69.7 ± 0.5
	F1 (%)	69.4 ± 0.4	67.3 ± 1.5	49.9 ± 0.7	48.3 ± 1.6	68.0 ± 0.4	69.7 ± 0.5
CIFAR10 $(\alpha =0.1$)	Acc (%)	64.4 ± 2.5	58.5 ± 7.7	34.5 ± 2.1	34.0 ± 2.8	59.6 ± 3.2	65.0 ± 1.5
	F1 (%)	63.9 ± 2.4	57.6 ± 8.0	29.6 ± 3.5	28.6 ± 4.1	59.2 ± 3.8	64.9 ± 1.5
CIFAR100 $(\alpha =0.5$)	Acc (%)	42.8 ± 0.8	39.1 ± 0.6	35.9 ± 0.4	36.2 ± 0.2	40.5 ± 0.4	42.9 ± 0.6
	F1 (%)	43.6 ± 0.7	40.1 ± 0.6	35.9 ± 0.5	36.1 ± 0.3	41.2 ± 0.4	43.7 ± 0.6

* The statistics include accuracy and F1, along with the mean ± standard deviation of the approaches. Bolded numbers indicate the best performance among all methods.

summarizes the average optimal test accuracy (Acc) and F1 score (F1), along with their standard deviations, obtained from five independent runs with different random seeds across five dataset configurations. The trends for test accuracy and F1 are consistent; therefore, we focus our analysis primarily on accuracy.

Overall, the proposed FedDCS achieves the best comprehensive performance in most settings. On the relatively simple Fashion-MNIST ($\mathsf{\alpha }=0.5$) task, FedDCS attains a slight lead with 89.0% accuracy, compared to FedAvg and FedBuff (both 88.7%). The advantage of FedDCS becomes more pronounced on the more challenging CIFAR datasets. Under mild heterogeneity on CIFAR-10 ($\mathsf{\alpha }=1.0$), FedDCS achieves 70.3% accuracy—slightly lower than FedAvg’s 70.9%—but exhibits superior stability with a smaller standard deviation (±0.3% vs. ±0.4%). Crucially, FedAvg requires significantly more training time to reach this accuracy. As data heterogeneity intensifies ($\mathsf{\alpha }$ decreasing from 1.0 to 0.1), the performance degradation of FedDCS is markedly less severe than that of other baselines. In the highly data heterogeneous CIFAR-10 ($\mathsf{\alpha }=0.1$) setting, FedDCS achieves a significantly higher accuracy of 65.0% compared to FedAvg (64.4%) and others, while also demonstrating the best robustness with a standard deviation of ±1.5%, far lower than that of FedAnp (±7.7%). For the fine-grained CIFAR-100 ($\mathsf{\alpha }=0.5$) task, FedDCS also delivers the most competitive result with an accuracy of 42.9% ± 0.6%, balancing high performance with stability.

In contrast, all baseline methods exhibit notable limitations. While FedAvg can achieve accuracy comparable to FedDCS in some settings, its synchronous nature fundamentally limits efficiency due to the straggler problem. FedBuff delivers acceptable performance on simpler tasks but shows a significant gap in both convergence speed and final accuracy on complex ones. FedAnp demonstrates high sensitivity to data distribution; its accuracy drops sharply, and its variance increases drastically as heterogeneity intensifies. The asynchronous methods (FedAsync, FedFa) consistently underperform all others in both final accuracy and stability across every configuration. The results in Table 3 collectively demonstrate that FedDCS not only achieves the highest convergence accuracy in most cases but also adapts to varying data distributions and task complexities with minimal performance fluctuation, establishing it as a robust and effective solution for complex, heterogeneous FL scenarios.

4.3.3. Time Efficiency

To precisely quantify the time efficiency of each method, we record the cumulative wall-clock time required to reach a pre-defined target test accuracy. A direct comparison is presented in Figure 6.

Across all experimental settings, FedDCS consistently reaches the training goal in the shortest time, establishing a comprehensive lead in time efficiency. On the Fashion-MNIST task ($\mathsf{\alpha }=0.5$), FedDCS requires only 320 s. In comparison, FedAvg, FedAnp, and FedBuff take 2.66×, 2.16×, and 1.15× longer, respectively. This advantage is further amplified under the highly heterogeneous CIFAR-10 ($\mathsf{\alpha }=0.1$) scenario, where FedDCS needs merely 402 s. The completion times for FedAvg, FedAnp, and FedBuff are 3.29×, 4.93×, and 2.00× longer, respectively, indicating a clear efficiency advantage. This trend holds for other CIFAR-10 scenarios and the more complex CIFAR-100 ($\mathsf{\alpha }=0.5$) task, where FedDCS’s completion time remains significantly lower than all other methods.

4.3.4. Ablation Study

To evaluate the practical overhead of our server-side orchestration approach, we measure the time spent by its main components during a full training cycle. The experiment is performed on three benchmark datasets in a non-IID setting (α = 0.5), with 3000 Monte Carlo simulations. As shown in

Table 4. Time cost breakdown of different modules.

Dataset $(\mathit{\alpha }=0.5$)	Metrics	Training Time Prediction	Early-Batch Segmentation	Monte Carlo Simulation	Total Round Time
FMNIST	$\mathrm{Time} (\mathrm{s}$)	0.189	0.037	46.743	2175.929
	Proportion	0.009%	0.002%	2.148%	100%
CIFAR10	$\mathrm{Time} (\mathrm{s}$)	0.264	0.052	134.338	3753.548
	Proportion	0.007%	0.001%	3.579%	100%
CIFAR100	$\mathrm{Time} (\mathrm{s}$)	0.366	0.150	179.304	5998.491
	Proportion	0.006%	0.003%	2.989%	100%

, the client training time prediction and early-batch segmentation modules are highly efficient, together representing less than 0.02% of the total round duration. Their overhead is therefore negligible. Although the Monte Carlo simulation module is the most resource-intensive among the three, it still adds only a small overhead—ranging from 2.1% to 3.6% of the total round time across all datasets. These results empirically confirm that FedDCS’s entire adaptive scheduling overhead is minimal. This small additional cost is justified and acceptable, as it enables the significant time efficiency improvements demonstrated in our experiments.

To examine the contribution of each component in the two-stage waiting strategy of FedDCS, we conduct an ablation study by comparing the full method with two variants across three datasets (α = $0.5$). The compared variants are defined as follows:

• FedDCS: The full proposed strategy with the complete two-stage adaptive waiting mechanism.
• FedDCS-T1: A variant retaining only the first-stage waiting mechanism. This effectively reduces the method to a FedBuff variant with a dynamically sized buffer.
• FedDCS-T2: A variant retaining only the second-stage waiting mechanism, with a fixed buffer size of 20. This is equivalent to augmenting the standard FedBuff with the second-stage waiting mechanism as an optimization patch.
• FedBuff: The standard semi-asynchronous baseline, which employs a fixed buffer size and contains neither of the proposed waiting mechanisms.

The experimental results are shown in Figure 7 above. The analysis reveals the distinct and complementary roles of the two proposed mechanisms:

• The first-stage waiting mechanism ensures baseline time efficiency. On simpler tasks such as Fashion-MNIST, FedDCS-T1 achieves higher early-stage efficiency than FedBuff and FedDCS-T2. However, on the complex CIFAR-100 task, it underperforms relative to FedDCS-T2 and the full FedDCS. This indicates that dynamically adjusting the buffer size based on client progress is effective at adapting to common performance variations and avoiding the inefficiencies of a fixed buffer. Nonetheless, its standalone contribution is limited, particularly in handling dynamic environmental changes.
• The second-stage waiting mechanism enhances efficiency on complex tasks. For the more challenging CIFAR-10 and CIFAR-100 datasets, FedDCS-T2 demonstrates significantly higher early-stage time efficiency than FedBuff and slightly outperforms FedDCS-T1. This validates that the second-stage waiting mechanism, by purposefully incorporating updates from “following” clients, enriches the information content of each communication round, thereby accelerating early-phase convergence. However, a fixed buffer size can result in excessive waiting or unnecessary delays when clients experience sudden slowdowns.
• Synergistic effect for optimal performance. The complete FedDCS strategy achieves the best overall performance across all three datasets. It leads comprehensively in both time efficiency and final accuracy on Fashion-MNIST and CIFAR-100. On CIFAR-10, it achieves the highest convergence rate while reaching peak accuracy. These results demonstrate a clear synergistic effect: the first-stage waiting mechanism establishes an efficient, adaptive scheduling foundation, while the second-stage waiting mechanism performs refined optimization on this basis. This combination is crucial for robust performance in environments with compounded device and data heterogeneity.

To investigate the impact of the Monte Carlo reward function weight $\mathsf{\beta }$ within the second-stage waiting mechanism, we conduct a sensitivity analysis on three datasets ($\mathsf{\alpha }=0.5$), testing values of $\mathsf{\beta }\in \{0.2,0.4,0.6,0.8\}$. This parameter controls the trade-off in the Monte Carlo simulation between the reward for aggregating more clients and the penalty for incurring additional waiting time. The results are presented in Figure 8.

Across all three datasets, $\mathsf{\beta }=0.4$ achieves the best overall performance, striking an optimal balance between time efficiency and final accuracy. On Fashion-MNIST, $\mathsf{\beta }=0.4$ maintains a consistent lead throughout the entire FL training process. On CIFAR-10, $\mathsf{\beta }=0.4$ and $\mathsf{\beta }=0.2$ show comparable early-stage efficiency. However, $\mathsf{\beta }=0.4$ demonstrates superior convergence stability and higher final accuracy. While $\mathsf{\beta }=0.6$ reaches high final accuracy, its early-stage efficiency is inferior to that of $\mathsf{\beta }=0.4$. On the more complex CIFAR-100, $\mathsf{\beta }=0.4$ slightly outperforms $\mathsf{\beta }=0.2$ in efficiency and stability, and delivers better overall performance than $\mathsf{\beta }=0.6$ and $\mathsf{\beta }=0.8$. Setting $\mathsf{\beta }$ too high places excessive emphasis on waiting for more clients, thereby introducing significant and often unnecessary latency. This leads to markedly lower time efficiency—a drawback that would be further exacerbated in dynamic environments with sudden client performance shifts.

These results indicate that setting $\mathsf{\beta }=0.4$ assigns the most appropriate weight to client quantity in the second-stage dynamic decision-making. It enables the effective utilization of more client updates without significantly prolonging the per-round duration. The consistency of this optimal balance point across tasks of varying complexity demonstrates the robustness and generalizability of the chosen parameter value.

5. Conclusions

In this paper, we address the critical challenge of time efficiency and robustness in FL environments characterized by device and data heterogeneity. To overcome this, we proposed FedDCS, a semi-asynchronous FL framework. Its core innovation is an efficient, predictive, and adaptive server-side orchestration mechanism. FedDCS first employs an enhanced exponential smoothing model to predict client completion times. These predictions then drive a two-stage adaptive waiting mechanism: the first stage dynamically sets a buffer size and wait time to efficiently collect a core cohort of clients, while an optimized second-stage wait captures additional clients that complete in close succession. Collectively, these components enable FedDCS to adaptively respond to dynamic heterogeneities in real time.

We conducted extensive experiments across three benchmark datasets of varying complexity under meticulously simulated heterogeneous conditions. The results consistently demonstrate that FedDCS achieves a superior balance between efficiency and model quality. It significantly outperforms synchronous, asynchronous, and semi-asynchronous baselines in terms of time efficiency and exhibits the highest accuracy with lower variance across diverse and challenging scenarios.

Two practical directions for future work include defending against potential client poisoning attacks and handling frequent client dropouts in unstable networks. Enhancing the current adaptive mechanism to address these issues would make the framework more practical for volatile environments.