Proximity-Aware VM Placement in Multi-Layer Fog Computing for Efficient Resource Management: Performance Evaluation Under a Gaming Application Scenario

Abstract

The rapid proliferation of mobile devices, particularly smartphones and tablets, has transformed digital entertainment, with mobile gaming emerging as one of the fastest-growing digital segments. Such applications are inherently latency-sensitive and require effective resource management and seamless mobility support. To overcome these issues, this paper suggests a four-layered infrastructure that combines edge, fog, and cloud computing with Software-Defined Networking (SDN) and is assisted by a lightweight proximity-aware heuristic placement strategy and mobility management. The suggested structure follows a microservices contained breakdown of the gaming functionality and uses clustering algorithms to permit coordinated access to resources by edge and fog nodes. A dynamic lightweight proximity-aware virtual machine placement algorithm is presented to deploy application modules nearer to the users depending on the availability and mobility of the resources. The proposed work is simulated using IFogSim2. The proposed model reduces the latency by up to 73 percent and the rate of task completion by 25 percent relative to baseline configurations in the case of dynamic mobility of users. These results indicate that the suggested strategy can be effective in improving the latency-sensitive mobile gaming applications performance in the edge-fog networks.

1. Introduction

The instantaneous growth in latency-sensitive applications has made a higher demand for effective resource management in edge and fog computing environments. Real-time gaming, augmented and virtual reality (AR/VR) applications, and Internet of Things (IoT) systems [1] need ultra-reliable low-latency communication (URLLC), scalable resource provisioning, and dynamic workload handling capabilities. The traditional cloud-centric model, along with a three-tier edge–cloud architecture, encounters difficulties in maintaining steady latency performance due to the lack of coordinated resource management across various layers. In this context, the advent of 5G and progressive smartphones has further redefined mobile applications [2], with gaming emerging as one of the fastest-growing sectors. Multiplayer gaming with console-level and real-time features is now possible on mobile devices due to enhanced bandwidth, low latency, and high connectivity. This change, accelerated by COVID-19 lockdowns, has led to exceptional user activity and revenue growth in mobile gaming [3], a trend that is anticipated to continue. Such grown traffic demands more robust infrastructure and service designs to ensure seamless back-end support and efficient handling of dynamic workloads. To satisfy these requirements, providers are increasingly moving processing closer to the edge to reduce latency, which is essential for supporting latency-sensitive applications such as First-Person Shooter (FPS) and Massively Multiplayer Online (MMO) games. However, traditional cloud-centric and three-tier edge–cloud architectures usually struggle to maintain consistent latency performance under dynamic user mobility and workload variations, mainly in the absence of coordinated resource management across layers.

Dynamic resource allocation, load balancing, and smart routing are made possible by Network Function Virtualization (NFV) and SDN [4] as they allow providers to maintain QoS without over provisioning. Due to the development of cloud gaming systems such as NVIDIA GeForce Now and Xbox Cloud Gaming [5], the need to have a high frame rate, low latency, and continuous service becomes even more important. Predictive orchestration is critical to resilience and scalability to handle demand spikes and avoid congestion. With mobile gaming increasingly becoming more immersive and resource-intensive, operators are required to provide real-time responsiveness and constant QoE using programmable networks with SDN emulation tools such as Mininet and MiniEdit, having to support the process [6]. However, SDN-based solutions are not complete solutions to mobility-sensitive service placement, there is also the fine-grained coordination of edge, fog, and cloud resources in the most dynamic gaming scenarios.

Gaming applications serve as the test environment that evaluates the resource management strategy presented in this research. The system needs to meet several strict requirements, which include maintaining low latency while enabling high interactivity and handling dynamic workload changes. Gaming workloads function as effective benchmarks that enable researchers to assess fog-based resource provisioning and VM placement strategy performance. The proposed approach extends its application range beyond gaming platforms, although the evaluation process uses gaming workloads for assessment. The underlying requirements of gaming systems—such as real-time responsiveness, mobility awareness, and efficient resource utilization—are also shared by several other emerging domains, including AR/VR applications, smart city services, autonomous systems, and real-time IoT analytics. Therefore, the results obtained from the simulation study provide meaningful insights into the applicability of the proposed approach across a broader class of latency-sensitive applications.

Efficient resource provisioning is crucial for achieving user satisfaction in latency-sensitive gaming, where edge nodes and fog nodes reduce delay and ensure responsiveness in FPS and VR applications. Architecture has a direct impact on task scheduling, offloading choices, and load balancing, especially in cases of dynamic user mobility. Though current simulation models, including iFogSim [7], iFogSim2 [8], YAFS [9], EdgeCloudSim [10], and PureEdgeSim [11], enable the analysis of edge–fog–cloud systems, they are typically used on binary or three-layer allocation models without much support for coordinated multi-layer mobility-aware placement. As the work at hand focuses on the provisioning and placement of application modules with proximity in mind rather than an in-depth analysis of the network protocol, iFogSim2 [12,13] is chosen due to its ability to support mobility, microservices, clustering, and hierarchical fog–cloud modeling. These features are well-matched with the suggested four-layered architecture and allow an orderly analysis of the dynamic placement of VMs in realistic mobility scenarios.

