ClusterCast: Cluster-Aware Dissemination

• ClusterCast is a cluster-aware dissemination mechanism that selectively propagates data across clusters with tailored criteria for different domains.
• It leverages advanced clustering methods—such as label divergence and topological similarity in federated learning or sparsity-based beamforming in cloud RAN—to optimize system performance.
• It reduces communication overhead, mitigates semantic drift, and ensures robust, fault-tolerant delivery in resilient distributed systems.

“ClusterCast” appears in several distinct technical literatures as a cluster-aware dissemination or communication mechanism. In federated graph learning, it denotes a semi-asynchronous server-side procedure that clusters clients by label-distribution divergence and graph topological characteristics, then broadcasts personalized models within semantic clusters to mitigate semantic drift (Yuan et al., 24 Jul 2025). In cache-enabled cloud radio access networks, it denotes content-centric base-station clustering coupled with multicast beamforming under backhaul and power constraints (Zhou et al., 2015). In resilient distributed systems, closely related cluster-sending and Cross-Cluster Consistent Broadcast formulations treat clusters as Byzantine- or crash-tolerant replica groups and study reliable inter-cluster delivery with expected constant communication or constant metadata overhead (Hellings et al., 2021, Frank et al., 2023). A plausible unifying interpretation is that the term consistently refers to selective propagation across cluster structure, but the optimization targets, fault models, and algorithmic machinery differ substantially by domain.

1. Domain-specific meanings

The cited works use “ClusterCast” in three technically different senses.

Context	Cluster notion	Core mechanism
Federated graph learning	Clients with similar label distributions and graph structures	Cluster-level broadcasting of personalized GNN models
Cache-enabled cloud RAN	Dynamically chosen BS set serving a multicast group	Content-centric BS clustering with multicast beamforming
Resilient inter-cluster communication	Fault-tolerant replica clusters or RSMs	Certified cluster-sending or C3B with acknowledgements and retransmission logic

In the federated graph learning setting, the mechanism is part of FedSA-GCL, a semi-asynchronous federated framework designed for graph data, where naive asynchronous federated learning can aggravate semantic drift because it ignores graph topology and label-distribution shifts (Yuan et al., 24 Jul 2025). In the wireless networking setting, ClusterCast is tied to multicast transmission and caching: users requesting the same content form a multicast group, and a dynamically selected cluster of base stations cooperatively transmits with multicast beamforming (Zhou et al., 2015). In the distributed-systems setting, the relevant problem is cluster-sending between Byzantine fault-tolerant clusters, or more generally Cross-Cluster Consistent Broadcast between replicated state machines, with emphasis on integrity, eventual delivery, message complexity, and recovery from failures (Hellings et al., 2021, Frank et al., 2023).

This distribution of meanings suggests that “ClusterCast” is not a single canonical protocol family. The shared element is cluster-aware dissemination, but the objects being disseminated differ: GNN parameters, cached content streams, and certified messages.

2. FedSA-GCL: cluster-aware broadcasting in federated graph learning

FedSA-GCL is introduced as a semi-asynchronous federated graph learning framework whose core innovation, ClusterCast, performs three operations: client clustering based on both label-distribution divergence and graph-structural similarity; semi-asynchronous aggregation weighted by local smoothness confidence and model staleness; and proactive “cluster-level broadcasting” of personalized models not only to clients who just uploaded but also to inactive clients in the same semantic cluster (Yuan et al., 24 Jul 2025). The mechanism is motivated by two failures of prior practice. First, synchronous federated learning suffers straggler delay and under-utilized compute because the server must wait for all selected clients. Second, existing asynchronous federated learning methods such as FedAsync and FedBuff were developed for image and text settings and can over-represent a biased subset of clients, creating temporal sampling bias and semantic drift when applied directly to graph learning (Yuan et al., 24 Jul 2025).

The clustering criterion combines a symmetric KL divergence on local label histograms with a distance on graph summary statistics. For client $i$ with local label histogram

$$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$

the inter-client shift is

$$D_{\mathrm{KL}}(i,j)=\frac{1}{2}\sum_{y\in\mathcal{Y}}\left[p_i(y)\log\frac{p_i(y)}{p_j(y)}+p_j(y)\log\frac{p_j(y)}{p_i(y)}\right].$$

Graph topology is summarized by the average clustering coefficient $\overline{C}_i$ and modularity $Q_i$, and the structural distance is

$$D_{\mathrm{topo}}(i,j)=\bigl|\overline{C}_i-\overline{C}_j\bigr|+\bigl|Q_i-Q_j\bigr|.$$

These are fused as

