Enhanced Rat Swarm Optimization for Energy–Latency-Aware Task Offloading in Mobile Cloud Computing

The rapid growth of mobile computing is primarily driven by the spectacular increase in the number of mobile devices such as smartphones, smartwatches, laptops, and more. In 2026, the number of smartphones worldwide is estimated at 7.58 billion, while the number of smartphone users will reach 5.65 billion [1]. Users of these devices typically expect a high quality of service, particularly in terms of response time, energy efficiency, and storage costs. Reducing the energy consumption of mobile devices has become both a major user requirement and an important objective in addressing the global energy crisis and promoting environmental sustainability. Current estimates indicate that mobile applications collectively consume approximately 20.3 terawatt-hours of electricity annually, slightly below the annual electricity consumption of Ireland [2]. Striking a balance between these non-functional requirements demands careful attention to ensure both a seamless user experience and the preservation of our planet. Several strategies have been adopted by both academia and industry to address energy efficiency and performance in mobile devices, covering multiple facets:

•At the hardware level, techniques like dynamic voltage and frequency scaling (DVFS) help adjust processor power based on workload. Newer approaches, such as MetaDVFS, have shown up to 17% improvement in performance-per-watt by using metadata to guide frequency scaling [3]. Modern mobile chips also integrate specialized hardware accelerators like neural processing units (NPUs) alongside graphics processing units (GPUs) and digital signal processors (DSPs). These allow tasks such as AI inference to run on the most energy-efficient unit available [4, 5]. Storage technology has also evolved: universal flash storage has largely replaced embedded MultiMediaCard (eMMC) by enabling full-duplex data transfer and command queuing, which translates to faster speeds and better power efficiency [6]. Meanwhile, smarter cache hierarchies help reduce the energy cost of memory operations [7].

•At the software level, energy-aware operating systems coordinate power management across different layers. Research shows that optimizing across hardware, operating system, network, and applications together yields better energy savings than tuning each layer separately [8]. Virtualization and containerization also help consolidate resources efficiently [7].

•User best practices, simple practices like lowering screen brightness, closing background apps, and following proper charging routines can extend battery life. A recent study [9] found that user awareness of these practices was a key factor in managing battery drain effectively.

•Finally, green energy harvesting offers a sustainable path forward. Systems that capture ambient energy from light, motion, or heat can power devices without relying solely on batteries. Light-based harvesters typically use solar cells, power management chips with Maximum Power Point Tracking, and small batteries or supercapacitors. The main challenges are dealing with inconsistent energy availability and ensuring that harvested power meets the device’s average needs [10].

In this study, we focus on computation offloading (CO). While hardware improvements, software optimization, user practices, and green energy each contribute to mobile device energy efficiency, CO offers a uniquely flexible solution that can dynamically adapt to varying workloads and environmental conditions. Rather than executing all computations locally on the device, offloading them to external resources, specifically the cloud, can be an effective way to meet user requirements. Mobile cloud computing (MCC) has emerged as a transformative paradigm, enabling mobile devices to offload intensive computations to the cloud and leverage its virtually unlimited resources. This practice has become a key approach for enhancing both performance and energy efficiency in mobile environments [11-13].

The CO is a complex process that involves a three-step workflow [14]:

•Application partitioning: This step divides a given mobile user application into offloadable and nonoffloadable components, i.e., determining which components are executed inside the device and which need to be externalized to the cloud. It is a prerequisite for efficient CO.

•Preparation: This step handles all tasks required for the offloadable components in mobile applications, including selecting a remote server, transferring, and installing the code, among others.

•Offloading decision: Before remote execution, a decision is made based on the current execution context to determine whether the remote component will be used in the user’s mobile application.