The main findings of this paper are summarized as follows:

• An edge–fog–cloud architecture with four layers is suggested to ensure fewer latency restrictions than traditional cloud-based gaming structures. The architecture strategically deploys computational nodes in a hierarchical network to provide scalable, resilient, and mobility-conscious service delivery to latency-sensitive gaming applications.
• A microservice architecture that separates monolithic gaming systems into small independent components that developers can deploy throughout edge and fog network infrastructures. This decomposition enables fine-grained offloading, elastic scaling, and efficient resource utilization, contributing to reduced service latency under dynamic user conditions.
• SDN-based control mechanism that is incorporated to assist in centralized traffic management and adaptive routing of game-related data flows. The SDN programmability within the framework makes the implementation more responsive and compliant with real-time performance demands in the context of multiplayer games.
• iFogSim2 is used to analyze the proposed architecture, and proximity-aware VM placement strategy allows analyzing user mobility, microservice-based deployment, and dynamic resource provisioning in a variety of edge–fog–cloud configurations.

The remainder of the paper is structured as follows: Section 2 presents a summary of the multiplayer games available on the market. This section also discusses resource allocation techniques aligned with the identified domain. Section 3 details the proposed system architecture. The results are discussed and analyzed in Section 4. Finally, Section 5 also brings the work to a close with possible future directions.

2. Related Works

Smartphones, social connectivity, and cloud infrastructure have made multiplayer gaming a dominant form of digital entertainment. The modern mobile gaming industry presents three main resource requirements, as its gameplay mechanics and user interaction patterns create different system operation demands.

• Latency-sensitive games, which require high (real-time) responsiveness to ensure fairness and smooth communication among players.
• Data-sensitive games, which depend on state synchronization and regular transmission of data to keep their gameplay authentic.
• Graphics-sensitive games, which prioritize mainly visual experiences and require high rendering capabilities, can be adapted to device constraints.

Industry reports such as the Ericsson Mobility Report [14], together with widely referenced open datasets, highlight how general multiplayer games differ in terms of data intensity, latency sensitivity, and graphics demand, as summarized in

Table 1. Summarization of most popular multiplayer games based on latency, data, and graphics requirements.

Game	Company/Developers	Latency-Sensitive	Data-Sensitive	Graphical-Sensitive
PUBG Mobile	LightSpeed Studio	✓	✓	✓
Clash Royale	Supercell	✓	✓	✗
Pokémon GO	Niantic, Inc.	✓	✓	✗
Call of Duty Mobile	TiMi Studio Group	✓	✓	✓
Among Us	Innersloth	✓	✓	✗
Fortnite	Epic Games	✓	✓	✓
Clash of Clans	Supercell Video Game	✓	✓	✗
Candy Crush Saga	King	✗	✓	✗
Ingress	Niantic, Inc.	✓	✓	✗
Note: ✓ indicates presence, ✗ indicates absence.

. The companies/developers listed in Table 1 represent major contributors to the mobile gaming industry, where each game is characterized based on its sensitivity to latency, data, and graphical requirements. Variations in resource requirements create the need for resource-aware architectures that can provide on-demand computing and networking capabilities. The gaming experience requires a balance between three elements, which include throughput, rendering quality, and responsiveness. This study concentrates on latency-sensitive cases, because delays create negative effects that disrupt user interaction.

Simulation-based tools are basic elements that are used to test such architectural designs. The iFogSim2 framework is an example of a commonly used tool that researchers use to emulate fog and edge computing systems, as well as to experiment with the application deployment and quality of service in the context of mobile operations. In this context, this review focuses on latency-aware gaming systems, SDN-based traffic management approaches, and existing studies that use iFogSim simulations for resource management in fog and edge computing environments.

Fog computing, originally introduced by Cisco in 2012, extends cloud computing by bringing computation, storage, and networking resources closer to end users, thereby enabling low-latency, high-bandwidth, and real-time processing for IoT and interactive applications [15,16,17,18,19]. To support the evaluation of such fog-based systems, several simulation platforms including iFogSim, EdgeCloudSim, MyiFogSim, and YAFS have been developed. Although these tools provide cost-effective environments for performance analysis, many of them lack comprehensive support for techno-economic modeling, user mobility, and heterogeneous deployment scenarios [20,21,22]. These limitations motivate the adoption of more advanced simulation frameworks when studying latency-sensitive and mobility-aware applications.

Recent studies have explored the applications of fog and edge computing to games, virtual reality (VR), and interactive services. Examples include hybrid cloud gaming architecture using edge GPUs [23], VR application [24], resource optimization under AI control, caching-based task allocation in an IoT system [25], and SDN-based support for cloud gaming [26]. IoT and 5G systems have also been suggested to use three-tier fog architectures, and the migration of services to fogs has been shown to have reduced latencies in smart home control systems [27,28]. Survey studies based on online gaming further analyze latency compensation and optimization techniques [29]. Systems such as EdgeGame [30], edge-enabled media streaming platforms [31], and mobile VR frameworks [32] collectively highlight the benefits of edge and fog computing in improving QoE, reducing latency, and enabling adaptive resource allocation. Nevertheless, the majority of these techniques are based on fixed-layer or binary placement schemes and have little support with regard to coordinated mobility-aware provisioning across multiple infrastructure layers.

