A Survey on Open-Source Edge Computing Simulators and Emulators: The Computing and Networking Convergence Perspective

Abstract: Edge computing, with its low latency, dynamic scalability, and location awareness, along with the convergence of computing and communication paradigms, has been successfully applied in critical domains such as industrial IoT, smart healthcare, smart homes, and public safety. This paper provides a comprehensive survey of open-source edge computing simulators and emulators, presented in our GitHub repository (https://github.com/qijianpeng/awesome-edge-computing), emphasizing the convergence of computing and networking paradigms. By examining more than 40 tools, including CloudSim, NS-3, and others, we identify the strengths and limitations in simulating and emulating edge environments. This survey classifies these tools into three categories: packet-level, application-level, and emulators. Furthermore, we evaluate them across five dimensions, ranging from resource representation to resource utilization. The survey highlights the integration of different computing paradigms, packet processing capabilities, support for edge environments, user-defined metric interfaces, and scenario visualization. The findings aim to guide researchers in selecting appropriate tools for developing and validating advanced computing and networking technologies.

• The paper provides a comprehensive review of over 40 open-source edge computing simulators and emulators, categorizing them by packet-level, application-level, and emulation techniques.
• It examines the tools across five dimensions—including computing paradigms, resource simulation, performance metrics, resource management, and usability—to reveal their practical capabilities and limitations.
• The paper outlines future research directions focusing on integrated computing paradigms, enhanced environmental simulation, and flexible user-defined metrics and visualization support.

This paper, "A Survey on Open-Source Edge Computing Simulators and Emulators: The Computing and Networking Convergence Perspective" (2505.09995), provides a comprehensive review of over 40 open-source tools for simulating and emulating edge computing environments, with a focus on the convergence of computing and networking. It highlights the challenges in validating ideas in large-scale real-world edge scenarios and positions simulation and emulation as crucial enabling technologies.

The survey categorizes these tools into three types based on their implementation level:

1. Packet-level Simulators: These simulate individual packet behavior and are suitable for analyzing protocols and low-level network performance (e.g., NS-3 [nsnam], OMNeT++ [omnetpp], ndnSIM [ndnsim]). They provide fine-grained metrics but can be computationally expensive for large scales.
2. Application-level Simulators: These abstract packet-level details to focus on higher-level system and application behaviors, such as resource management and task scheduling across distributed systems (e.g., CloudSim [cloudsim], iFogSim [ifogsim2], EdgeCloudSim [edgecloudsim], faas-sim [faas]). They are more scalable for large networks but may lack detailed network fidelity.
3. Emulators: These run real application code on physical or virtualized infrastructure, providing higher fidelity and realism compared to simulators (e.g., Mininet [mininet], MaxiNet [maxinet], Shadow [shadow2], Fogify [fogify], CORE [core], DFaaS [dfaas]). They are useful for real-world testing and debugging but typically scale less than simulators.

The paper evaluates the tools across five dimensions:

1. Supported Computing Paradigms: The tools cover a spectrum of paradigms including Cloud, Fog, Edge, In-Network Computing, Serverless, Mist, and specialized environments (e.g., V2X, Satellite Edge). Many newer tools support multiple paradigms, reflecting the convergence trend. For instance, CloudSim derivatives (like CloudSimSDN [cloudsimsdn] and EdgeCloudSim [edgecloudsim]) extend traditional cloud simulation to include edge and fog layers. Packet-level simulators like NS-3 and OMNeT++ are foundational and can be extended to support in-network computing scenarios (e.g., NS-3 with EasiEI [easiei] or OMNeT++ with Simu5G [simu5g]). Specialized tools like SatEdgeSim [satedgesim] and Artery [artery] focus on specific domains. A key lesson is that while specialized tools offer deep support, multi-paradigm tools are becoming crucial for converged environments, although integrating dynamic distributed systems remains challenging.
2. Resource Simulation: Tools represent hardware resources with varying granularity. Basic representations model simple components like CPU, memory, and storage (e.g., SimGrid [simgrid], faas-sim [faas]). Advanced representations model complex entities like VMs, physical machines, edge devices, satellites, or specific network nodes (e.g., CloudSim [cloudsim], EdgeCloudSim [edgecloudsim], SatEdgeSim [satedgesim], Simu5G [simu5g]). These can be general-purpose (VMs, clusters) or domain-specific (mobile devices, satellites). Communication protocols are handled differently: packet-level simulators support detailed protocol stacks (e.g., NS-3 [nsnam] supports various TCP/IP variants), while application-level simulators often use abstract delay models (e.g., CloudSim [cloudsim]). The paper notes that simulating environmental factors (like temperature) that affect edge performance is largely missing, except for some ITS simulators like Artery [artery] which model weather effects.
3. Performance Metrics: Tools support basic metrics such as latency, throughput, energy consumption, and resource usage. Packet-level simulators provide fine-grained network metrics (jitter, packet loss), while application-level simulators focus on higher-level task or service metrics (execution time, migration delay). Support for custom metrics is inconsistent, with only a few simulators offering dedicated interfaces for user-defined measurements (e.g., NS-3 [nsnam] via its tracing system, YAFS [yafs] via Stats/Metrics). System-wide performance metrics like scalability (maximum supported nodes) vary significantly, with application-level simulators generally supporting larger scales (e.g., PeerSim [peersim] over $10^7$ nodes, CloudSim [cloudsim] variants up to 1 million nodes) compared to packet-level simulators or emulators, although emulators can scale through distributed execution (e.g., Shadow [shadow2], StarryNet [starrynet]).
4. Resource Management and Utilization: Tools differ in how they model resource allocation and scheduling. Allocation can be node-level (e.g., using containers or VMs in emulators like Mininet [mininet] or Fogify [fogify]) or unit-level (allocating CPU cycles, bandwidth, memory units in simulators like CloudSim [cloudsim] or SimGrid [simgrid]). Many tools support standard scheduling policies (FCFS, Round Robin) and some offer advanced or user-defined policies (e.g., RL-based in CloudSimPy [cloudsimpy], genetic algorithms in VirtFogSim [virfogsim], mobility-aware in iFogSim [ifogsim2]). Cost management or optimization targets (e.g., minimizing latency, energy, maximizing resource utilization) are often built-in and specific to the simulator's focus, though user-defined targets are increasingly supported. The paper notes that fundamental packet-level simulators and emulators typically do not have built-in optimization targets but allow users to implement them.
5. Usability: This dimension covers features like visualization, logging, configuration flexibility, and programming language support. Most tools are Discrete-Event Simulators (DES), while emulators and hybrid tools also exist. C/C++ are common for packet-level simulators, while Java is prevalent for application-level ones, and Python is popular for emulators and some simulators. Modular design, including distinct layers for services, hardware, networking, configuration, scenarios, logging, and visualization, enhances usability. Packet-level simulators and emulators generally have strong network visualization, while application-level simulators often lack detailed network visualization. Scenario scripting support is also a valuable usability feature, enabling easier configuration of complex experiments (e.g., CloudSim Express [cloudsimexpress], PureEdgeSim [pureedgesim]). Project popularity (stars, forks, contributors) is also considered as an indicator of community adoption and maintenance.

Based on the analysis, the paper identifies five key future directions:

• Integrating Computing Paradigms: Developing tools that seamlessly support multiple paradigms (Cloud, Fog, Edge, In-Network) and offer common libraries for tasks like scheduling.
• Packet Processing in Application-level Simulators: Incorporating packet-level details into application-level simulators to support research considering data content (e.g., AoI) alongside computation.
• Edge Environments Simulation Support: Adding modeling capabilities for environmental factors (weather, temperature) that influence performance in realistic edge deployments.
• User-defined Metric Interface Support: Providing flexible and standardized interfaces for users to define and calculate custom performance metrics, possibly leveraging database tools for easier analysis.
• Scenario Scripts and Visualization Support: Improving tools for defining complex, diverse scenarios and enhancing visualization capabilities, particularly for application-level simulators, to better represent distributed systems and network dynamics.

In conclusion, the survey provides a valuable reference for researchers navigating the complex landscape of open-source edge computing simulation and emulation tools, emphasizing their practical capabilities and identifying areas for future development to meet the evolving needs of computing and networking convergence.