$$M(i,j)=\alpha D_{\mathrm{KL}}(i,j)+(1-\alpha)D_{\mathrm{topo}}(i,j), \quad \alpha\in[0,1],$$

and clients are assigned to the same cluster if $M(i,j)\le \tau$, where $\tau$ is a threshold hyperparameter, with the example $\tau=0.5$ given in the formulation (Yuan et al., 24 Jul 2025).

The server procedure is semi-asynchronous rather than fully asynchronous. It waits until the upload buffer size reaches $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$0, then processes the queued uploads, updates a server knowledge base containing $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$1 per client, determines a semantic cluster for each uploaded client using cosine similarity on semantic feature matrices, computes a personalized aggregation weight, returns $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$2 to the uploader, and pushes models to inactive clients in the same cluster (Yuan et al., 24 Jul 2025). Downloaded models are cached locally and only merged after the current epoch, so server pushes do not interrupt in-progress local training. This design is explicitly intended to preserve representational consistency while retaining the latency advantages of asynchronous operation.

3. Aggregation, drift mitigation, and empirical behavior in FedSA-GCL

FedSA-GCL’s aggregation policy is personalized and staleness-aware. For an uploaded client $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$3 at server round $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$4, if $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$5 is the last upload round of client $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$6, the staleness term is defined as

$$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$7

Given local smoothness confidence $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$8, the aggregation weights are

$$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$9

After computing a personalized model $$D_{\mathrm{KL}}(i,j)=\frac{1}{2}\sum_{y\in\mathcal{Y}}\left[p_i(y)\log\frac{p_i(y)}{p_j(y)}+p_j(y)\log\frac{p_j(y)}{p_i(y)}\right].$$0, the server pushes it not only to client $$D_{\mathrm{KL}}(i,j)=\frac{1}{2}\sum_{y\in\mathcal{Y}}\left[p_i(y)\log\frac{p_i(y)}{p_j(y)}+p_j(y)\log\frac{p_j(y)}{p_i(y)}\right].$$1 but also to inactive clients in the same semantic cluster $$D_{\mathrm{KL}}(i,j)=\frac{1}{2}\sum_{y\in\mathcal{Y}}\left[p_i(y)\log\frac{p_i(y)}{p_j(y)}+p_j(y)\log\frac{p_j(y)}{p_i(y)}\right].$$2. Upon receipt, client $$D_{\mathrm{KL}}(i,j)=\frac{1}{2}\sum_{y\in\mathcal{Y}}\left[p_i(y)\log\frac{p_i(y)}{p_j(y)}+p_j(y)\log\frac{p_j(y)}{p_i(y)}\right].$$3 caches $$D_{\mathrm{KL}}(i,j)=\frac{1}{2}\sum_{y\in\mathcal{Y}}\left[p_i(y)\log\frac{p_i(y)}{p_j(y)}+p_j(y)\log\frac{p_j(y)}{p_i(y)}\right].$$4 and merges after finishing its current epoch via

$$D_{\mathrm{KL}}(i,j)=\frac{1}{2}\sum_{y\in\mathcal{Y}}\left[p_i(y)\log\frac{p_i(y)}{p_j(y)}+p_j(y)\log\frac{p_j(y)}{p_i(y)}\right].$$5

The intended effect is twofold: inactive clients are kept close to current cluster representations, and very old updates are down-weighted so that outdated models do not create abrupt representational shifts (Yuan et al., 24 Jul 2025).

The overhead analysis in the same work quantifies several costs. Computing $$D_{\mathrm{KL}}(i,j)=\frac{1}{2}\sum_{y\in\mathcal{Y}}\left[p_i(y)\log\frac{p_i(y)}{p_j(y)}+p_j(y)\log\frac{p_j(y)}{p_i(y)}\right].$$6 and $$D_{\mathrm{KL}}(i,j)=\frac{1}{2}\sum_{y\in\mathcal{Y}}\left[p_i(y)\log\frac{p_i(y)}{p_j(y)}+p_j(y)\log\frac{p_j(y)}{p_i(y)}\right].$$7 is $$D_{\mathrm{KL}}(i,j)=\frac{1}{2}\sum_{y\in\mathcal{Y}}\left[p_i(y)\log\frac{p_i(y)}{p_j(y)}+p_j(y)\log\frac{p_j(y)}{p_i(y)}\right].$$8 per client pair, with worst-case $$D_{\mathrm{KL}}(i,j)=\frac{1}{2}\sum_{y\in\mathcal{Y}}\left[p_i(y)\log\frac{p_i(y)}{p_j(y)}+p_j(y)\log\frac{p_j(y)}{p_i(y)}\right].$$9 for $\overline{C}_i$0 clients, though in practice the comparison is between uploaded clients and the server knowledge base, giving $\overline{C}_i$1. The topological metrics require $\overline{C}_i$2 per client, dominated by graph size. ClusterCast adds one extra push per semantically similar inactive client, and if the average cluster size is $\overline{C}_i$3, the additional messages per round are approximately $\overline{C}_i$4 (Yuan et al., 24 Jul 2025).

