Hierarchical and Clustering-Based Timely Information Announcement Mechanism in the Computing Networks

Abstract

Information announcement is the process of propagating and synchronizing the information of Computing Resource Nodes (CRNs) within the system of the Computing Networks. Accurate and timely acquisition of information is crucial to ensuring the efficiency and quality of subsequent task scheduling. However, existing announcement mechanisms primarily focus on reducing communication overhead, often neglecting the direct impact of information freshness on scheduling accuracy and service quality. To address this issue, this paper proposes a hierarchical and clustering-based announcement mechanism for the wide-area Computing Networks. The mechanism first categorizes the Computing Network Nodes (CNNs) into different layers based on the type of CRNs they interconnect to, and a top-down cross-layer announcement strategy is introduced during this process; within each layer, CNNs are further divided into several domains according to the round-trip time (RTT) to each other; and in each domain, inspired by the “Six Degrees of Separation” concept from social propagation, a RTT-aware fast clustering algorithm canopy is employed to partition CNNs into multiple overlap clusters. Intra-cluster announcements are modeled as a Traveling Salesman Problem (TSP) and optimized to accelerate updates, while inter-cluster propagation leverages overlapping nodes for global dissemination. Experimental results demonstrate that, by exploiting shortest path optimization within clusters and overlapping-node-based inter-cluster transmission, the mechanism is significantly superior to the comparison scheme in key indicators such as convergence time, Age of Information (AoI), and communication data volume per hop. The mechanism exhibits strong scalability and adaptability in large-scale network environments, providing robust support for efficient and rapid information synchronization in the Computing Networks.

1. Introduction

With the rapid development of emerging technologies such as artificial intelligence, big data, and cloud computing, the scale of data has shown exponential growth, and the demand for computing resources has become more urgent [1,2,3]. Traditional centralized models can no longer meet the increasingly distributed and diverse computing scenarios. In response, the Computing Networks [4,5,6] have emerged as a novel infrastructure paradigm that orchestrates geographically distributed resources to support flexible allocation, efficient collaboration, and on-demand service delivery—similar to public utilities like water and electricity. Within this architecture, scheduling plays a central role in optimizing resource utilization and coordination, where timely and reliable announcements of computing resources are critical for informed and accurate decision-making [7].

In the Computing Networks, information announcement refers to the process by which various Computing Resource Nodes (CRNs, such as edge computing nodes, data centers, and supercomputers) publish and exchange their own computing information (including but not limited to available capacity, type, response latency, energy consumption metrics, and available services) via specific communication protocols and platforms [8,9]. The objective is to enable the Computing Network Nodes (CNNs) that interconnect to CRNs to obtain a comprehensive and timely view of all computing resource information in the system [10].

Information announcements typically adopt either a centralized or distributed architecture [10]. Centralized approaches, which rely on a central controller to manage all information, are simple and provide clear global visibility [10,11,12]. However, they face scalability issues, including communication bottlenecks and single points of failure. Distributed approaches, better suited to large-scale, heterogeneous deployments, allow nodes to exchange information autonomously for gradual consistency. Nonetheless, they suffer from high overhead and limited real-time performance. The dynamic nature of information requires frequent updates, and as the network grows, communication and processing burdens increase [9,13,14,15]. Meanwhile, delays during propagation raise the Age of Information (AoI) [16] and compromise information freshness and timeliness at the receiver. In the wide-area Computing Networks, these challenges are amplified, further increasing convergence time and AoI and leading to degraded scheduling performance.

Current research mainly targets overhead reduction while overlooking AoI. Even when AoI is considered, it is rarely a core optimization goal, resulting in minimal improvements [17]. Additionally, many approaches lack scalability and fail to adapt to growing network complexity. More importantly, they focus on basic resource-level data and ignore more dynamic service-level information [9,14], which is closely tied to changing demands and service capabilities. This leads to poor update accuracy and timeliness in dynamic environments, limiting flexible and efficient service orchestration.

Therefore, designing a synchronization mechanism that balances convergence time and communication overhead, improves information freshness, and scales effectively with network growth remains a significant challenge. To address this problem, this paper proposes an information announcement mechanism based on hierarchy and clustering for the wide-area Computing Networks. The main contributions are as follows:

• We propose a hierarchical and clustering-based distributed announcement mechanism to cope with large-scale node deployment, resource heterogeneity, and asynchronous state updates in wide-area Computing Networks. By structuring nodes into core, metropolitan, and edge layers and further partitioning each layer into RTT-constrained domains with controllable overlap, the mechanism reduces unnecessary synchronization overhead while maintaining timeliness.
• Aiming to solve additional forwarding delays from traditional bottom-up information aggregation, we design a top-down cross-layer broadcasting mechanism. Upper-layer nodes with the minimum average RTT are selected as primary nodes for lower-layer domains, proactively broadcasting information to lower layers and reducing the probability that lower-layer nodes need to forward task requests to upper-layer nodes when local resources are insufficient. This mechanism reconstructs the information flow direction, improving user satisfaction and reducing the overall task response delay under comparable communication overhead.
• To We enhance the convergence speed and information freshness within each domain by combining RTT-aware overlapping clustering with optimized path routing. Bridge nodes enable efficient progressive synchronization across cluster boundaries, while bidirectional concurrent routing minimizes intra-cluster delay. Experimental results demonstrate a significant reduction in the Age of Information (AoI) and convergence time compared to existing schemes.

The rest of this paper is organized as follows: Section 2 reviews the related work, focusing on the limitations of existing information announcement mechanisms in Computing Networks; Section 3 presents the proposed hierarchical and clustering-based synchronization architecture; Section 4 details the algorithmic design, including optimized canopy clustering algorithm and Ant Colony Optimization (ACO); Section 5 reports the simulation setup, performance evaluation, and analysis; Section 6 concludes the paper and outlines directions for future research.

2. Related Work

This section focuses on the related research of information announcement mechanisms, analyzing from two core perspectives: cross-layer information exchange and intra-layer information synchronization. Cross-layer synchronization concerns the methods used to transmit information across hierarchical layers. Cross-layer synchronization concerns both the directional flow of information across hierarchical levels and the spatial distribution of information from one layer within others. The choice of direction and distribution strategy significantly influences subsequent scheduling decisions. Intra-layer synchronization addresses the architectural model of mechanisms and the triggering mode of information exchange. By reviewing the key characteristics, this section provides an in-depth analysis of the advantages and limitations of each approach. These insights serve as a theoretical foundation and comparative reference for the design of the proposed mechanism, helping to clarify the research focus and identify the innovation points of this work. A summary of representative existing work and their characteristics is presented in

