RIGEO: Hybrid Optimization for Fog Scheduling

• The paper presents a hybrid scheduling algorithm that partitions tasks and fog nodes by deadline and traffic levels, using IGEO for low-deadline and RL for high-deadline tasks to optimize energy, response time, and deadline violations.
• The IGEO component adapts the golden eagle metaheuristic with genetic operators, effectively managing discrete task scheduling and balancing exploration with exploitation.
• The reinforcement learning aspect tailors task assignments for high-deadline tasks on high-traffic nodes by using reward and penalty signals to iteratively improve scheduling performance.

Searching arXiv for the specified paper and closely related context. arXiv search query: (Sirjani et al., 9 Sep 2025) Reinforcement Improved Golden Eagle Optimization (RIGEO) is a hybrid task-scheduling algorithm for fog computing that is explicitly organized around deadline awareness and traffic awareness in a three-layer IoT–Fog–Cloud architecture. In the formulation reported in "Optimizing Task Scheduling in Fog Computing with Deadline Awareness" (Sirjani et al., 9 Sep 2025), fog nodes are classified into low-traffic and high-traffic categories, while tasks are classified into low-deadline and high-deadline categories. Low-deadline tasks are scheduled on low-traffic fog nodes by an Improved Golden Eagle Optimization (IGEO) procedure, whereas high-deadline tasks are processed on high-traffic nodes by a reinforcement learning (RL) procedure. The stated optimization targets are reduction of total energy consumption, response time, and total deadline violation time.

1. Scheduling context and system model

RIGEO is defined on a heterogeneous fog-computing environment with three layers: IoT devices, a Fog layer, and the Cloud. The Fog layer contains fog nodes or fog controllers with different CPU capacities and energy characteristics. Tasks generated by IoT devices arrive at the Fog layer and must be assigned to fog nodes for execution. The fog network is modeled as a graph $G=(V,E)$, with nodes representing fog nodes and edges representing communication links.

The scheduling problem is expressed over a task set $T=\{t_1,\dots,t_n\}$, a fog-node set $F=\{f_1,\dots,f_m\}$, and a mapping $M:T\rightarrow F$ that assigns each task to exactly one fog node. Each task $t_i$ has a deadline $d_i$, and its realized response time depends on both network and processing effects. Capacity constraints are implicit rather than fully formalized; the scheduler is expected to assign tasks only to nodes that can accommodate them.

The central design decision in RIGEO is a two-way partition. Fog nodes are split according to traffic level: nodes with average traffic below the global average are treated as low-traffic, and nodes with average traffic at or above the global average are treated as high-traffic. Tasks are likewise divided into low-deadline and high-deadline classes using a deadline threshold. This produces a deadline- and traffic-aware decomposition of the overall scheduling problem.

2. Objective structure and mathematical definitions

The response-time model is given per task as

$R_i = P_i + T_i + E_i + Q_i$

where $P_i$ is propagation delay, $T_i$ is transmission delay, $E_i$ is execution time on the assigned fog node, and $T=\{t_1,\dots,t_n\}$0 is queue waiting time. The exact closed forms of these components are not expanded; they are handled through simulation-level network and CPU parameters.

Deadline violation is defined as tardiness relative to the task deadline:

$T=\{t_1,\dots,t_n\}$1

and the total deadline violation is

$T=\{t_1,\dots,t_n\}$2

Energy is modeled per fog node as

$T=\{t_1,\dots,t_n\}$3

with total system energy

$T=\{t_1,\dots,t_n\}$4

Here, $T=\{t_1,\dots,t_n\}$5 and $T=\{t_1,\dots,t_n\}$6 denote active and idle energy for node $T=\{t_1,\dots,t_n\}$7, while $T=\{t_1,\dots,t_n\}$8 and $T=\{t_1,\dots,t_n\}$9 are user-defined coefficients weighting active and idle energy.

The optimization goal is to minimize system energy consumption, task response time, and total deadline violation time while respecting node capacities as much as possible. A notable point is that no explicit scalarized multi-objective formula is printed. Response time and deadline violation are explicitly used in fitness evaluation, and energy minimization is emphasized in both the design rationale and the reported evaluation. Deadlines therefore function as soft constraints through the $F=\{f_1,\dots,f_m\}$0 penalty term rather than as hard feasibility conditions.