The reported empirical results are on 7 benchmarks split via Louvain and Metis into 20 clients, averaged over 5 runs. FedSA-GCL outperforms the best baseline by $\overline{C}_i$5 overall accuracy on the Louvain split and by $\overline{C}_i$6 on the Metis split. When convergence is measured in client trips to reach target accuracy, FedSA-GCL requires approximately 149 client trips on Louvain versus FedBuff’s approximately 807 and FedAvg’s approximately 1483, and approximately 130 on Metis versus FedBuff’s approximately 269 and FedAvg’s approximately 1237 (Yuan et al., 24 Jul 2025). Ablation results on Cora and PubMed under the Metis split show that using only label-divergence clustering or only topological-distance clustering yields moderate gains over FedBuff, that combining both yields the best convergence speed and final accuracy, that turning off ClusterCast increases required trips by more than $\overline{C}_i$7, and that removing staleness weighting slows late-stage convergence and lowers final accuracy by approximately $\overline{C}_i$8 (Yuan et al., 24 Jul 2025). Within its stated scope, ClusterCast is therefore presented as a specific remedy for semantic drift and representational inconsistency in asynchronous federated graph learning.

4. ClusterCast in cache-enabled cloud RAN

In cache-enabled cloud radio access networks, ClusterCast refers to content-centric multicast transmission in which multiple base stations connected to a central processor cooperatively serve users requesting the same content (Zhou et al., 2015). The system model has $\overline{C}_i$9 multi-antenna base stations connected to a central processor via finite-capacity backhaul links, with each base station $Q_i$0 having $Q_i$1 antennas and a local cache of size $Q_i$2. There are $Q_i$3 single-antenna users and a library of $Q_i$4 independent contents. Users requesting the same file form multicast group $Q_i$5, denoted by the user set $Q_i$6, and are served by a dynamically chosen cluster of base stations $Q_i$7 (Zhou et al., 2015).

The beamforming variable for group $Q_i$8 is the aggregate network-wide beamformer

$Q_i$9

where $$D_{\mathrm{topo}}(i,j)=\bigl|\overline{C}_i-\overline{C}_j\bigr|+\bigl|Q_i-Q_j\bigr|.$$0 is the beam for base station $$D_{\mathrm{topo}}(i,j)=\bigl|\overline{C}_i-\overline{C}_j\bigr|+\bigl|Q_i-Q_j\bigr|.$$1. Base station $$D_{\mathrm{topo}}(i,j)=\bigl|\overline{C}_i-\overline{C}_j\bigr|+\bigl|Q_i-Q_j\bigr|.$$2 is in $$D_{\mathrm{topo}}(i,j)=\bigl|\overline{C}_i-\overline{C}_j\bigr|+\bigl|Q_i-Q_j\bigr|.$$3 if and only if $$D_{\mathrm{topo}}(i,j)=\bigl|\overline{C}_i-\overline{C}_j\bigr|+\bigl|Q_i-Q_j\bigr|.$$4, equivalently

$$D_{\mathrm{topo}}(i,j)=\bigl|\overline{C}_i-\overline{C}_j\bigr|+\bigl|Q_i-Q_j\bigr|.$$5

For a user $$D_{\mathrm{topo}}(i,j)=\bigl|\overline{C}_i-\overline{C}_j\bigr|+\bigl|Q_i-Q_j\bigr|.$$6, the received signal is

$$D_{\mathrm{topo}}(i,j)=\bigl|\overline{C}_i-\overline{C}_j\bigr|+\bigl|Q_i-Q_j\bigr|.$$7

and the SINR constraint is

$$D_{\mathrm{topo}}(i,j)=\bigl|\overline{C}_i-\overline{C}_j\bigr|+\bigl|Q_i-Q_j\bigr|.$$8

The joint design problem minimizes total network cost

$$D_{\mathrm{topo}}(i,j)=\bigl|\overline{C}_i-\overline{C}_j\bigr|+\bigl|Q_i-Q_j\bigr|.$$9

which explicitly trades transmission power against backhaul cost (Zhou et al., 2015).