Table 1. Related works on computing information announcement.

Approach	Centralized or Distributed	Detailed Method	Advantages and Disadvantages
Based on the domain-name resolution mechanism [11]	Centralized	Use URLs to identify multi-level computing resources and allocate them through a centralized platform	Simple implementation and unified management of multi-level resources; limited reliability and scalability; the parsing process introduces additional latency
Unified centralized platform [12]	Centralized	Unified management of multi-level resources through SDN controller or NFV orchestrator	Easy to deploy and implement; limited scalability and low coordination efficiency between computing nodes and network attributes
Extended BGP routing protocol [13,15,18]	Distributed	Encapsulate information in sub-TLV format and announce it via BGP update messages	The sub-TLV format features a clear structure, making it easy to extend and well-suited for resource representation and dynamic evolution; BGP update frequency unsuitable for dynamic Computing Networks
Extended BGP based on information granularity [14]	Distributed	Localized maintenance for fast-changing fine-grained information and global announcement for slowly-evolving coarse-grained information	Reduce overhead; inaccurate information affects subsequent scheduling results
Multi-path announcement based on self-organizing map network [17]	Distributed	Use self-organizing map network to find multiple shortest paths and announce concurrently	Reduce convergence time; redundant transmission and scalability issues
Distributed service discovery scheme based on the Chord protocol [19]	Distributed	Service information is hashed and maintained by specific network nodes	Targeted dissemination of information to specific nodes to reduce overhead; essentially an extension of centralized storage, with issues of reliability and information collision
On-demand synchronization mechanism of service information based on information granularity layering and chord protocol [20]	Distributed	Static information is synchronized to the Chord ring, and dynamic information is maintained in each computing domain. When a service request arrives, the information is queried and updated	Reduce overhead; complex to implement and introduces query latency in subsequent scheduling

.

2.1. Cross-Layer Information Exchange Mechanism

Cross-layer information exchange is a common design pattern in hierarchical systems such as grid computing and P2P networks, where information is managed and aggregated across multiple levels. These architectures typically rely on supernodes or upper-layer coordinators to collect and aggregate data from lower layers in a bottom-up manner, forming a hierarchical control structure [21,22,23]. The rationale behind this design lies in its scalability and the ease of achieving global coordination, enabling efficient management of large-scale distributed resources. A study proposed a layered architecture for multi-domain resource allocation in grid computing. The lower domains report aggregated and abstracted information to the upper layer. After receiving the request, the lower layer uses a joint scheduling algorithm to allocate resources, and requests the upper layer when there are insufficient resources [24]. A five-layer distributed hierarchical mechanism with a root layer is proposed in study [25], which improves the fault tolerance and efficiency of service discovery in grid environments through multi-service instance caching and peer-layer direct communication.

However, such approaches often overlook the spatial locality of task arrivals. They emphasize bottom-up information aggregation while neglecting the actual origin of tasks. In latency-sensitive scenarios, tasks generated at lower-layer nodes typically need to traverse multiple layers for resource discovery and await scheduling decisions from higher-layer nodes, resulting in significant response delays. This design limits the adaptability and responsiveness of traditional hierarchical systems in dynamic and low-latency environments.

2.2. Intra-Layer Interaction Mechanisms

2.2.1. Centralized and Distributed Information Announcement Mechanisms

The centralized mechanism uses a single central control entity to lead the synchronization process of the information of the entire network. Under this architecture, all CRNs need to upload their own status information (such as remaining computing power, response delay, energy consumption indicators, etc.) to the central node through a standardized interface. The central node will master the information of the entire network and make scheduling decisions when tasks arrive. Some studies [12] adopt SDN controllers to centrally manage information reporting and task scheduling between cloud and edge computing nodes, thereby leveraging the advantages of cloud-edge collaboration. Mechanisms [11] based on domain-name resolution allow CRNs to register their status information with a resolution server, while scheduling nodes query this information to make scheduling decisions. Overall, centralized mechanisms have a clear architecture, making it easier to achieve unified management and ensure information consistency. They are well-suited for small-scale Computing Networks with concentrated nodes. However, as the network grows, the load on the central node increases significantly, leading to performance bottlenecks and single points of failure, which limit the system’s scalability and robustness—making it difficult to support large-scale, heterogeneous Computing Networks.

The distributed mechanism relies on autonomous interactions among nodes to disseminate and converge status information, without the need for a centralized control entity. In existing studies, some approaches [13,15,18] extend traditional routing protocols by embedding computing status information into routing updates; however, these methods often suffer from problems such as the mismatch between the update frequency of computing status information and that of network information. The main issue lies in the fact that routing table updates are typically low-frequency events. As a result, these protocols are designed to accommodate data synchronization needs on a timescale of minutes. In contrast, changes in computing status information occur much more frequently. Simply increasing the update frequency of routing protocols may lead to routing oscillations, significantly increasing routing overhead and severely compromising overall network performance [8]. Other research [14,20] effort classify computing status information into coarse-grained resource data, which changes slowly and is disseminated globally, and fine-grained service-level data, which varies rapidly and is maintained only within local computing clusters. Although this method reduces communication overhead to some extent, it may lead to inaccurate scheduling due to insufficient information granularity. Other study [17] model the information announcement problem as TSP, using multiple paths for information dissemination. Although this reduces system convergence time, the parallel transmission of multiple paths increases information redundancy and leads to higher network resource consumption.

2.2.2. Proactive and Passive Information Announcement Mechanisms

The proactive mechanism [26] is characterized by computing nodes autonomously disseminating their status information (such as resource utilization, service availability, etc.) to the network based on predefined triggering conditions, such as fixed time intervals or threshold changes in internal state. The aforementioned existing studies primarily adopt proactive information announcement mechanisms. This mechanism’s primary advantage lies in its ability to ensure the freshness of the information, enabling nodes across the network to promptly construct a dynamically updated global view. As a result, it is well-suited for highly dynamic environments where real-time scheduling decisions are critical. However, its main drawback stems from indiscriminate broadcasting of information, which can lead to redundant transmissions, thereby increasing communication overhead and processing burden on participating nodes.

In contrast, the passive mechanism follows a “request-response” model [26], where CRNs only transmit information to the scheduling node when tasks arrive. Research [19,20] based on the Chord protocol stores computing resource information within network nodes, querying and updating node information only upon task arrival. This mechanism effectively reduces unnecessary transmissions, improving bandwidth and energy efficiency, making it suitable for low-dynamic and low-interaction scenarios. However, its reliance on external queries limits the freshness of information, making it difficult to meet the real-time requirements of highly dynamic systems and potentially affecting the quality of scheduling decisions.