Edge computing has been widely studied to improve cloud gaming and IoT services. Previous research investigates request scheduling based on reinforcement learning [33], the mobility-awareness task offloading technique in AR/VR applications [34], and 5G-integrated edge architectures [35,36,37], with a summary of the findings listed in

Table 2. Summary of latency-sensitive applications in cloud, fog, and edge environments.

Paper	Problem Addressed	Cloud	Fog	Edge	Mobility	Micro- Services	Cluster- Ing	Tools
[23]	Offloads encoding and streaming to nearby fog nodes	✓	✗	✓	✗	✗	✗	Docker
[24]	Shifts graphics rendering from HMD to fog servers	✓	✓	✗	✗	✗	✗	Hardware, Deep RL
[25]	Assignment of user requests to fog nodes with cached content using matching theory	✓	✓	✗	✗	✓	✗	Numerical simulation
[26]	DQN-based DRL for dynamic resource allocation in cloud gaming	✓	✗	✓	✗	✗	✗	Python
[27]	Three-tier fog architecture for latency-sensitive IoT/5G applications	✓	✓	✗	✓	✓	✗	Not mentioned
[28]	Fog computing for live video streaming and emergency alerts	✓	✓	✗	✗	✗	✗	Custom tool
[29]	Overview of online gaming latency compensation techniques	✓	✗	✓	✗	✗	✗	Not implemented
[30]	EdgeGame framework leveraging MEC and AI	✓	✗	✓	✗	✗	✗	Prototype
[31]	Improving cloud gaming experience using MEC	✓	✗	✓	✗	✓	✗	Prototype system
[32]	Wireless multiplayer VR gaming	✓	✗	✓	✓	✗	Implicit	MATLAB
[33]	Scheduling and server allocation in edge-assisted gaming	✓	✗	✓	✗	✗	✓	EdgeCloudSim
[34]	Multiplayer AR/VR gaming	✓	✗	✓	✓	✗	✓	MATLAB
[35]	5G and edge computing for cloud gaming	✓	✗	✓	✗	✗	Implicit	Not mentioned
[36]	Server allocation and admission control in cloud gaming platforms	✓	✗	✗	✗	✗	Implicit	Java
[37]	Cloud gaming delivery supported by 5G	✓	✗	✓	✓	✗	✗	Real-world implementation
Proposed Model	Efficient resource utilization across cloud, fog, and edge	✓	✓	✓	✓	✓	✓	iFogSim2

Note: ✓ indicates presence, ✗ indicates absence.

. Even with these developments, effective resource provisioning is a major issue. SDN–fog architectures [38,39] improve latency and resource utilization, but often face limitations related to controller scalability, mobility management, and resilience in dynamic workloads. Trust-based and security-oriented frameworks [40] address malicious behavior in distributed environments, but frequently overlook scalability and performance trade-offs. The studies presented in Table 2 do not consistently specify the versions of the software tools used. Therefore, version details are reported only where explicitly available in the referenced works, and are indicated as Not mentioned/Not implemented otherwise.

More recent work includes GVMP (gateway validation module placement) to place an application module efficiently [41], iFogSim2 with better support of mobility, clustering, and microservices [8], IFCSim to allow more realistic fog simulations [42], and SDN-controlled multi-layer cloud architectures to serve tactile internet applications [43]. These initiatives show progress in dynamic and scalable fog–edge systems, but in most cases are based on single aspects of optimization instead of a coordinated approach of mobility awareness between edge, fog, and cloud layers.

Sandmac [44] introduces a security-oriented architecture that combines SDN, IoT, and edge computing using bi-level trust models and fuzzy decision mechanisms, achieving reduced response time and false positive rates. MobFogSim [13] enables mobility support, service migration, and resource allocation in vehicular fog environments through network slicing, but does not incorporate SDN-based traffic control, energy-aware optimization, or gaming-specific workloads. In contrast, iFogSim2 extends edge-fog simulation capabilities by supporting mobility, clustering, microservices, SDN integration, and energy-aware modeling, making it suitable for evaluating latency-sensitive domains like gaming, healthcare, and industrial IoT [8]. Similar growth in gaming technologies, including AI-driven gameplay, high-fidelity graphics, and hardware-accelerated platforms, has further increased the computational demands of modern games, particularly on mobile devices [45,46,47,48,49].

In conclusion, mobile gaming has been expanding at a very high rate, which has stimulated large-scale investigation on the implementation of edge, fog, and cloud services. Available research highlights the great enhancement of both latency and QoE, but frequently falls short of uniting aspects in support of the mobility-driven provisioning, orchestrated multi-layer positioning, and dynamic workload adjustment. The proposed architecture will fill these gaps with a hybrid approach of proximity-based VM placement with hierarchical resource coordination to satisfy high-latency gaming applications.

3. System Model