The problem is non-convex because of the mixed $$M(i,j)=\alpha D_{\mathrm{KL}}(i,j)+(1-\alpha)D_{\mathrm{topo}}(i,j), \quad \alpha\in[0,1],$$0-norm, the fractional SINR constraints, and the implicit rank-one constraints under lifting. The proposed solution uses semidefinite relaxation, smooth concave approximations of the $$M(i,j)=\alpha D_{\mathrm{KL}}(i,j)+(1-\alpha)D_{\mathrm{topo}}(i,j), \quad \alpha\in[0,1],$$1 term, and a difference-of-convex programming algorithm. Three smooth surrogates are given for the sparsity term:

$$M(i,j)=\alpha D_{\mathrm{KL}}(i,j)+(1-\alpha)D_{\mathrm{topo}}(i,j), \quad \alpha\in[0,1],$$2

with $$M(i,j)=\alpha D_{\mathrm{KL}}(i,j)+(1-\alpha)D_{\mathrm{topo}}(i,j), \quad \alpha\in[0,1],$$3 controlling smoothness (Zhou et al., 2015). The DC algorithm linearizes the concave part around the previous iterate, solves a convex SDP at each step, and yields a monotonic decrease of the objective to a stationary point.

The reported simulations use $$M(i,j)=\alpha D_{\mathrm{KL}}(i,j)+(1-\alpha)D_{\mathrm{topo}}(i,j), \quad \alpha\in[0,1],$$4 base stations with $$M(i,j)=\alpha D_{\mathrm{KL}}(i,j)+(1-\alpha)D_{\mathrm{topo}}(i,j), \quad \alpha\in[0,1],$$5, $$M(i,j)=\alpha D_{\mathrm{KL}}(i,j)+(1-\alpha)D_{\mathrm{topo}}(i,j), \quad \alpha\in[0,1],$$6 contents, $$M(i,j)=\alpha D_{\mathrm{KL}}(i,j)+(1-\alpha)D_{\mathrm{topo}}(i,j), \quad \alpha\in[0,1],$$7 users per slot, per-base-station power $$M(i,j)=\alpha D_{\mathrm{KL}}(i,j)+(1-\alpha)D_{\mathrm{topo}}(i,j), \quad \alpha\in[0,1],$$8 W, and SINR target $$M(i,j)=\alpha D_{\mathrm{KL}}(i,j)+(1-\alpha)D_{\mathrm{topo}}(i,j), \quad \alpha\in[0,1],$$9 dB. With popularity-aware caching, caching $M(i,j)\le \tau$0 of the library per base station reduces backhaul by approximately $M(i,j)\le \tau$1, and caching $M(i,j)\le \tau$2 yields up to $M(i,j)\le \tau$3 backhaul reduction. Popularity-aware caching outperforms random caching, giving backhaul cost $M(i,j)\le \tau$4 lower for the same transmit power. Multicast ClusterCast achieves approximately $M(i,j)\le \tau$5 dB transmit-power savings over unicast with the same QoS, and at $M(i,j)\le \tau$6 dBm total power the backhaul cost is only one third of the unicast scheme (Zhou et al., 2015). In this literature, ClusterCast is therefore a sparse, optimization-based content-delivery mechanism rather than a learning-theoretic broadcast policy.

5. Cluster-sending, Byzantine communication, and C3B

A third usage of the underlying idea arises in resilient inter-cluster communication. The Byzantine cluster-sending problem considers two disjoint clusters $M(i,j)\le \tau$7 and $M(i,j)\le \tau$8, where cluster $M(i,j)\le \tau$9 has $\tau$0 replicas, at most $\tau$1 Byzantine faulty, and at least $\tau$2 non-faulty, under the assumption $\tau$3 (Hellings et al., 2021). The required properties are that every non-faulty replica of $\tau$4 eventually receives $\tau$5, every non-faulty replica of $\tau$6 eventually confirms that $\tau$7 has received $\tau$8, and $\tau$9 never delivers $\tau=0.5$0 unless all non-faulty replicas of $\tau=0.5$1 agreed to send it (Hellings et al., 2021). The basic certified handshake is the two-message cs-step: a candidate sender $\tau=0.5$2 sends $\tau=0.5$3 to a candidate receiver $\tau=0.5$4, the receiver runs local consensus and obtains certificate $\tau=0.5$5, and then $\tau=0.5$6 is returned to $\tau=0.5$7, which confirms via local consensus (Hellings et al., 2021).

Three synchronous probabilistic protocols are then built on top of cs-step. In Pcs, a random sender-receiver pair is chosen in each trial. The one-trial success probability is

$\tau=0.5$8