From the above review of related work, it is evident that distributed mechanisms are better suited for large-scale heterogeneous Computing Network environments, while proactive mechanisms are more aligned with the needs of high-frequency changes in computing state information. Based on these insights and inspired by prior research, this paper combines the advantages of distributed and proactive mechanisms to propose a hierarchical and clustering-based distributed proactive information announcement mechanism. The proposed mechanism aims to achieve a comprehensive optimization of information synchronization efficiency, communication overhead control, and dynamic adaptability to meet the practical technical requirements of Computing Networks.

3. System Architecture

This chapter elaborates on the overall architecture design of the information announcement mechanism for the wide-area Computing Networks, including the hierarchical architecture division principle, cross-layer information interaction strategy, and intra-layer information sharing and path optimization mechanism. This architecture achieves low-overhead and fast synchronization of information through a hierarchical and distributed design, and provides comprehensive and real-time information support for subsequent scheduling decision modules.

3.1. Overall Architecture Design

The fundamental characteristics of wide-area Computing Networks stem from the heterogeneity of computing resources coupled with their broad geographic distribution, posing significant challenges to the design of a unified information announcement mechanism capable of satisfying practical requirements. On one hand, indiscriminate synchronization across the entire network engenders a substantial escalation in communication overhead, while the cumulative delay inherent in long-distance transmissions markedly impairs information freshness—quantified by an increased AoI—thereby undermining the timely availability of data critical for real-time scheduling decisions. On the other hand, CRNs with disparate computational capacities exhibit distinct affinities for diverse service types: high-performance CRNs predominantly cater to “cold services” characterized by low real-time constraints, medium-performance CRNs support “warm services,” and edge CRNs accommodate latency-sensitive “hot services” demanding millisecond-level responsiveness. This heterogeneity induces variability in both the frequency of resource information updates and the tolerance for information latency. Consequently, adherence to a monolithic synchronization strategy results not only in suboptimal resource utilization but also in exacerbated mismatches between resource capabilities and task requirements.

Given the hierarchical characteristics [27] of CRNs in the wide-area Computing Networks in terms of scale and service suitability, as well as significant differences in synchronization frequency, scope, and timeliness requirements across levels, we proposes a structured adaptation strategy based on hierarchical management. We divides the CNNs into core layer, metropolitan layer and edge layer according to the types of CRNs to which they are interconnected, so as to organize the subsequent information announcement and coordination processes more efficiently. Furthermore, within each layer, considering the timeliness of information [28], CNNs are further divided into multiple domains based on latency constraints, in order to reduce unnecessary propagation and improve overall system efficiency.

As shown in Figure 1, the overall architecture of the announcement mechanism proposed in this paper consists of three core entities: CNNs, CRNs, and Gateway Nodes (GNs). CRNs are the fundamental units that provide computational services. They are widely distributed across different layers of the wide-area Computing Networks and exhibit significant heterogeneity. Based on their physical location and computational capacity, these nodes can be categorized into national or regional core data centers, city-level data centers, and edge computing nodes. Each CRN periodically reports its current status to its associated gateway, including but not limited to the types of services it supports (e.g., AI inference, real-time data processing, batch computing), available resource metrics (e.g., remaining CPU/GPU resources, memory capacity, bandwidth), and quality of service parameters (e.g., average response latency, load ratio, energy efficiency). The GNs server as the boundary interface for CRNs to access the Computing Networks. A GN typically connects to multiple CRNs that are geographically proximate and functionally similar, forming a logical “computing cluster”. The GN is responsible for aggregating, preprocessing, and managing the information from its associated CRNs, and for forwarding the processed information to the CNNs. CNNs are the key carriers responsible for the propagation and synchronization of information throughout the Computing Networks. A CNN can connect to multiple GNs, receive information reported by them, and exchange this information with other CNNs.

3.2. Intra-Domain Information Synchronization Mechanism

CNNs at the same layer often exhibit geographical proximity, resource homogeneity, and similar service responsiveness. To mitigate the timeliness degradation caused by long-distance transmission, nodes at the same layer are further partitioned into multiple domains based on latency constraints. In order to achieve fast synchronization and efficient sharing of information, this paper proposes an intra-domain information sharing mechanism that combines overlap clustering structure with intra-cluster path optimization.

This overlap clustering design is inspired by the Six Degrees of Separation concept and the Small-World Network phenomenon. First introduced by Hungarian writer Frigyes Karinthy in his 1929 short story Chains, the Six Degrees of Separation suggests that any two individuals can be connected through at most five intermediaries [29]. This idea was later empirically examined by Milgram (1967) in his small-world experiment, which found that the average social path length in the United States was approximately six [30]. The concept was further generalized into the theory of “small-world networks,” mathematically formalized by Watts and Strogatz (1998), where the network simultaneously exhibits high local clustering and short average path lengths that scale logarithmically with population size [31]. Since then, this principle has inspired extensive research across diverse domains, including social networks [29], epidemic spreading [32], and computer network design [33], highlighting its broad applicability to understanding and optimizing complex systems. In our mechanism, the individual clusters ensure the necessary high local connectivity (clustering), while the overlapping nodes (bridge nodes) act as the crucial “long-range shortcuts” or “social bridges” between otherwise disparate clusters. This structure allows information to hop efficiently from one cluster to another through a number of intermediate nodes, significantly reducing the average path length and ensuring information can be propagated across the domain efficiently, directly addressing the requirement for timely information acquisition.

Different from the traditional hard-division clustering strategy, this paper adopts an improved canopy [34] clustering algorithm with controllable overlap to cluster nodes in the domain according to the round-trip time (RTT) relationship between nodes, forming multiple local clusters with overlapping areas. The nodes within these overlapping areas can be regarded as bridge nodes belonging to multiple clusters. Structurally, these nodes exhibit high connectivity and dissemination capability, serving as relays for information forwarding in the intra-domain announcement mechanism. By controlling the number of bridge nodes in the overlapping regions, the system can achieve a balance between information timeliness and communication overhead. This overlapping clustering design brings significant advantages in information synchronization: on one hand, bridge nodes enable rapid aggregation and dissemination of information across clusters, greatly accelerating global convergence; on the other hand, redundant coverage improves the system’s fault tolerance against link failures and node departures, thereby enhancing overall robustness. The number and selection of bridge nodes are determined according to the improved Canopy clustering algorithm, which adaptively identifies nodes in the overlapping regions based on the RTT distribution within each domain. Detailed procedures for selecting bridge nodes in accordance with domain-specific latency characteristics are provided in the subsequent algorithm Section 4.2.