To address the difficulties of heterogeneous application requirements and user mobility, the proposed work suggests that a system model incorporates distributed computing on edge, fog, and cloud layers with mobility management, microservice-based application decomposition, clustering, and SDN. The architecture is proposed to serve latency-sensitive gaming workloads, making it possible to provide lightweight proximity-aware heuristic resource provisioning, coordinate service placement, and adaptive traffic management. Integrating all these mechanisms into a single four-layered architecture, the system model will provide the basis for effective resource allocation and regular service delivery to work under dynamic mobility and workload conditions.

3.1. Proposed Architecture

The proposed architecture, shown in Figure 1, adopts a four-layer model that comprises mobile users, edge servers, fog coordination layer, and the cloud. Mobile users are at the bottom of the layering and are supposed to travel dynamically in various geographic locations. User devices access nearby edge data centers through access points, enabling localized computation and low-latency service delivery for latency-sensitive gaming workloads.

The design of edge servers is assumed to be geographically distributed within a metropolitan area such that the inter-server distance remains short and network delay variations are moderate. Under this assumption, workload redistribution among neighboring edge servers can be performed with minimal additional latency. In the event of congestion on an individual edge server, the computational load can be migrated or offloaded to neighboring edge nodes to achieve balanced resource utilization with an acceptable response time. These assumptions illustrate a controlled metropolitan deployment scenario and can be used as a foundation for system modeling and simulation.

The proposed design introduces an intermediate fog layer between the edge and the cloud compared to standard three-layer edge–cloud architectures (IoT–Edge–Cloud). This layer serves as a coordination and control plane, rather than a primary execution layer. This layer provides global visibility and allows for coordination of resource management across multiple edge servers within the metropolitan area. The system includes a controller that handles the following functions:

• Monitoring computational and network performance metrics from underlying edge servers;
• Making QoS-aware resource allocation and load redistribution decisions;
• Interfacing with an integrated SDN controller to adapt network configurations in response to user mobility and load variations.

The integrated SDN controller manages the network operations by the network layer functions that allow it to direct the data flow and manage network traffic, as well as create new paths that use latency-sensitive gaming traffic that is required to run under varying user locations and system load conditions. The fog control layer handles the placement of computations and the migration of services. Thus, the fog layer contributes to the load balancing and dynamic distribution of services by its ability to track all computing and network services available on edge nodes. The cloud layer can be used as the back-end storage infrastructure for long-term data storage, historical performance analysis, and global policy management. The combination of these layers creates a programmable and scalable architecture that provides the ability to dynamically provision resources and deliver mobility-aware services in latency-sensitive gaming environments.

The proposed architecture does not rely on a single centralized controller for the entire system. Instead, the fog layer consists of multiple fog devices distributed across different metropolitan regions. Each fog device hosts a controller responsible for managing edge nodes and mobile users within its local region. This regionalized control structure distributes orchestration responsibilities across multiple fog nodes, thus reducing the risk of a centralized control bottleneck as the number of users increases. In the simulation setup, one fog node is assumed to represent a metropolitan-scale deployment region, allowing localized control and coordination of edge resources while maintaining scalability across larger geographical areas.

3.2. Design Elements

The fog and edge environment employs various technologies that combine to provide dynamic services at low latency and manage the various workloads and user traffic. Users can manage the operation of the network using an SDN centralized system that offers programmable access to flow-level routing, traffic prioritization, and dynamic path reconfiguration of traffic in the network that is sensitive to latency and is important to the gaming process. This programmability feature allows the system to handle modifications due to user mobility and load variations without changing the underlying network infrastructure.

A microservice-based application model further intensifies flexibility by breaking down the gaming application into independent, lightweight functional modules that communicate through well-structured interfaces. This decomposition enables the deployment of the required modules, on-demand scaling, and fine-grained offloading of application components along edge and fog layers by providing efficient resource utilization under dynamic conditions.

Mobility management addresses the challenges of dynamically switching users through access points during gameplay. By supporting the migration and reassignment of the application module based on proximity and resource availability, the system model aims to preserve service continuity and responsiveness as users move across the network.

Clustering enables cooperation among heterogeneous and geographically distributed edge nodes. By organizing nodes into logical clusters, the system supports resource sharing and load distribution, reducing localized congestion and stabilizing the overall service provided in a distributed environment.

3.3. Topology

To assess the performance of the proposed architecture with an alternative one of a baseline system topology, a comparative analysis is carried out in terms of two system topologies: a traditional three-layer architecture with no fog layer and the proposed four-layer architecture with a dedicated fog coordination layer, as shown in Figure 2. The topologies are set to the same level of edge and cloud resource capabilities to facilitate a fair comparison, as the only difference between them is the existence of the fog layer.

The clustering mechanism in the edge layer presented in the system design is used to cluster geographically close edge nodes into local groups. When initializing it, the edge nodes store their geographic position and the position of other nodes within the deployment area. The distances between internal nodes are computed using the Haversine formula [50], and nodes located within a communication radius of 300 m are identified as potential cluster members. This radius is used as a representative distance for geographically proximate edge nodes participating in cooperative clustering within the simulation environment, enabling efficient coordination for mobility handling, application module placement, and load distribution as discussed in later subsections.