A thorough analysis of existing studies reveals the five key dimensions constituting the CO ecosystem (Figure 1): (D1) the highly dynamic nature of MCC, where device performance, bandwidth, and network latency fluctuate continuously, impacting the overall offloading cost; (D2) the underlying infrastructure of mobile devices including available memory, battery level, and CPU speed, as well as network specifications (such as 3G, Wi-Fi, and available bandwidth) that enable connectivity between devices and the cloud; (D3) user preferences, including data preferences; (D4) the CO algorithms responsible for application partitioning and decision-making; and (D5) the used non-functional requirements that CO algorithms have to satisfy. However, most existing CO algorithms do not incorporate the dynamic nature of the MCC environment. As a result, an effective offloading strategy should account for these fluctuations, optimizing energy consumption and resource usage in real time by adapting to changes in network conditions and service node capabilities, including the processing speed of both the mobile device and cloud servers. These challenges highlight the need for adaptive approaches that dynamically adjust offloading decisions based on current environmental conditions [15, 16].

1.png

Figure 1. Five dimensions of the computation offloading (CO) ecosystem

Due to its importance, let us focus on application partitioning. To perform this CO step, the mobile user application can be formally modeled as a graph, where vertices represent computational components (annotated with metrics such as execution time, memory usage, and input/output), and edges represent communication costs between these components [15, 17]. The goal of graph partitioning is to determine the optimal allocation of components between the mobile device and cloud servers, minimizing communication costs while maximizing performance and energy savings. Achieving this goal is challenging, as the graph partitioning problem is known to be nondeterministic polynomial-time complete (NP-complete) [18].

Several algorithms have been proposed for CO-oriented graph partitioning, including heuristic and metaheuristic approaches. Among these, swarm intelligence-based algorithms, such as Ant Colony Optimization (ACO), Particle Swarm Optimization (PSO), and Whale Optimization Algorithm (WOA), have demonstrated promising results in balancing trade-offs between energy efficiency, processing power, and communication costs. However, these algorithms are static and do not account for the dynamic MCC environment [19]. Recently, the Rat Swarm Optimizer (RSO) has emerged as a novel swarm intelligence-based algorithm for solving global optimization problems. Inspired by the behavior of rats chasing and fighting their prey, RSO has shown significant success in continuous optimization tasks [20]. This study focuses on enhancing the RSO algorithm to increase its effectiveness for MCC. The objective is to modify RSO to efficiently manage the allocation of tasks between mobile devices and cloud resources, prevent entrapment in local optima, and reduce both energy consumption and execution time.

The remainder of this study is organized as follows: Section II reviews existing research on CO and optimization methods in MCC. Section III presents the cost function formulation for energy optimization. We also introduce the proposed Enhanced Rat Swarm Optimization (ERSO) algorithm, detailing how it adapts traditional RSO concepts to reduce energy consumption while maintaining efficient task completion. Section IV outlines the simulation setup and performance metrics used to evaluate our approach, followed by an in-depth discussion of the experimental results. Finally, Section V provides concluding remarks and suggests potential directions for future research on applying intelligent swarm-based optimization to MCC offloading problems.

MCC presents several challenges, including variable network bandwidth, fluctuating server performance, and the limited resources of mobile devices, such as battery capacity, memory, and computational power [52]. These issues underscore the imperative for formulating efficient and flexible solutions for CO, which involves reallocating resource-intensive workloads from mobile devices to cloud servers [53]. A significant problem with existing approaches is their propensity to become trapped in local optima, resulting in unsatisfactory solutions. This issue occurs because numerous algorithms emphasize enhancing current solutions instead of sufficiently investigating fresh opportunities. Moreover, energy consumption continues to be a significant issue for mobile devices with limited battery life [19]. An efficient offloading approach must achieve a balance between performance and energy efficiency [54], including both processing and communication costs.

Before presenting the proposed approach, we formally define the system model and the optimization problem that our ERSO algorithm aims to solve.

3.1 System model

3.1.1 Application model