Within each domain, an improved fast clustering method is employed to divide CNNs into multiple overlap clusters, where CNNs located in the overlap regions are regarded as bridge nodes connecting multiple clusters. The information synchronization problem within each cluster is modeled as TSP to determine the shortest circular path. The nodes at both ends of this path simultaneously initiate information transmission, concurrently sending messages along the path toward the intermediate nodes, thereby forming a bidirectional concurrent re-transmission mechanism: in each dissemination round, once either endpoint receives back the message it originally sent, a new re-transmission round is triggered. During the dissemination process, when a node receives information from other nodes, it compares it with its existing local information; if it is new, the node stores it directly, and if a record with the same identifier already exists, it retains the version with the more recent timestamp. The node then appends its latest local state to the message before forwarding it to the next hop. Meanwhile, bridge nodes naturally perform cross-cluster information forwarding, participating in the announcement process to realize multi-round polling-based global progressive synchronization, effectively promoting overall network convergence speed and information timeliness. The mechanism is shown in Figure 2.

3.3. Inter-Layer Information Exchange Mechanism

Considering the differences in resource capabilities, service types, and latency constraints among CRNs at each layer, a reasonable cross-layer information announcement mechanism needs to be constructed to achieve efficient scheduling coordination. In contrast to traditional bottom-up aggregation strategies, this paper proposes a top-down mechanism, motivated by the following considerations: In wide-area Computing Networks, the majority of tasks enter the network via edge nodes, and scheduling requests are typically initiated at the edge. When local resources are insufficient to meet service demands, it becomes necessary to promptly discover and access available upper-layer resources to ensure service continuity and meet performance requirements, while avoiding excessive forwarding. Meanwhile, services hosted on upper-layer nodes generally exhibit higher tolerance to response latency. Thus, even if certain transmission delays are introduced during the cross-layer announcement process—resulting in a moderate decrease in information timeliness—the impact on subsequent scheduling decisions remains relatively limited.

To implement this top-down mechanism effectively, the network first performs domain partitioning based on latency constraints, which are determined according to the service characteristics of each layer. The boundary of each domain is defined based on “latency reachability”, meaning that any two nodes within the same domain must satisfy a predefined latency threshold to ensure real-time information interaction. After domains are formed, the system calculates the communication latency between each upper-layer candidate node and all nodes within a lower-layer subdomain. The node with the lowest average latency is selected as the primary node to act as the information relay. This primary node is then responsible for broadcasting the cross-layer announcement to all nodes in the lower-layer domain following the top-down principle, thereby ensuring the timeliness and efficiency of cross-layer information dissemination.

4. Cluster-Based Domain Synchronization: Improved Canopy Clustering Algorithm and Path Optimization

This section mainly introduces the clustering algorithm (Algorithm 1) involved in the above Section 3.2 and the algorithm for solving the optimal path within a cluster. Section 4.1 mainly introduces the clustering algorithm selected in this paper and its improvement, and Section 4.2 focuses on the complexity analysis of the intra-cluster path optimization algorithm. The overall algorithm flow chart is shown in Figure 3 below.

To address the inefficiency of each domain information synchronization in the wide-area Computing Networks—characterized by high redundancy, poor information freshness, and slow convergence—this section proposes an integrated strategy combining improved canopy clustering algorithm and ACO. The core idea is to first partition nodes into structured clusters with controllable overlap via the modified canopy clustering algorithm, then leverage ACO to optimize intra-cluster information propagation paths. This two-stage design ensures “rapid local synchronization within clusters” and “orderly progressive propagation between clusters,” laying the foundation for efficient domain information synchronization.

The canopy clustering algorithm [34] is an unsupervised pre-clustering algorithm introduced by Andrew McCallum, Kamal Nigam, and Lyle Ungar in 2000, often used in the pre-clustering stage of large-scale data. Unlike other clustering methods with hard partitions, canopy naturally forms overlapping regions through a double-threshold mechanism, allowing some nodes to belong to multiple clusters. This approach effectively preserves the topological features of original nodes and identifies key bridge nodes, while avoiding cluster fragmentation. Moreover, as a lightweight pre-clustering method, canopy does not require iterative optimization of cluster centers and has low computational complexity, making it suitable for real-time clustering in large-scale network scenarios.

4.1. Improved Canopy Clustering: Achieving Controllable Overlap and Eliminating Small Clusters

The basic canopy clustering algorithm relies on two distance thresholds ($T_1$ and $T_2$) to partition nodes: nodes within distance $T_1$ from a central node are grouped into a canopy, while nodes within $T_2$ (a stricter threshold) are marked as core nodes and excluded from subsequent clustering iterations. This mechanism naturally supports overlapping clusters, as nodes between $T_2$ and $T_1$ can belong to multiple canopies.

However, the original canopy algorithm encounters significant limitations when applied to large-scale network synchronization. Specifically, the overlap between clusters is entirely determined by manually set thresholds $T_1$ and $T_2$, resulting in random and unpredictable overlap sizes that can adversely affect inter-cluster information transmission efficiency and increase communication redundancy, thereby failing to satisfy the fine-grained control required in dynamic networks. In addition, clusters containing very few nodes, e.g., fewer than three nodes, do not provide meaningful intra-cluster path structures for synchronization, which is modeled as a TSP.

To address these issues, we propose two key improvements. First, to achieve controllable overlap, we analyze the relationship between the thresholds $T_1$ and $T_2$ and the resulting cluster overlap, and introduce an iterative adjustment mechanism that dynamically tunes the thresholds to converge to a target overlap ratio. This allows for orderly control of the overlap area, balancing information synchronization efficiency and communication overhead. Second, to improve intra-cluster path optimization and algorithm stability, clusters with very few nodes are merged during the clustering phase, ensuring that each cluster provides a meaningful path structure for subsequent TSP-based propagation. Finally, after the clustering operation is completed, ACO is run on each cluster to find the shortest ring path, and then concurrent ring traversals are performed from the starting point and the end point within each cluster.

Based on the above description, the improved algorithm steps are as follows:

1.

Input