3.4. Mobility

One of the most prevalent features of the mobile gaming environment is mobility, because users often change their geographical location, making network access points dynamic. To realistically capture this behavior, the simulation incorporates mobility dynamics that depend on the underlying topology and clustering configuration. In particular, user mobility with a constant speed of 10 m/s is simulated using the MobilityController of iFogSim2, which enables the behavior of mobility-aware applications to be analyzed. This speed was chosen to represent moderate vehicular mobility in urban environments, allowing the evaluation of system robustness under frequent service migration and latency-sensitive conditions typical in mobile gaming scenarios. The mobility model allows the redirection of requests and the maintenance of the services as it varies the placement decisions based on the place where the user is and the movement direction. This ensures that low-latency interactions and consistent QoS are not compromised during gameplay, even under frequent mobility events.

In the simulation environment, user mobility is modeled with speeds up to 10 m/s (≈36 km/h) to represent typical mobility patterns observed in metropolitan environments. This range reflects common usage scenarios in which mobile gamers access online services while walking or traveling in slow-moving vehicles under urban traffic conditions. Moderate mobility models within this range are commonly adopted in mobile edge computing and 5G network studies to represent realistic user movement within dense urban deployments of edge infrastructure. Modeling mobility within this range enables the evaluation of latency-sensitive gaming applications that interact with nearby edge nodes while maintaining stable wireless connectivity [51].

Nevertheless, the mobility management strategy in iFogSim2 is mainly based on geographical proximity during the selection of target edge nodes in service redirection. Although it can help minimize communication delay, this approach does not explicitly reflect the actual state of candidate edge server, for example, the available computational resources, the current workload, or the network connectivity. In edge environments that are resource constrained, proximity could thus not be enough to ensure optimal performance.

To better reflect realistic edge deployment scenarios, mobility-aware placement decisions should be incorporated with resource-awareness. By adding capabilities like processing capacity and node occupancy, services may be migrated not just to nearby nodes, but also to nodes that are capable of supporting the extra load. This is especially needed when it comes to mobile gaming applications, where it is necessary to have very high latency criteria and the user is in motion. The detailed handling of service decomposition and migration under such conditions is further discussed in the following subsection.

3.5. Microservices and Its Placement

In iFogSim2, applications are modeled with microservices, which are represented as AppModules, and deploy the apps with a modular and scalable architecture of applications with low-latency requirements, like in the case of multiplayer mobile games. The game application is broken down into a series of logical units, the GameClient which processes user input and generates game output, the GameEngine which executes the core game logic and evaluates the game state, the session manager which stores the information about player sessions and their locations, and the DataStorage unit which deals with stored information such as player progress, analytics, etc.

These modules comprise an application graph consisting of data flowing between components through AppEdges. The graph reflects the properties of exchanged tuples (for example, positions of players and state updates), selectivity models, and communication delays. Figure 3a shows the four-layer deployment model defined through the AppModule configuration. To evaluate the impact of the fog layer, a three-layer model excluding fog nodes has also been implemented for comparative performance analysis, as shown in Figure 3b.

Based on the operational functions and their needs for latency and system resources, the microservices are distributed throughout device, edge, fog and cloud infrastructure. Modules like the GameClient and GameEngine components, which require immediate response, are deployed on mobile devices and edge locations to provide users with uninterrupted game experience and fast performance. Modules that require a wider system view but are less latency-sensitive, such as the SessionManager, are positioned at intermediate layers to balance responsiveness and scalability. The DataStorage module is implemented on the cloud infrastructure since it requires constant data storage and analytics features which demand a large computing power and storage volume.

The policy ModulePlacement allows microservice deployment and operational adjustments through its implementation of ModulePlacementMobileEdgewardsCluster which allows appropriate device allocation for application modules based on latency requirements and user movement behavior and system resource distribution. During execution, modules communicate with tuples containing game events and state information, allowing the simulator to monitor both computational performance and network overhead.

To support mobility-aware operation, selected components, like tracking user positions, can migrate dynamically across edge nodes in response to user movement. This enables latency-sensitive services to remain near the player while maintaining continuity of service. Less critical services remain hosted on the upper-level infrastructure, resulting in a balanced and efficient system architecture. Although this subsection focuses on the decomposition and placement of microservices, the selection of appropriate target nodes during migration is primarily based on proximity-based decisions. The underlying proximity calculation mechanism to guide these placement decisions is described in the following subsection.

3.6. Proximity Approach

In the proposed architecture, the controller placed within the fog layer governs deployment and resource orchestration of the proximity-aware microservice using a hierarchical two-level strategy that combines ProximityAwareMobileVmPlacement and DistributedFogAllocationPolicy.

At the global level, ProximityAwareMobileVmPlacement finds a suitable edge node by evaluating candidate nodes based on their geographical proximity to mobile users and current resource availability, including computational capacity and utilization. This policy works with network-wide visibility to account for mobility-induced variations during placement decisions.