The mobile application is modeled as a directed graph G = (V, E), where V = {v₁, v₂, ..., v_n} represents the set of computational components (methods or tasks), and E = {(v_i, v_j)} represents the communication dependencies between these components. Each vertex v_i has associated costs: L_i for local execution on the mobile device and Ri for remote execution on the cloud server. Each edge (v_i, v_j) has an associated communication cost C_ij, which represents the data transfer overhead if methods v_iand v_j are executed on different nodes. The goal of application partitioning is to divide the graph G into two disjoint subsets: VL (methods executed locally on the mobile device) and VR (methods offloaded to the cloud server), such that the total cost is minimized while satisfying system constraints.

3.1.2 Computation model

The execution time for methods executed locally on the mobile device is given by:

$T_{{Local }}=\sum_{i \in L} t_i^{ {Local }}$

where, L represents the set of methods executed locally, and $t_i^{{Local }}$ is the execution time for method i on the mobile device.

The execution time for methods offloaded to the cloud server is given by:

$T_{ {Remote }}=\sum_{i \in R} t_i^{ {local }} / F$

where, R represents the set of methods offloaded to the cloud, and F is the speedup factor representing the computational advantage of the cloud server over the mobile device. Typical values for F range from 5 to 50 depending on the cloud server type [14, 55, 56].

The energy consumption for local execution is calculated as:

$E_{{Local }}=\sum_{i \in L}\left(t_i^{ {Local }} * P_L\right)$

where, P_L is the power consumption during local execution.

The energy consumption for remote execution is calculated as:

$E_{ {Remote }}=\sum_{i \in R}\left(t_i^{ {Remote }} * P_R\right)$

where, P_R is the power consumption during remote execution.

3.1.3 Communication model

When methods are offloaded to the cloud, data must be transmitted between the mobile device and the cloud server. The communication time between methods i and j is determined by:

$C_{i j}=\frac{{ Data }_{i j}}{B}$

where, Data_ij is the amount of data transmitted between methods i and j, and B is the network bandwidth.

The total communication time is given by:

$T_{ {Com }}=\sum_{(i, j) \in E} C_{i j}$

The energy consumption for communication is given by:

$E_{{Com }}=\sum_{(i, j) \in E}\left(C_{i j} * P_{ {Com }}\right)$

where, P_Com is the power consumption for data transfer during communication.

3.2 Optimization problem formulation

The CO problem is formulated as a bi-objective optimization problem aiming to minimize both execution time and energy consumption.

3.2.1 Decision variables

Let x_i $\in$ {0, 1} be the decision variable for each method v_i $\in$ V, where:

$x_i=\left\{\begin{array}{c}0, \text { if method } v_i \text { is executed locally on the mobile device } \\ 1, \text { if method } v_i \text { is offloaded to the cloud server }\end{array}\right.$

The offloading strategy is represented by the binary vector x = [x₁, x₂, ..., x_n].

3.2.2 Objective function

The total execution time is the sum of local execution time, remote execution time, and communication time:

$T_{ {Total }}=T_{{Local }}+T_{ {Remote }}+T_{{Com }}$

The total energy consumption is the sum of local energy, remote energy, and communication energy:

$E_{{Total }}=E_{ {Local }}+E_{ {Remote }}+E_{ {Com }}$

The objective is to minimize the weighted sum of execution time and energy consumption:

Minimize: Fitness $=W_t * T_{ {Total }}+W_e * E_{ {Total }}$

where, $W_t$ and $W_e$ are pre-defined weights such that $W_t$ $+W_e=1$. These weights allow for expressing preferences between execution time and energy consumption.

3.2.3 Constraints

The optimization problem is subject to the following constraints:

•Binary decision constraint:

$x_i \in\{0,1\}, \quad \forall_i \in V$

•Task dependency constraint:

If method $v_j$ depends on method $v_i$ (i.e., $v_j$ requires output from $v_i$), then the execution order must be preserved.

The problem is known to be NP-complete [18], which motivates the use of metaheuristic algorithms such as the proposed ERSO to find near-optimal solutions efficiently.

3.3 Proposed Enhanced Rat Swarm Optimization algorithm

The proposed approach, ERSO for MCC offloading, depicted in Figure 2, utilizes hybrid algorithms that integrate the benefits of both linear programming and graph models to attain an optimal and dynamic solution by factoring in the previously stated costs: local, remote, and communication costs. This is achieved through the use of three modules, including profiler, analyzer, and solver, with the solver tasked with identifying the optimal partitioning outcome: which methods ought to remain on the mobile device and which should be offloaded. The application is partitioned during offloading to determine whether the process should be offloaded or executed locally. In our approach, application partitioning is a fundamental activity conducted before decision-making. It is assumed that the methods entering the decision engine are offloadable methods. In the context analysis and profiling phase, several metrics are gathered through the profiling tool for distinct factors to facilitate an optimal offloading decision, regarded as the final step of the CO process. A decision engine helps to decide when to offload to the remote or cloud using the enhanced ERSO algorithm, designed explicitly for CO in MCC environments. The suggested approach seeks to improve the allocation of tasks between mobile devices and cloud resources, including variable environmental factors, execution costs, and energy efficiency.

2.png

Figure 2. Schematic representation of application partitioning and offloading

Table 4. Characteristics of the proposed approach in mobile cloud computing (MCC) partitioning

Our research contribution can be effectively visualized and compared using the thematic taxonomy of Application Partitioning Algorithm’s (APA) classification illustrated in [31]. Table 4 delineates the distinct attributes of our work, situating it clearly within the established taxonomy framework:

(1) Granularity: In our approach, partitioning is method-based, which allows for effective management and offloading of individual tasks. Besides, it provides flexibility and finer control over performance optimization [57]. Table 5 illustrates a comparison between the offloading-based methods, classes, and objects:

(2) Supported language: The approach was developed using a single programming language, Python. Python was chosen due to its widespread adoption and extensive libraries. Its simplicity, versatility, and comprehensive libraries suit complex tasks like application partitioning.

(3) Partitioning model: The hybrid model employed in this approach integrates a method call graph representation with linear programming for problem formulation. This method visually represents interactions among methods and facilitates mathematical optimization via linear programming.

(4) Profiling: Profiling is essential for acquiring data regarding software, hardware, and network characteristics. It aids in making informed decisions regarding offloading mechanisms, contingent upon the capabilities and status of both the cloud server and the mobile device.

(5) Allocation decision: Real-time online decision-making that improves adaptation to changes in the application context. It entails adapting to user behavior, network configurations, or device conditions for enhanced and dynamic offloading techniques.

(6) Techniques for analysis and annotation: Automating analysis and annotation enhances the efficiency and accuracy of identifying offloading strategies. This methodology guarantees the selection of methods with the highest profit potential from offloading, considering method dependencies, conditions, and constraints.

Table 5. Comparison between the offloading of methods, classes, and objects [57]

These components jointly enhance performance and reduce energy consumption, rendering the technique adaptive, efficient, and responsive to variations in application context and system conditions.

In what follows, we give a description of each module illustrated in Figure 2:

(1) Profiling module: The profiling module actively monitors hardware, software, and network components, utilizing specific profiling techniques to gather detailed information. This ensures comprehensive tracking of system performance by concentrating on the underlying hardware infrastructure, software processes, and network activity.

•Hardware profiling: Its objective is to collect detailed information about the physical hardware resources of both mobile and cloud devices, such as the cloud server CPU, mobile device CPU, and mobile device battery capacity.

•Software profiling: It gathers data about the mobile application, including metrics such as code size, CPU usage, and other relevant software characteristics, which will be used later by the solver module to analyze the resource requirements and characteristics of the application, thereby enhancing overall performance and optimizing CPU utilization.

•Network profiling: Collects information on the network environment, including bandwidth and connectivity options (3G, 4G, 5G, Wi-Fi). This module enables informed decision-making regarding method allocation and offloading, ensuring efficient data transfer processes and optimal resource utilization.

(2) Analyzer: The analyzer has two main functionalities. First, it partitions the mobile application into methods, and second, it follows the common practice in programming by representing the mobile application as a graph (Figure 3), where each vertex symbolizes a computational component (method). Each edge denotes the communication between these components. The weight on a vertex signifies the computational load required to execute that component on the mobile and cloud servers. In contrast, the weight on an edge indicates the relative communication demand between components. Communication costs between operations that are executed in the same location (either locally or remotely) are assumed to be negligible. Graph partitioning is a fundamental problem in many computer science domains. It involves dividing a graph into k equal sets while minimizing the edges between them. This problem is particularly relevant in the context of computation offloading to the network, where the goal is to partition the computational methods into groups and dispatch them to a single network node [56, 58]. The communications between methods within the same group essentially have no overhead because the methods will be executed in the same network node. Thus, it is desirable to group methods with high communication requirements; internal communication is maximized while minimizing external communication between different groups, effectively reducing overhead and optimizing performance. When k = 2, this problem is known as the min-cut bipartitioning problem. Employing this strategy tackles the NP-hard challenge of finding an optimal solution for graph partitioning [59].

(3) Solver: or decision engine, is a crucial element in the offloading framework, determining whether to offload tasks to a distant server based on the parameters available from the profiling process and the analyzer's output. The profiler and analyzer are two sources of information that the solver module gathers and utilizes to enhance the solution. This module employs the RSO algorithm to partition the application into groups, facilitating the equitable distribution of workloads between local (device) and remote (cloud) execution, hence minimizing overall execution time. The suggested RSO algorithm integrates a weighted fitness function that combines execution time and energy costs. This dual-objective optimization guarantees that the solution minimizes task execution delays while simultaneously decreasing energy consumption, which is essential for resource-constrained mobile devices. The weights for execution and energy costs can be adjusted dynamically according to the application's specifications.

3.png

Figure 3. Example of a weighted call graph generated by the analyzer module

Rats, in their natural environments, exhibit social intelligence. The primary inspiration of the RSO algorithm is the aggressive behavior of rats towards other animals, characterized by chasing and fighting [12, 20].

(1) Chasing the prey: The primary premise in this phase is that the most effective search rat is one that is aware of the prey's location. Consequently, the subsequent equations have been provided:

$\vec{P}=A * \overrightarrow{P_{\imath}}(x)+C\left(\overrightarrow{P_r}(x)-\overrightarrow{P_{\imath}}(x)\right)$

where, P_i(x) is the rats’ position in the space, and P_r(x) is the position of the best rat in the population. A and C are two calculated parameters.

$A=R-x\left(\frac{R}{ { Max }_{ {iteration }}}\right)$

where, x represents the current iteration from Max_iteration and R is a random number in the interval [1, 5].

C = 2 × rand()

where, C is a random number in the interval [0, 2].

(2) Fighting the prey: The following equation models mathematically the process of fighting the prey by rats:

$\vec{P}_l(x+1)=\left|\overrightarrow{P_r}(x)-\vec{P}\right|$

Algorithm 1 illustrates the pseudo-code of the RSO algorithm [13].

Table 6. Limitations of standard Rat Swarm Optimizer (RSO) and corresponding enhancements in Enhanced Rat Swarm Optimization (ERSO)

Note: MCC = mobile cloud computing.

The RSO algorithm promises to solve optimization problems but needs some adjustments to work effectively in MCC environments (Table 6). The suggested enhancements include:

(1). Balancing exploration and exploitation

To enhance exploration, we replace standard random initialization with a diverse random matrix generation. Standard initialization often produces clustered solutions, limiting exploration. Our approach adds small controlled perturbations to the initial population, increasing diversity and reducing the risk of premature convergence to suboptimal solutions:

$M_{ {diverse }}={clip}\left(M_{ {random }}+U(-0.1,0.1), 0.1\right)$

where, $M_{{diverse }}$ is a random matrix in [0, 1], U(−0.1, 0.1) is a uniform perturbation in the range [−0.1, 0.1], and clip(0, 1) ensures values stay in [0, 1]. This provides a more robust foundation for optimization, particularly in high-dimensional problems.

(2). Energy-aware fitness function

A new fitness function will be introduced to evaluate solutions depending on:

• Energy consumption: This includes the energy required for the device's computational operations and communication with the cloud.

• Execution duration: This considers the time required for both local and remote execution.

The fitness function will incorporate these two components into a singular score, modified according to the user's preferences.

(3). Real-time method partitioning

The mobile application will be conceptualized as a graph, with tasks designated as nodes and dependencies represented as edges. This enables dynamic partitioning, allowing real-time decisions regarding which tasks should be executed locally and which should be delegated to the cloud.

(4). Memory component

To accelerate convergence and prevent the algorithm from revisiting suboptimal solutions, we introduce a memory mechanism that stores promising offloading strategies. The memory is defined as:

$M m=\left\{x_1, x_2, \ldots, x_k\right\}$

where, k is the memory size (set to 5). When a new solution x_new improves the global best, it is added to memory. If memory is full, the worst solution is replaced:

$M m=M m \backslash\left\{x_{{worst }}\right\} \cup\left\{x_{{new }}\right\}$

This mechanism has two key benefits: (1) it preserves high-quality solutions for future reference, and (2) it accelerates the search by guiding the algorithm toward promising regions of the search space

(5). Mutation mechanism

To further reduce the risk of entrapment in local optima, a guided mutation mechanism is incorporated. Instead of applying mutations randomly across all agents, the mechanism targets agents with the worst fitness values. The set of worst agents is identified as:

$W=\arg \min _i$ Fitness $\left(x_i\right)$

where, $W$ represents the set of agents with the worst fitness values, and $x_i$ is the position (offloading strategy) of agent $i$. For each selected agent $i \in W$, a mutation is applied to a randomly selected bit:

$x_i(j)= \begin{cases}1-x_i(j), & \text { if } j \in \text { selected bits for mutation } \\ & x_i(j), \quad \text { otherwise }\end{cases}$

where, $x_i(j)$ represents the j-th bit of agent i’s configuration. This operation flips a random bit of the worst agents, introducing meaningful diversity where it is most needed. The mutation probability is fixed:

$p_{m u t}=0.2$

where, $p_{m u t}$  is the probability that an agent undergoes mutation. Only the worst agents (typically the bottom 5) are selected for mutation, ensuring that the population retains stability while still encouraging exploration where it is most needed.

This guided mutation strategy has three key advantages:

• Targeted exploration: Mutations are applied only to the worst solutions, improving them without disrupting the better solutions.

• Population stability: The best solutions remain unchanged, preserving the algorithm’s convergence.

• Avoidance of local optima: By introducing diversity in the worst-performing agents, the algorithm can escape local optima.

The ERSO algorithm functions as outlined below:

1. Initialization: Construct an initial array of potential solutions (agents) and set parameters for exploration, exploitation, and mutation.

2. Evaluation of solutions: Employ the energy-aware fitness function to assess the quality of each solution.

3. Pursue optimal solutions: Transition between exploration and exploitation according to varying parameters. Subsequently, mutation will be implemented to preserve variation among solutions. Afterward, update the memory with the optimal solutions identified thus far.

4. Dynamic method partitioning: Utilize a graph-based approach to allocate tasks to the mobile device or the cloud based on prevailing conditions.

5. Repeat and converge: Persist in refining solutions until the algorithm satisfies a termination criterion, such as a predetermined number of iterations or negligible improvement in fitness.

6. Output results: Present the optimal work allocation strategy, along with data on energy consumption and execution time.

Algorithm 2 shows the detailed steps:

The pseudo-code of the enhanced algorithm is illustrated in Algorithm 3.

3.4 Complexity analysis

The computational complexity of the proposed ERSO algorithm is analyzed as follows:

Let n be the number of methods/tasks in the application (size of the graph), and N be the number of agents (population size). The complexity of each step is:

• Initialization: $O(N \cdot n)$ to generate and evaluate the initial population.

• Position update: $O(N \cdot n)$ per iteration to update each agent’s position.

• Fitness Evaluation: $O(N \cdot n)$ per iteration to evaluate each agent.

• Mutation: $O(N \cdot n)$ per iteration to apply mutations.

• Memory Update: $O(N \cdot n)$ per iteration.

Overall, the time complexity of the ERSO algorithm is:

$O(T N n)$

where, T is the number of iterations. This complexity is linear with respect to the number of agents and tasks, making the algorithm suitable for resource-constrained mobile devices. The space complexity is $O(N \cdot n)$ for storing the population and memory. Compared to exact algorithms that have exponential complexity $O(2 n)$ for the graph partitioning problem, the ERSO algorithm provides a polynomial-time heuristic solution that is practical for real-time MCC offloading decisions.

This study presented an ERSO algorithm for intelligent and dynamic task offloading in MCC environments. Unlike conventional approaches that depend on static heuristics or deterministic partitioning, ERSO introduces a swarm intelligence-based optimization framework that adapts to changing conditions such as bandwidth variability and server load. Our approach effectively identifies optimal execution points for mobile applications by balancing energy consumption and execution time through modeling the CO process as a bi-objective optimization problem and enhancing the standard RSO algorithm with adaptive learning strategies.

Experimental results demonstrated that ERSO significantly outperforms classical offloading methods in energy savings, particularly under highly dynamic network conditions. Extensive experiments conducted on both 16-node and 50-node application graphs, under network bandwidths ranging from 3 to 100 Mbps and cloud speedup factors ranging from 5 to 30, confirmed the robustness and effectiveness of the proposed approach. Compared with the non-offloading, full offloading, and min-cut approach, as well as GA, PSO, and the standard RSO, ERSO consistently achieved superior performance in terms of overall fitness, energy consumption, and response time. In particular, under the most challenging network conditions (3 Mbps bandwidth and a cloud speedup factor of 5), the proposed algorithm achieved up to a 33% improvement in fitness over the non-offloading baseline, demonstrating its ability to maintain efficient task allocation even in adverse MCC environments.

Furthermore, ERSO shows strong convergence performance and avoids the premature convergence and local minima limitations observed in earlier RSO-based algorithms. The proposed adaptive enhancements effectively balance exploration and exploitation throughout the optimization process, resulting in improved solution quality and greater robustness under dynamic execution conditions. These findings demonstrate that ERSO constitutes a reliable and scalable optimization framework for CO in MCC.

Several directions can further improve the ERSO approach:

•Task parallelism and multi-objective offloading: Future extensions may explore the simultaneous offloading of multiple interdependent tasks, considering parallel execution across edge/cloud nodes and multi-core mobile devices.

•Hybrid optimization models: Combining ERSO with other bio-inspired optimization techniques or deep learning methods could lead to hybrid frameworks capable of learning optimal offloading strategies in real time.

•Real-world deployment: Building a real MCC simulation platform or deploying ERSO in practical mobile and edge-cloud applications will enable a more comprehensive evaluation under realistic operating conditions.

•Scalability studies: Investigating ERSO's behavior in larger and more heterogeneous environments, involving numerous users, applications, and computational tasks, is essential to further validate its scalability and robustness.

•Security and privacy constraints: Since CO often involves transmitting sensitive data, integrating privacy-preserving mechanisms and incorporating security overhead into the fitness function would further enhance the algorithm's practical applicability. In addition, considering quality of service requirements, such as latency guarantees, reliability, resource availability, and user mobility, represents a promising direction for extending the proposed framework to next-generation mobile cloud and edge computing systems.

Overall, the proposed ERSO algorithm provides an effective, adaptive, and scalable solution for CO in MCC by achieving a balanced trade-off between energy efficiency, response time, and computational performance. The encouraging experimental results demonstrate its potential for deployment in dynamic real-world MCC environments and establish a solid foundation for future research on intelligent resource management and CO strategies.