This paper uses the RTT between nodes as the distance measurement. On the one hand, it is relatively easy to obtain, while the measurement of one-way delay is more complicated; on the other hand, the subsequent path transmission is a two-way communication. Therefore, after comprehensive consideration, the RTT is selected as a reasonable metric. Assume that there are m nodes in each domain, forming a node set $N=\{N_1,N_2,\dots ,N_m\}$, $t_{ij}$ represents the RTT between nodes $N_i$ and $N_j$, then the RTT matrix between m nodes is:

$$D=\left[\begin{array}{cccc}{t}_{11}& t_{12}& \cdots & t_{1m}\\ t_{21}& t_{22}& \cdots & t_{2m}\\ ⋮& ⋮& \ddots & ⋮\\ t_{m1}& t_{m2}& \cdots & t_{mm}\end{array}\right]\in {\mathbb{R}}^{m\times m}$$

(1)

2.

Determination of thresholds $T_1$ and $T_2$

The two thresholds play a crucial role in the canopy algorithm [35], determining the boundaries, density, and overlap of clusters. $T_1$ is a soft constraint that defines the “loose boundaries” of the cluster. Nodes whose distance from the central node is less than $T_1$ are included in the cluster, even if these nodes may belong to other clusters at the same time. A larger $T_1$ leads to clusters with more nodes, thereby expanding the scope of information sharing, but potentially increasing synchronization overhead. Conversely, a smaller $T_1$ results in more compact clusters with higher synchronization efficiency, yet may risk insufficient coverage of relevant nodes. $T_2$ is the hard constraint that defines the “core boundary” of the cluster. Its role is to reduce redundant calculations, avoid the repeated allocation of core nodes to multiple clusters, and ensure the compactness and exclusivity of each cluster. In this paper, we first obtain the average RTT based on the distribution of the RTT matrix between nodes:

$$\overline{t}={\displaystyle \frac{1}{m(m-1)}}\sum _{i\ne j}{t}_{ij}$$

(2)

Then determine the initial values of $T_1$ and $T_2$ based on this average as:

$$T_1=\overline{t},T_2={\displaystyle \frac{1}{2}}·\overline{t}$$

(3)

This simple proportional setting balances cluster coverage, core compactness, and computational efficiency. Such a configuration not only avoids blind parameter tuning but also provides a reasonable structural basis for subsequent optimization tasks, such as TSP path optimization and inter-cluster synchronization in the current study.

3.

Merging of Small Clusters and Adjustment of Overlap

After the initial clustering based on thresholds $T_1$ and $T_2$, two problems remain: the presence of trivial clusters containing too few nodes, and the lack of controllability in the resulting overlap size. To address these issues, clusters with fewer than three nodes are first merged into their nearest neighboring clusters, where the nearest cluster is determined by the minimum average RTT distance. This merging step is essential because the subsequent intra-cluster path optimization is modeled as a TSP, which requires at least three nodes to construct a meaningful cycle path.

Once small clusters are merged, the overlap can be measured by the average number of clusters to which each data point belongs. Formally, the overlap degree is defined as [34]:

$${\theta }_{\mathrm{actual}}={\displaystyle \frac{1}{m}}\sum _{i=1}^m\text{cover\_count}\left[i\right]$$

(4)

where $\text{cover\_count}[i]$ records the number of canopies that node $N_i$ belongs to. At present, there is no universally accepted standard for the appropriate range of overlap in canopy clustering. Most studies determine suitable overlap levels empirically, based on specific application scenarios. Notably, the baseline method adopted in this study [17] can be regarded as a special case of canopy clustering, in which all nodes are grouped into a single cluster and this cluster is duplicated multiple times to form pseudo-clusters. Experimental results from that work suggest that setting the overlap to 30% of the total number of data points yields favorable performance. Given that this study aims to perform explicit clustering of nodes, the overlap parameter should be constrained to a value below that. To control the expected overlap size, we define a target overlap value ${\theta }_{\mathrm{target}}$, given by

$${\theta }_{\mathrm{target}}=\lambda ·m$$

(5)

where $\lambda$ is a tunable parameter. In this study, we set

$$\lambda <=0.3$$

(6)

to ensure moderate overlap suitable for explicit node clustering. In scenarios with relatively few nodes, the overall cluster structures tend to be underdeveloped, and the transitional regions between clusters are often difficult to delineate. In such cases, the characteristics of bridging nodes—those that potentially connect multiple clusters—are typically less apparent. Moderately increasing $\lambda$ can help retain such boundary nodes across multiple clusters, thereby preserving potential structural connections and enhancing inter-cluster connectivity, which is beneficial for subsequent information propagation tasks.

As the number of nodes increases, cluster structures become more distinct, and the distribution of bridging nodes becomes more representative. The boundaries between clusters also become easier to identify. Under these conditions, $\lambda$ can be appropriately reduced to minimize redundancy and improve clustering efficiency, while still maintaining the overall structural connectivity of the network.

The size of the overlap is closely related to the threshold parameters $T_1$ and $T_2$: when $T_1$ is larger and $T_2$ is smaller, data points are more likely to be classified into multiple clusters, resulting in a higher overlap; conversely, the overlap is smaller. Therefore, adjusting these two thresholds is the key means to control the overlap.

Subsequently, $T_1$ and $T_2$ are adjusted according to the overlap of the clustering results. If the overlap is too large, $T_1$ is decreased while $T_2$ is increased; conversely, if the overlap is too small, $T_1$ is increased and $T_2$ is decreased. This adjustment process continues until:

$$|{\theta }_{\mathrm{actual}}-{\theta }_{\mathrm{target}}| < ϵ$$

(7)

where $ϵ$ is a small tolerance parameter controlling convergence.

4.

Cluster Path Optimization with ACO

Through the aforementioned clustering algorithm, each domain is divided into multiple overlapping clusters. Within each cluster, the core goal is to achieve efficient information synchronization among nodes, i.e., to quickly share local states and ensure a consistent global view. The efficiency of this synchronization process depends on the optimization of the information propagation path.

This synchronization requirement can be naturally abstracted as a Traveling Salesman Problem (TSP), where each node in the cluster is treated as a “city”, and the RTT between nodes is regarded as the “distance”. The objective is to find the shortest closed-loop path that visits all nodes, minimizing the total information propagation cost [36].

To solve this intra-cluster TSP, this paper adopts the Ant Colony Optimization (ACO) algorithm. The choice of ACO is motivated by two key reasons: (1) ACO is inherently inspired by biological foraging behavior, making it well-suited for path planning problems; (2) Thanks to the clustering strategy used in this work, each TSP instance involves only a small number of nodes, and since ACO’s computational complexity is quadratic in the number of nodes, clustering significantly reduces the overall computation, while preserving scalability for larger networks.