Once a target edge node is selected, control is delegated to DistributedFogAllocationPolicy, which performs local VM allocation by assigning services to the least-loaded host within the selected node based on host-level resource status. By decoupling global proximity-based selection from local resource allocation, the proposed approach enables adaptive microservice placement and service migration under user mobility and dynamic workload conditions.

3.7. Model Implementation

The swift implementation of microservices is required in the latency-sensitive system, i.e., mobile gaming, to ensure responsiveness even under the conditions of dynamic user mobility. The proposed structure enables a lightweight proximity-aware heuristic placement strategy by synchronizing user detection, candidate edge selection, and resource allocation via the fog-layer controller, as illustrated in Figure 4.

The procedure starts with identifying mobile users who need task offloading. The geolocation of the user is determined on a dynamic basis and a proximity-based filtering system is used to determine a group of candidate edge servers within the communication distance. The candidates are then compared with the policy, the ProximityAwareMobileVmPlacement, to rank the nodes based on proximity and the available resource usage as shown in Algorithm 1.

Once the target edge node is chosen, the controller checks the feasibility of deployment and allocates VMs to the level of the DistributedFogAllocationPolicy which runs at the edge-node level. This guarantees the load distribution at the host level and the optimal use of local resources. When successful allocation takes place, an application module is instantiated, service mappings are updated, and discovery information is propagated in order to ensure a steady inter-module communication.

In case there is no appropriate edge node, the framework permits other alternative actions like fog-level deployment or deferred cloud execution. The suggested framework offers scalable and responsive deployment of microservices in the presence of mobility-conscious and resource-constrained conditions through centralized coordination in the fog layer and localized implementation in the edge.

The proposed proximity-aware placement algorithm evaluates the candidate edge devices for each mobile user based on communication proximity and the availability of resources. Let $\left|U\right|$ denote the number of mobile users and $\left|F\right|$ denote the number of edge devices. For each user, the algorithm computes the proximity with all candidate edge devices to identify devices within the communication threshold, resulting in a computational cost of $O\left(\right|F\left|\right)$. The selection of the host within the selected edge device requires scanning the available hosts to identify the least loaded host, which requires $O\left(\right|H\left|\right)$, where $\left|H\right|$ represents the number of hosts per edge node. Since the number of hosts is typically small compared to the number of edge devices, the overall computational complexity of the algorithm becomes $O\left(\right|U|$×$\left|F\right|)$. This linear complexity makes the approach suitable for latency-sensitive applications, such as interactive gaming, where placement decisions must be performed rapidly under dynamic mobility conditions.

Algorithm 1 Proximity-aware mobile VM placement

Require: Mobile users U, edge devices F, application module M Ensure: Deployment status of M   1: for each mobile user $u\in U$ do   2:      if u requires a dedicated VM for M then   3:            $F_u\leftarrow \varnothing$   4:            for each edge device $f\in F$ do   5:                  compute proximity between u and f   6:                  if distance$(u,f)$ within communication threshold then   7:                        add f to $F_u$   8:                  end if   9:            end for 10:            select $f_{opt}\in F_u$ based on proximity and resource utilization 11:            if canBeCreated$(M,f_{opt})$ then 12:                  select host $h\in f_{opt}$ with minimum load 13:                  if resources available on h then 14:                        allocate VM for M on host h 15:                        update resource usage and service mappings 16:                        propagate service discovery information 17:                        return success 18:                  end if 19:            end if 20:            return failure 21:      end if 22: end for

4. Performance Evaluation

To evaluate the efficiency of the proposed four-layer architecture, a set of experimental simulations was conducted using the iFogSim2 simulator [8]. The latency-sensitive application of mobile gaming and continual user mobility that iFogSim2 models include microservice migration, clustering, and service continuity mechanisms, and they are based on real-life EUA datasets with the geographical locations of edge- and fog-node deployments throughout the Melbourne Central Business District, which are fed into the simulator by the DataParser module. iFogSim2 is an event-driven simulator in which computation, networking, and latency behaviors are modeled through abstraction; therefore, the experimental results presented in this work are based on the simulated infrastructure and workload configurations. These abstractions enable the controlled evaluation of system behavior and allow a comparative analysis of different architectural designs under consistent experimental conditions.

A comparative analysis was conducted between a three-layer (edge–cloud) architecture and the proposed four-layer architecture (edge–fog–cloud) as stated in

Table 3. System setup and simulation settings.

Parameter	Values
Operating Systems	Windows 10
Processor	Intel(R)
RAM	16 GB
Sensor Transmission Time	10 ms
Random Dataset	True
Mobility Speed	10 m/s
Environment Limit	6371 km
Node Communication Range	300 m
Simulation Time	30 min

. To ensure a fair comparison, both architectures were configured with identical edge and cloud resource capacities, while the fog layer in the proposed model provided coordination and control functionality rather than an additional computational advantage.

Table 4. Baseline device configuration for iFogSim2-based evaluation.

Layer	No. of Nodes Tested	MIPS	RAM	UpBW	DownBW	BusyPwr	IdlePwr
Cloud	1	20,000	16,384	1000	5000	150	100
Fog	1–9	4000	4096	1000	3000	40	20
Edge	1–60	2000	2048	1000	2000	20	10
Mobile	1–30	500	512	500	1000	4	1.5

