Experimental Setup

The experiments for this comparison were carried out using a Docker-based testbed running on a 40-core Intel Xeon server with 128 GB RAM. Each container represented one node in the monitoring network. 

Both systems were tested under identical conditions to ensure fairness and both systems were allowed to run until all participating nodes had received the necessary monitoring data. Convergence was measured as the point at which each system met its defined synchronization condition. For DEMon [1, 2], this meant that every node had received state updates from all others. For FogMon2 [3,4], convergence was considered reached once all leaders had received updates about all nodes in the system.

Message Complexity in Focus

The findings show that in smaller setups, FogMon2 performs better in terms of total messages exchanged in smaller networks. Its hierarchical structure minimizes redundant gossip, as follower nodes report only to their assigned leaders. However, this efficiency deteriorates as the number of nodes increases. Above roughly 70 nodes, the message load in FogMon2 rises sharply, especially as more leader nodes are added to retain robustness. The system’s fixed leaders could create communication bottlenecks and reduce its ability to scale without exponentially increasing message volume.

DEMon, on the other hand, benefits from its gossip parameters. Although it starts off with higher message counts in small configurations, the system maintains linear or near-linear growth in message complexity as the network size increases. The decentralized gossip design ensures that every node contributes to the dissemination process, which distributes load evenly and avoids central bottlenecks. 

While FogMon2 becomes increasingly dependent on its leader nodes and could suffer from centrality issues, DEMon’s fully decentralized approach proves more scalable and robust. The comparison illustrates that DEMon, despite lacking a hierarchical structure, handles the growth of the system more gracefully. It achieves full data convergence without excessive message load and does so with lower sensitivity to the number of participating nodes.

Random Access Memory in Focus

In addition to message complexity, memory efficiency plays a crucial role in evaluating the scalability of monitoring frameworks. DEMon, developed as a Python prototype using Flask and in-memory state repositories, exhibits a higher RAM footprint per node compared to FogMon2. In contrast, FogMon2 is implemented in C++ and leverages lightweight sockets, resulting in significantly lower memory usage. While DEMon maintains consistent performance across larger systems, its resource consumption reflects its prototypical nature. FogMon2, with its leaner architecture, demonstrates more efficient memory handling, particularly in smaller deployments.