Based on the definitions and procedures described above, the complete clustering process is formally summarized in the following pseudocode (see Algorithm 1).

4.2. Complexity Analysis of the Improved Clustering Algorithm and ACO

The proposed method consists of two main stages: (1) improved canopy clustering with controlled overlap and small-cluster merging, and (2) cluster path optimization using ACO [37]. The computational complexity of each stage is analyzed as follows.

• Canopy Clustering Stage. Let m denote the number of nodes in a domain. For each iteration, the algorithm repeatedly selects a center node and assigns nodes to clusters based on distance thresholds $T_1$ and $T_2$. In the worst case, for each of the m nodes, distance comparisons are performed against all remaining unclustered nodes. Therefore, the worst-case complexity of a single clustering iteration is $O\left(m^2\right)$. The iterative adjustment of thresholds to achieve the target overlap requires at most $I_{\max }$ iterations. Hence, the overall complexity of the clustering stage is

  $$O(I_{\max }·m^2).$$
  The additional step of merging small clusters involves computing average distances to neighboring clusters. Assuming the total number of clusters after initial clustering is k, the merging step has complexity $O(k·m)$, which is typically smaller than $O(I_{\max }·m^2)$.
• Cluster Path Optimization with ACO. After clustering, each cluster contains $n_c$ nodes on average. For each cluster, the ACO algorithm constructs candidate TSP paths: Each ant traverses all $n_c$ nodes, and the selection of the next node requires $O\left(n_c\right)$ computations based on pheromone and heuristic values. For $m_a$ ants and T iterations, the per-cluster complexity is

  $$O(T·m_a·n_c^2).$$
  Since clustering limits the cluster size ($n_c\ll m$), the ACO stage is significantly more efficient than running ACO on all nodes globally. The total complexity across all clusters is

  $$O\left(T·m_a·\sum _c{n}_c^2\right),$$

  which is upper-bounded by $O(T·m_a·m·n_{\max })$, where $n_{\max }$ is the largest cluster size.
• Overall Complexity. Combining both stages, the total computational complexity of the proposed algorithm is

  $$O(I_{\max }·m^2+T·m_a·\sum _c{n}_c^2).$$

Algorithm 1 Improved Canopy Clustering with Overlap Control
Require:  Node set $N=\{N_1,N_2,\dots ,N_m\}$, distance matrix $D\in {\mathbb{R}}^{m\times m}$, initial thresholds $T_1,T_2$ ($T_1>T_2$), target overlap ratio $\lambda$, maximum iterations $max\_iter$, tolerance $\epsilon$, adjustment step $\delta$, minimum cluster size $s_{min}=3$, ACO parameters Ensure:  Cluster set $\mathcal{C}$, set of optimal paths $\mathcal{P}$ for each cluster
1:	Initialize $\mathcal{C}\leftarrow \varnothing$, $\mathcal{P}\leftarrow \varnothing$
2:	Initialize $cover\_count\left[i\right]\leftarrow 0$ for $i=1,2,\dots ,m$
3:	Let full node set $N_{\mathrm{unassigned}}\leftarrow N$
4:	Compute overlap target: ${\theta }_{\mathrm{target}}=\lambda ·m$
5:	$iter\leftarrow 0$
6:	repeat
7:	Reset clusters: $\mathcal{C}\leftarrow \varnothing$, $cover\_count\left[i\right]\leftarrow 0$ for all i
8:	while $N_{\mathrm{unassigned}}\ne \varnothing$ do
9:	Randomly select a center node $N_c\in N_{\mathrm{unassigned}}$
10:	Create a new cluster $C\leftarrow \{N_i\in N_{\mathrm{unassigned}}\mid t_{ic}<T_1\}$
11:	Add C to $\mathcal{C}$
12:	Remove nodes $N_j$ from $N_{\mathrm{unassigned}}$ where $t_{jc}<T_2$
13:	end while
▹ Merge clusters smaller than $s_{min}$ into nearest clusters
14:	for each cluster $C_k\in \mathcal{C}$ with $|C_k|<s_{min}$ do
15:	Find nearest cluster $C_{\mathrm{nearest}}$ minimizing average RTT between $C_k$ and $C_{\mathrm{nearest}}$
16:	Merge $C_k$ into $C_{\mathrm{nearest}}$
17:	Remove $C_k$ from $\mathcal{C}$
18:	end for
▹ Compute actual overlap after merging
19:	Update $cover\_count\left[i\right]$ for all nodes based on current clusters
20:	Compute ${\theta }_{\mathrm{actual}}={\displaystyle \frac{1}{m}}{\sum }_{i=1}^{m}cover\_count\left[i\right]$
▹ Adjust thresholds to approach target overlap
21:	if $|{\theta }_{\mathrm{actual}}-{\theta }_{\mathrm{target}}| > \epsilon$ then
22:	if ${\theta }_{\mathrm{actual}}>{\theta }_{\mathrm{target}}$ then
23:	$T_1\leftarrow T_1-\delta$,    $T_2\leftarrow T_2+\delta$
24:	else
25:	$T_1\leftarrow T_1+\delta$,    $T_2\leftarrow T_2-\delta$
26:	end if
27:	end if
28:	$iter\leftarrow iter+1$
29:	until  $|{\theta }_{\mathrm{actual}}-{\theta }_{\mathrm{target}}| \le \epsilon$ or $iter\ge max\_iter$
▹ Run ACO to find optimal intra-cluster TSP paths
30:	for each cluster $C_k\in \mathcal{C}$ do
31:	Extract submatrix $D_k$ from D corresponding to nodes in $C_k$
32:	Run ACO on $D_k$ to find shortest closed-loop path $P_k$
33:	Add $P_k$ to $\mathcal{P}$
34:	end for
35:	return $\mathcal{C}$, $\mathcal{P}$

In practice, due to small cluster sizes resulting from the canopy partitioning, the ACO stage does not dominate the overall computation, and the algorithm scales efficiently with the domain size. Additionally, the iterative threshold adjustment converges quickly in empirical settings. Thus, the first stage remains computationally feasible even for large-scale networks. Importantly, the proposed algorithm is primarily invoked during network deployment or periodic topology adjustments (e.g., when nodes join/leave the network or latency characteristics change significantly), rather than in real-time during continuous information propagation processes. This deployment scenario ensures that the computational complexity incurred during these discrete stages is acceptable, as it does not interfere with the real-time performance of ongoing information synchronization tasks.

5. Simulation Experiments and Results Analysis