gives the basic setups of the devices used in the initial simulation phase. Every situation was executed repeatedly, and the results obtained report average values so as to have consistency and reliability.

Based on the configurations in Table 4, various scenarios were developed to test the behavior of the system under different workloads and infrastructure conditions. Changes in bandwidth measure the user proximity to access points and modifications of RAM, MIPS simulated graphics- and data-sensitive gaming workloads. Scalability was tested by adding more mobile users and changing the number of edge and fog nodes to test the load distribution on the edge–fog–cloud layers.

The execution time and latency values provided in Figure 5 and Figure 6 indicate that the proposed four-layer architecture always outperforms the three-layer baseline in all the cases considered. These improvements are attributed to proximity-aware microservice placement and coordinated resource management, which reduce queuing delays and improve service responsiveness.

The gaming functions are subdivided and strategically placed in the proposed architecture: the Player module is implemented in the mobile devices, the functionality of GameEngine is placed in edge nodes so as to provide the low-latency processing, the SessionManager is deployed in the fog layer for coordination, and the cloud manages storage and analytics. In contrast to that, the three-layer architecture puts both the game engine and the session manager on the edge. As can be seen in Figure 7, the four-layer design achieves better task completion, less execution time, and lower latency due to this separation.

Additional benefits of the proposed architecture are highlighted using the results of energy consumption. Figure 8a shows that offloading workloads with high computational power to the edge and fog layers will greatly reduce energy use on mobile devices, which is essential in real-time gaming applications. The energy consumption of the individual fog and edge node, as illustrated in Figure 8b, shows that the energy consumption on the mobile is minimal as the number of users increases. Figure 8c provides a comparison of the balanced and unbalanced workload distribution where the high energy usage of a particular configuration (such as Fog-2, Edge-5, User-15) is caused by localized overload, highlighting the importance of effective clustering and proximity-aware placement.

Two scenarios were taken into consideration to analyze the effect of the mobility of users: a fixed scenario where the location of users is constant and a mobile scenario where users are constantly relocating access points. The hardware and network conditions to approach mobile gaming simulation are as in

Table 5. Device configuration parameters for mobile gaming applications.

Layer	No. of Nodes Tested	MIPS	RAM	UpBW	DownBW	BusyPwr	IdlePwr
Cloud	1	50,000	64,000	10,000	20,000	200	150
Fog	1–9	8000	6000	5000	5000	50	30
Edge	1–60	6000	4000	3000	3000	30	15
Mobile	1–30	650	1024	1000	1000	5	2

, which is detailed in [52]. Figure 9a demonstrates the execution time in the mobile context which seems to be shorter due to the proactive migration of the proximity-aware modules. Figure 9b shows that there is a moderate latency increment when under mobility, as expected, owing to handovers, but this is counterbalanced by an increase in CPU utilization and a decrease in the queuing timing. The network usage results shown in Figure 9c reveal that there is no significant difference between unbalanced and balanced deployment, which has been established as very robust to load changes introduced by mobility.

Figure 10a presents the application-level communication latency between the individual modules deployed throughout the fog–edge infrastructure. Since the proposed system adopts a modularized application design, the latency values shown in Figure 10a represent the communication delay between the interacting components of the application rather than the overall end-to-end latency of the entire application. The observed latency between these modules in the simulated environment is mostly within the range of 1 to 2 ms.

The total execution latency of the application is determined by the aggregation of delays across multiple interacting modules, along with additional network transmission and processing overheads. Consequently, the effective end-to-end latency experienced by the application is typically within the range of 5 to 20 ms, which aligns with the latency requirements of real-time gaming environments. Minor deviations in the results are mainly caused by temporary load imbalances during mobility events.

The latency target of approximately 1 ms originates from the vision of the tactile internet and has been explored in several simulation-based studies. For example, the paper [43], evaluated a fog-based traffic framework using the iFogSim simulator to analyze latency reduction in edge–fog architectures. Therefore, the 1 ms latency mentioned in this work should be interpreted as a design benchmark within the simulation environment rather than a guaranteed real-world deployment latency.

In addition, the target application in this work focuses on interactive gaming environments, where users continuously interact with the system and expect immediate responses to their actions. In such scenarios, system responsiveness is strongly influenced by the latency between interacting application modules, as each user action triggers a sequence of processing and communication events across the distributed infrastructure. For this reason, the application-level latency graph is presented to illustrate the responsiveness achieved by the proposed architecture.

Figure 10b,c investigate how communication overhead is affected by the fog-layer controller. When a controller is disabled, the number of tuples sent increases as a result of retransmission. The SDN-enabled controller also allows an intelligent choice of the path and greatly reduces the overhead of communications as the global network is visible. This establishes that the proximity-based controller experimented in this work is scalable with regard to the number of users and network pressure.