3. Improved Golden Eagle Optimization as the low-deadline scheduler

RIGEO inherits its metaheuristic core from Golden Eagle Optimization (GEO), a population-based swarm method inspired by golden eagles’ hunting behavior. In GEO, each eagle corresponds to a candidate solution, each eagle selects a prey, and the search is governed by attack and cruise movements. For eagle $F=\{f_1,\dots,f_m\}$1, the attack vector is

$F=\{f_1,\dots,f_m\}$2

the step vector is

$F=\{f_1,\dots,f_m\}$3

and the position update is

$F=\{f_1,\dots,f_m\}$4

In this formulation, $F=\{f_1,\dots,f_m\}$5 is the current position, $F=\{f_1,\dots,f_m\}$6 is the prey or best solution, $F=\{f_1,\dots,f_m\}$7 is the cruise vector, $F=\{f_1,\dots,f_m\}$8 and $F=\{f_1,\dots,f_m\}$9 are attack and cruise coefficients, and $M:T\rightarrow F$0 are random vectors in $M:T\rightarrow F$1. Cruise dominance corresponds to more exploration, while attack dominance corresponds to more exploitation.

Because standard GEO is continuous and task scheduling is discrete, RIGEO uses an Improved Golden Eagle Optimization (IGEO) variant that integrates genetic operators for discretization and search control (Sirjani et al., 9 Sep 2025). A candidate solution is a schedule encoding task-to-node assignments, typically as a vector whose entries are fog-node indices. For example, a vector such as $M:T\rightarrow F$2 denotes assignments of successive tasks to specific fog nodes.

The defining IGEO mechanism is the interpretation of the GEO step vector as a switch between exploration and exploitation. When the step is treated as negative, IGEO enters an exploration regime and applies mutation:

$M:T\rightarrow F$3

When the step is treated as positive, IGEO enters an exploitation regime and applies crossover:

$M:T\rightarrow F$4

This makes IGEO a discrete, GA-enhanced adaptation of GEO rather than a direct application of continuous GEO to a combinatorial space. Its conceptual loop is: initialize a population of schedules, evaluate response time, deadline violation, and energy, identify the global best, update each eagle through the GEO-derived regime decision, repair or penalize infeasible schedules, and iterate until termination. The paper describes IGEO fitness conceptually rather than by a single explicit equation; response time and deadline violation are central, and energy is treated as a key optimization metric.

4. Reinforcement learning for high-deadline tasks

The RL component is reserved for high-deadline tasks and operates over high-traffic fog nodes. The paper does not name a specific RL algorithm such as Q-learning or SARSA, and it does not provide an explicit update equation. Instead, RL is presented as a general agent-environment mechanism that iteratively improves schedules through reward and penalty signals (Sirjani et al., 9 Sep 2025).

The state representation is an array whose length equals the number of high-deadline tasks. Each cell corresponds to a task and contains the index of a fog controller that can accommodate that task. In effect, the state is a complete scheduling decision for the high-deadline subset:

$M:T\rightarrow F$5

The action space is not formally defined. A plausible interpretation, consistent with the description, is that actions modify the scheduling array by reassigning a task to another feasible fog controller or by making analogous discrete changes in the schedule. The environment then evaluates the new schedule in terms of the same QoS-oriented criteria used elsewhere in the framework.

The reward model is qualitative. If the result at state $M:T\rightarrow F$6 is better than at state $M:T\rightarrow F$7, the agent receives a reward; otherwise it receives a penalty. Improvement is judged by better scheduling performance, specifically lower response time, lower deadline violation, and lower energy. The paper therefore uses RL as a learning-based metaheuristic over the space of discrete assignments rather than as a fully formalized Markov decision process with explicit transition and value-update equations.

A recurrent misconception is to treat RIGEO as an RL-guided enhancement of IGEO. The reported design is different: the RL component does not tune or steer IGEO. It solves a separate subproblem, namely scheduling the high-deadline task subset on the high-traffic portion of the fog infrastructure.