This section conducts simulation experiments for the proposed architecture. Section 5.1 describes the design of the simulation experiment. Section 5.2 evaluates the performance of the inter-layer information exchange mechanism, using evaluation indicators including satisfaction with the subsequent scheduling results, latency reduction rate, and load balancing of the subsequent computing cluster. Section 5.3 evaluates the intra-cluster information synchronization mechanism based on overlapping clusters, mainly testing the convergence time within the domain, AoI, and the communication overhead.

5.1. Design of the Simulation Experiment

This subsection provides a detailed introduction to the experiment design from three aspects: experimental environment, experimental topology, and parameter design.

The experiments are simulated using Python 3.10.9, and the network topology is based on the previously described hierarchical and domain-partitioned architecture. The number of nodes in each layer and the inter-domain delay parameters are determined according to actual Computing Network deployment scenarios and relevant survey results (see survey [38]). In the simulation of the inter-layer information interaction mechanism, the numbers of large, medium, and edge nodes are set to 3, 9, and 45, respectively, corresponding to 1 core domain, 3 intermediate domains, and 9 edge domains. The delay is constrained as follows: within edge domains, the delay is kept under 5 ms; within intermediate domains, under 10 ms; and within the core domain, under 20 ms.

For the intra-domain information mechanism tests, to evaluate the performance under varying node densities, the number of nodes within each domain is set between 4 and 40. The intra-domain delay parameters remain consistent with those used previously. In addition, it is assumed that users are connected to access network nodes and computing clusters are connected to gateways via dedicated links, and that the transmission delay between them is negligible.

This experiment also involves user request information and cluster resource data. As there is currently no publicly available dataset for user request QoS requirements, we refer to several studies [39] and classify requests into three latency categories: low (10 ms), medium-low (50 ms), and high (100 ms), accounting for 20%, 60%, and 20% of the total requests, respectively. The required success rates are set at 95% for low-latency requests, 90% for medium-low, and 80% for high-latency requests, with each 5% increment representing a different level.

To improve simulation efficiency, the system is assumed to support 20 service types, each divided into different quality levels based on processing latency. Resource data for computing nodes are derived from the Alibaba cluster trace dataset [40], which includes resource configurations, utilization rates, deployed applications, and runtime data from multiple servers. These are statistically processed to generate the resource dataset for the experiments. Service processing latency data are taken from the QWS2 public dataset [41], which contains QoS metrics for 2057 real-world web services. The experimental schematic diagram is shown in Figure 4.

5.2. Experimental Results of Cross-Layer Information Interaction Mechanism

This experiment aims to verify the effectiveness of the top-down information interaction mechanism in the layered architecture; that is, the upper primary node broadcasts its own information to the secondary nodes in the lower domain. The comparison mechanism uses the typical bottom-up aggregation method in grid computing or P2P systems. The evaluation indicators include subsequent scheduling performance: user satisfaction and task-delay reduction rate. It should be noted that the scheduling mechanism used is the classic layer-by-layer access strategy in grid computing and P2P systems. The experimental parameters involved in this experiment are shown in

Table 2. Simulation Parameters Configurations for Cross-Layer Information Interaction.

Parameter	Description
Data Set	https://github.com/alibaba/clusterdata, accessed on 16 July 2025 https://qwsdata.github.io/, accessed on 16 July 2025
Number of Edge Network Nodes	45
Number of Medium Network Nodes	9
Number of Large Network Nodes	3
Delay constrains of request	(0 ms, 10 ms], (10 ms, 50 ms], (50 ms, 100 ms]
Delay between Edge Network Nodes (in same domain)	(0 ms, 5 ms]
Delay between Medium Network Nodes (in same domain)	(5 ms, 10 ms]
Delay between Large Network Nodes (in same domain)	(10 ms, 20 ms]
Number of request	10/30/60/90/120/150
Number of Service type	20
Service number of each cluster	100 (Large)/80 (Medium)/60 (Edge)

:

User satisfaction refers to the proportion of service requests that are successfully completed under a given latency constraint. Specifically, each type of request has a corresponding success rate requirement based on its latency level. If the task is completed within the specified time, it is considered a “satisfactory” service. In the experiment, user satisfaction is calculated by counting the proportion of all requests that meet the required level, reflecting the ability of the scheduling mechanism to meet user QoS requirements. The task-delay reduction rate is used to measure the effectiveness of the scheduling mechanism in optimizing task response time. It is defined as the ratio of the difference between the maximum acceptable task delay and the actual processing delay (including calculation and transmission) to the maximum delay. A higher delay reduction rate indicates that the system can process tasks more efficiently and shorten the user’s waiting time.

As shown in Figure 5, experimental results demonstrate that the proposed top-down information interaction mechanism significantly outperforms the traditional bottom-up aggregation approach in terms of both user satisfaction and task-delay reduction rate. This improvement is mainly attributed to the optimization of information distribution. By proactively disseminating scheduling information from upper-layer nodes to lower-layer nodes, the latter gain direct access to a more comprehensive view of available resources, rather than being limited to local or neighboring information.

When a task arrives at a lower-layer node and local resources are insufficient, the node can directly select an appropriate upper-layer node for task forwarding based on the global view it has already obtained—without the need to escalate the task step by step to an upper-layer primary node for centralized scheduling. This significantly reduces intermediate transmissions within the network and lowers the overall scheduling response time. On one hand, this simplification of the scheduling path increases the likelihood that tasks will be completed within their latency constraints, thereby improving user satisfaction. On the other hand, faster task response contributes to a higher delay reduction rate. These results indicate that the top-down information synchronization mechanism effectively enhances the efficiency and accuracy of scheduling decisions, thereby improving the overall service performance of the system.

5.3. Experimental Results of Intra-Domain Mechanism

This experiment aims to validate the effectiveness of the proposed intra-domain information synchronization mechanism based on overlap clusters. The main algorithms and parameter configurations used in the experiment are shown in

Table 3. Simulation Configurations for Intra-Domain Information Synchronization.

Parameter	Description
Number of CNNs in one layer ($N_d$)	[60, 100, 140, 180, 250, 500, 1000]
Number of CRNs connected to a CNN via GNs	5
Information update probability	0.5
RTT between CNNs in the same domain	(0 ms, 10 ms]
overlap parameter $\lambda$	0.3 ($N_d$ ≤ 100); <0.3 ($N_d$ > 100)

. To comprehensively evaluate the performance of the mechanism, three key metrics are measured and compared: intra-domain convergence time, Age of Information (AoI), and communication overhead.