Figure 10d compares resource utilization under iFogSim2’s binary allocation policy and the proposed proximity-aware placement strategy. The binary allocation approach rigidly assigns tasks either to local or remote nodes, which frequently leads to uneven resource usage and saturation under dynamic workloads. In contrast, the proposed proximity-aware algorithm dynamically routes application modules to nearby lightly loaded edge nodes by jointly considering proximity and current resource utilization. This approach has a more stable and balanced utilization profile than the binary allocation method, as seen in the utilization graph. This stability is specifically crucial in very dynamic mobile gaming applications when the workload varies and users move around, which would otherwise lead to a decrease in performance. By balancing resource utilization across edge nodes, the proposed model reduces unnecessary bandwidth consumption and facilitates a smooth and consistent gaming experience, even under high interaction rates.

5. Discussion

Simulation outcomes prove that the proposed four-layer edge fog cloud architecture enhances the performance of latency-sensitive mobile gaming applications significantly when compared to the traditional three-layer model. The decrease in the execution time and end-to-end latency proves the efficiency of introducing the fog layer, which has global visibility and controller-based proximity-driven placement.

Dynamic placement of the microservice and coordinated load redistribution to the clustered edge nodes are the major measures used to achieve performance gains. In contrast to the binary allocation strategy used in iFogSim2 where tasks are assigned statically, the suggested approach adjusts to the user mobility and resource availability and provides a stable utilization and better responsiveness. These results are consistent with previous research on edge-based and fog-based gaming, but go a step beyond in showing the advantages of fog-level coordination at a metropolitan level.

Energy consumption analysis indicates that mobile devices consume less power and this indicates the benefit of offloading compute-intensive modules to adjacent edge and fog nodes. Equal energy distributions at infrastructure levels also suggest that proximity-aware placement can overcome the localized overload problem, which is a weakness of uncoordinated edge deployments.

Mobility experiments indicate a trade-off between execution efficiency and handover-induced latency. Even though mobility enhances the network dynamics, proximity-based migration minimizes queuing delays and improves CPU utilization since services are near to users. Also, the usage of the network and transmission of the tuples confirm that the fog-layer controller helps to reduce unneeded communication due to the possibility of intelligent routing and central decision-making.

The proposed architecture is intended to operate on shared edge–fog–cloud infrastructures typically deployed in mobile edge computing environments. While the evaluation in this work focuses on mobile gaming workloads due to their strict latency requirements, the underlying infrastructure can support multiple latency-sensitive applications such as IoT analytics, augmented/virtual reality, and real-time multimedia services.

Although the results validate the proposed architecture, the evaluation is limited to simulation-based scenarios. Real-world deployments can introduce further variability in network conditions and hardware heterogeneity. Future work will focus on incorporating predictive or learning-based placement strategies, enhancing fault tolerance and security, and validating the framework in real or hybrid testbeds.

6. Conclusions and Future Works

This work investigated the deployment of latency-sensitive mobile gaming applications using a structured, multi-layer resource management approach evaluated through iFogSim2. A four-layer architecture was proposed that uses edge, fog, and cloud layers to address latency, mobility, and resource utilization challenges inherent in real-time gaming environments. Compared to the conventional three-layer model, the proposed architecture demonstrated improved latency performance, higher task completion efficiency, and optimal resource utilization. Decomposing the gaming application into microservices enabled modular execution and parallel processing, contributing to improved responsiveness under dynamic user workloads.

The introduction of a fog-layer controller with global visibility of metropolitan edge resources enabled lightweight proximity-aware and load-aware placement decisions, resulting in more stable utilization compared to the binary allocation model of iFogSim2. In this context, robustness refers to the system’s ability to sustain performance under user mobility and load fluctuations rather than fault tolerance. Overall, the proposed architecture provides a scalable and adaptable framework for latency-sensitive applications, such as multiplayer mobile gaming.

Although the evaluation in this work focuses on mobile gaming applications, the proposed architecture is not limited to gaming workloads. Mobile gaming is used as a representative latency-sensitive and interactive application to evaluate the effectiveness of the proposed edge–fog–cloud coordination framework. Architectural design and proximity-aware placement strategy can be extended to other latency-critical applications such as AR/VR, connected vehicle services, real-time video analytics, and industrial IoT monitoring systems. These applications share similar requirements for low-latency processing, mobility support, and rapid service response, which can benefit from distributed computation across edge and fog layers. Despite these improvements, the evaluation is based on simulation, which abstracts certain real-world network dynamics and failure conditions.

While the proposed framework has been evaluated using mobile gaming workloads due to their strict latency and mobility requirements, several practical aspects remain important for large-scale real-world deployment. Future work will investigate the adaptability of the proposed architecture to heterogeneous application workloads, including IoT services, AR/VR applications, and real-time multimedia processing. Additionally, further studies will explore resource sharing strategies and cost-effective infrastructure utilization in edge–fog–cloud environments, ensuring that the deployed infrastructure can effectively support multiple latency-sensitive services. Another important direction is the integration of intelligent decision-making mechanisms within edge–fog controllers, where machine learning or reinforcement learning techniques can be used to enable adaptive resource allocation, dynamic workload management, and mobility-aware service orchestration. Extending the evaluation to mixed-application scenarios and large-scale deployments will further validate the practicality and scalability of the proposed approach.