and the expected number of trials is

$\tau=0.5$9

which is $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$00 whenever $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$01. If $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$02, then $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$03, and if $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$04, then $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$05 (Hellings et al., 2021). Ppcs adds pruning of failed pairs and guarantees termination with worst-case $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$06 steps while retaining the same expected bound. Plcs instead uses random permutations of cluster-covering lists and achieves worst-case $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$07, which the paper states is optimal, while still giving expected $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$08 communication (Hellings et al., 2021).

Picsou generalizes the inter-cluster communication problem to Cross-Cluster Consistent Broadcast between replicated state machines (Frank et al., 2023). In its formal definition, integrity requires that the receiver cluster delivers a message at most once and only if the sender cluster previously transmitted it, while eventual delivery requires that every transmitted message is eventually delivered (Frank et al., 2023). The normal flow assigns sender replicas in round-robin fashion according to the commit index, sends a single cross-cluster copy of message $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$09 from one sender replica to one receiver replica, and has the receiver internally reliable-broadcast $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$10 to all $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$11 replicas. The paper states that in steady state this costs $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$12 messages per message, characterized as the information-theoretic minimum to ensure that at least one honest receiver learns the message and then informs its peers (Frank et al., 2023).

The central acknowledgement primitive is the Quack. A receiver replica reports its cumulative acknowledgement value $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$13, and a sender regards message $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$14 as Quacked when

$$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$15

Duplicate Quacks can indicate that $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$16 was lost or held back, and a bounded $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$17-list of missing indices allows parallel recovery of gaps (Frank et al., 2023). The evaluation reports microbenchmarks on two clusters in Iowa with $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$18 to $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$19 replicas each, using $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$20 kB and $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$21 MB messages, where Picsou achieves $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$22–$$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$23 speedup over ATA at $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$24 kB and $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$25–$$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$26 at $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$27 MB; in geo-replication between Iowa and Hong Kong, throughput is approximately $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$28 MB/s for Picsou versus approximately $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$29 MB/s for ATA at $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$30, and approximately $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$31 MB/s versus approximately $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$32 MB/s at $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$33, yielding observed improvements of up to $$p_i(y)=\frac{\#\{\text{nodes of class }y\text{ on }G_i\}}{\sum_{y'}\#\{\text{nodes of class }y'\text{ on }G_i\}},$$34 (Frank et al., 2023). In this setting, ClusterCast-like dissemination is governed by fault thresholds, acknowledgements, retransmission policy, and RSM sequencing rather than by semantic or content similarity.

6. Comparative interpretation and recurring misconceptions

The principal misconception is to treat ClusterCast as a single method with a fixed algorithmic core. The cited works indicate otherwise. In FedSA-GCL, ClusterCast is a semantic-cluster broadcasting mechanism for asynchronous federated graph learning, with clustering defined by label-distribution divergence and graph topological characteristics and aggregation shaped by local smoothness confidence and staleness (Yuan et al., 24 Jul 2025). In cache-enabled cloud RAN, ClusterCast is a joint clustering-and-beamforming optimization problem in which sparsity of beamformers determines the serving base-station cluster and the objective explicitly couples power cost with backhaul cost (Zhou et al., 2015). In Byzantine cluster-sending and C3B, the relevant abstraction is not semantic clustering at all, but reliable communication between already formed fault-tolerant clusters, with correctness certified by consensus artifacts, acknowledgements, and retry logic (Hellings et al., 2021, Frank et al., 2023).

A second misconception is that “cluster-aware” always implies the same performance criterion. The federated graph learning work measures overall accuracy, robustness, and client trips to a target accuracy (Yuan et al., 24 Jul 2025). The cloud RAN work optimizes total network cost under QoS and per-base-station power constraints (Zhou et al., 2015). The resilient-systems works focus on expected message complexity, worst-case communication, metadata overhead, and cross-cluster throughput under failures (Hellings et al., 2021, Frank et al., 2023). These are not interchangeable objectives.

A plausible common abstraction is that all variants exploit cluster structure to reduce an otherwise more expensive global coordination pattern. In FedSA-GCL, cluster propagation reduces drift and accelerates convergence relative to synchronous or standard asynchronous baselines. In cloud RAN, sparse content-centric clustering reduces backhaul cost and can lower transmit power relative to unicast or uncached delivery. In resilient inter-cluster communication, structured sender-receiver selection and cumulative acknowledgements replace all-to-all forwarding with expected constant communication or constant metadata overhead. The technical content of “ClusterCast” is therefore domain-specific, but the recurring design pattern is selective dissemination constrained by cluster organization.