The comparison mechanisms include two categories: one is the RSOM-based multipath transmission mechanism [17], and the other consists of several typical path optimization algorithms without clustering, including Tabu Search (TS) [42], Simulated Annealing (SA) [43], Greedy algorithms (GA) [44] and Graph Neural Network (GNN) [45]. These mechanisms represent common approaches in current path planning and are used to analyze the advantages of the proposed overlap cluster mechanism in terms of intra-domain information synchronization and propagation efficiency.

By experimentally comparing these three metrics under different mechanisms, we can more intuitively reflect the overall performance of the overlap cluster design in improving synchronization efficiency, reducing AoI, and controlling communication overhead. The related experimental results will be presented and analyzed in detail in the following sections.

5.3.1. Convergence Time Analysis

Convergence time refers to the duration from the moment the information is generated by any node until all nodes within the domain have received that information—that is, until each node has completed synchronization with all other nodes. It is a key metric for evaluating the efficiency of information synchronization. In the experiment, the convergence time is defined as the time taken by the last node to reach synchronization.

As shown in Figure 6, experimental results show that the proposed clustering-based mechanism significantly reduces the convergence time, outperforming both the RSOM-based multipath scheme and traditional single-path optimization scheme. This improvement is mainly attributed to the critical role of bridge nodes. Although the multi-path mechanism uses multiple parallel paths with different starting points and theoretically has a certain degree of concurrency, its path structure lacks optimization compared to the clustering-based mechanism with a clear structure. The repetition of its nodes mainly comes from the random overlap between paths, and it fails to fully utilize or tap the differentiated capabilities between nodes. In single-path mechanisms, nodes must wait to receive information from others along often lengthy transmission paths, resulting in longer convergence times. In contrast, the clustering-based mechanism uses bridge nodes as connectors between different clusters, allowing nodes within a cluster to partially access information from other clusters through these bridges. Repeated and rapid exchanges via these bridge nodes enable efficient inter-cluster information propagation, substantially accelerating global synchronization and shortening the overall convergence time.

5.3.2. AoI Comparison

AoI measures the freshness of the information held by a node. It is defined as the time difference between the node’s own convergence time and the timestamps of all the information it has received. Essentially, AoI reflects the degree of “information delay”; the lower the AoI, the more punctual the information available to the node.

Experimental results show that the proposed mechanism significantly outperforms the comparison schemes, including the RSOM multipath mechanism and non-clustered single-path scheme, in terms of AoI performance. As shown in Figure 7, across varying node counts and update frequencies, the clustering mechanism consistently maintains a low average AoI, demonstrating good stability.

The main reason for the improved AoI is the clustering mechanism. By dividing the entire domain into several smaller clusters and achieving high-frequency, rapid information synchronization within each cluster, the number of nodes per cluster is greatly reduced, significantly accelerating the synchronization process and ensuring that each node obtains fresher and more timely information. Bridge nodes, acting as critical connectors between clusters, establish “shortcuts” across clusters, allowing nodes to receive the latest information from multiple clusters in a shorter time and effectively reducing information aging.

In contrast, although the multipath mechanism can reduce AoI to some extent through path overlap, the generally long paths limit its improvement effect. In the single-path mechanism, information propagation relies solely on a single long path, causing some nodes to experience long delays in receiving the latest information, resulting in higher overall AoI values.

5.3.3. Communication Overhead Evaluation

In this experiment, we use the node communication overhead at convergence as a key metric to evaluate system efficiency. Inspired by the per-hop energy consumption metric in research [46], this paper introduces the metric—per-hop transmitted data—to reflect the cumulative communication overhead across the network. It is defined as the total amount of data generated by all announcement messages during the convergence process, divided by the total number of hops. This reflects the average amount of data each node needs to process in order to achieve convergence.

As shown in Figure 8, the proposed mechanism demonstrates superior performance in terms of communication overhead, slightly outperforming the multi-path mechanism and significantly outperforming the traditional single-path strategy.

Specifically, although the multi-path mechanism involves relatively long messages, it benefits from fewer transmission rounds due to concurrent paths, which helps control the average per-node overhead. In contrast, the clustering-based approach involves more frequent message exchanges during convergence due to repeated intra- and inter-cluster interactions, but the messages are shorter and more concise. Additionally, the limited scope of intra-cluster propagation helps reduce the overall data processing burden per node. By comparison, the single-path mechanism transmits longer messages over longer routes with more hops. As a result, nodes are required to process significantly more data during forwarding, leading to a noticeably higher communication overhead.

In summary, the proposed clustering-based mechanism not only ensures efficient information synchronization but also effectively reduces per-node communication processing pressure, demonstrating better resource efficiency in large-scale and dynamic network environments.

6. Conclusions

Accurate synchronization of the information is critical for ensuring resource coordination and service quality in the wide-area Computing Networks. To address the insufficient attention to the freshness of the information in existing announcement mechanisms, this paper proposes a hierarchical top-down cross-layer information interaction mechanism and an intra-domain synchronization mechanism based on clustering. The former enhances the scheduling responsiveness of lower-layer nodes by proactively distributing a global view from upper-layer nodes; the latter employs latency-aware clustering and bridge nodes to achieve rapid polling updates within clusters and efficient inter-cluster transmission, significantly shortening convergence time, reducing the AoI, and lowering communication overhead. Simulation experiments verify that the proposed mechanisms outperform traditional multi-path and single-path schemes under various scales and update frequencies, demonstrating good stability and scalability, and are particularly well suited to dynamic and complex wide-area computing environments.

Future research will focus on the following directions: first, exploring adaptive adjustment strategies for cluster structures in dynamic environments, studying how to optimize cluster partitioning and overlapping relationships based on network latency, node status, and load variations to improve the flexibility and efficiency of information synchronization; second, conducting in-depth analyses of the characteristics and selection mechanisms of bridge nodes, evaluating how different node features impact inter-cluster information propagation performance, aiming to identify more reasonable bridge-node configurations to optimize inter-cluster communication paths and overall synchronization performance; third, extending the study to realistic deployment scenarios and dynamic workload designs, where challenges such as accurate RTT acquisition, unstable online/offline behavior of edge nodes, and bursty traffic patterns need to be considered. Future validation on SDN-enabled prototype platforms (e.g., Mininet, NS-3, or P4 switches) and the incorporation of enriched traffic models with diurnal patterns and mobility-induced topology changes will help demonstrate the robustness of the proposed mechanisms under realistic dynamics, while also guiding parameter adaptation (e.g., cluster overlap ratio, bridge-node density) in live deployments.