5. Hybrid composition and scheduling workflow

RIGEO combines IGEO and RL through task-space partitioning. The two solvers are assigned disjoint operating regions rather than arranged in a nested or hierarchical optimization loop. The classification logic is based on average traffic among fog nodes and a deadline threshold for tasks. Traffic classification is periodically updated to reflect dynamic conditions.

Task category	Node category	Scheduling method
Low-deadline	Low-traffic	IGEO
High-deadline	High-traffic	RL

The scheduling procedure is summarized in the paper’s Algorithm 1. Fog controllers are first partitioned into Low_Traffic_FCs and High_Traffic_FCs according to whether fc.traffic_level < threshold. A task $M:T\rightarrow F$8 is then routed according to whether T.deadline < deadline_threshold. Low-deadline tasks are sent to a selected low-traffic node and processed by IGEO_PROCESS, whereas high-deadline tasks are sent to a selected high-traffic node and processed by RL_PROCESS.

This hybridization pattern is motivated by different computational profiles. The paper qualitatively characterizes GEO and IGEO as fast metaheuristics that can quickly yield satisfactory solutions, which is suitable for low-deadline tasks that must be handled promptly. RL is described as having higher time complexity, which makes it more appropriate for high-deadline tasks that possess greater scheduling slack. The resulting architecture is therefore both traffic-aware and deadline-aware at the level of solver selection.

Constraint handling follows the same decomposition. In both IGEO and RL encodings, each task is mapped to exactly one fog node. Capacity feasibility is enforced by assigning tasks only to nodes that can accommodate them, by repairing infeasible solutions, or by penalizing them heavily in evaluation. Deadline violations are not disallowed outright; they are penalized through $M:T\rightarrow F$9, making deadline satisfaction an optimization target rather than a hard admissibility rule.

6. Parameters, empirical evaluation, and interpretive limits

The reported experimental environment uses an Intel Core i7 @ 2.80 GHz, 16 GB RAM, Windows 10 64-bit, and MATLAB 2016, with 50 independent runs using parallel processing (Sirjani et al., 9 Sep 2025). Simulations use 20 fog nodes, CPU processing power per node randomly between 2000 and 6000 MIPS, energy usage per node randomly between 80 and 200 Joules, and task counts ranging from 200 to 600.

RIGEO is compared with four baseline algorithms: standard GEO, Grey Wolf Optimizer (GWO), WCLA+GA, and ETFC. The reported evaluation metrics are total energy consumption $t_i$0, total deadline violation time $t_i$1, total system response time $t_i$2, and resource utilization discussed qualitatively through energy and response improvements. Across task counts from 200 to 600, the reported outcome is that RIGEO achieves significantly lower energy consumption, lower total deadline violation time, and lower total response time than the listed baselines. The explanations offered for these results are smarter task-node assignments, the traffic/deadline partition, and the combined use of IGEO and RL.

The empirical discussion remains qualitative. Exact averages, standard deviations, and statistical significance tests are not reported in the text. This limits the precision with which comparative effect size can be assessed. Several additional limitations are explicit or strongly implied. The energy model is coarse, relying only on active and idle components weighted by $t_i$3 and $t_i$4, without fine-grained treatment of mechanisms such as DVFS or network-interface energy. The network model is similarly generic, using propagation and transmission delays without detailed link-level treatment. The RL component is underspecified algorithmically, since learning rate, discount factor, exploration strategy, and convergence properties are not given. Scalability is demonstrated only up to 600 tasks and 20 fog nodes, and large-scale deployments, multi-broker settings, dynamic failures, and abrupt traffic spikes are not deeply addressed.

These limits are important for correct interpretation. RIGEO should not be understood as a fully standardized RL architecture nor as a general-purpose theorem-backed scheduler. It is more precisely a problem-specific decomposition strategy coupled to a discrete GEO variant and a high-level RL scheduler. A plausible implication is that its strongest contribution lies in matching solver type to deadline slack and traffic condition rather than in introducing a unified formal learning theory for fog scheduling.