The traditional methodologies exhibit certain limitations, which are outlined below,

This work presents a dynamic request-aware fog-computing framework tailored for latency-sensitive healthcare IoT applications. Unlike existing approaches that address isolated aspects such as task scheduling, load balancing, or fault detection independently, the proposed framework integrates request dynamics analysis, adaptive fog-node deployment, fault-aware orchestration, and redundancy-aware offloading into a unified end-to-end management pipeline. The key technical contributions and novelties of this work are summarized as follows:

The rest of the paper is structured as follows: sections 2 and 3 present the analysis of the existing works and the proposed methodology, respectively. Results and discussion are presented in section 4. Section 5 presents the conclusion and future work.

Here, the request features like service type, request arrival time, source location, execution time, bandwidth, task, required memory, and response time requirement are extracted from (r^). These extracted features are denoted as (k).

Further, the dynamically varying request features from (k) are extracted using RTKDE to scale up the fog nodes effectively. The prevailing Kernel Density Estimation (KDE) effectively estimated the probability density function of a random variable and modeled complex distributions smoothly by placing a smoothing function. However, the dynamic request change extraction process is very slow due to the repeated computations of density. To overcome this, the Recurrent Tuning (RT) function is employed to adjust the bandwidth of the data. Primarily, the kernel (ϖ) is determined using a Gaussian function to represent the local density contribution of each (k). Also, the bandwidth (b̄) is estimated for each (ϖ) to control the width and spread of the kernels as shown in Equations 1, 2. Here, a larger bandwidth indicates the smoother density distribution, while a smaller bandwidth represents the noisier and sharper density distribution.

Where, (k_i) indicates the point where the density is to be estimated from (k), (π) is a numerical value, (ċ) and (ƛ) denote the width and span of the kernel, respectively. Further, the kernels are placed on (k_i) as shown in Equation 3 to build a smooth estimate of the density.

Where, (ξ.) denotes the normal distribution of (k_i). Then, the RT function (ψ) is employed to predefine the computations of the density.

Where, (b̄t-1) indicates the bandwidth of (ξ.) at the previous time step (t−1), (δ¨) signifies the learning rate, and (j′) is the local data volatility of (ξ.). Afterward, the probability density distribution (τ) is estimated by summing the normal distribution of all values of (k) as shown below.

Finally, from (τ), the dynamic request changes are extracted, and it is denoted as (I).

Where, (kl) represents the total number of the extracted dynamic request changes. The pseudo-code for RKTDE is given in Algorithm 1.

In this section, the request growth rate is assessed from (k) and (I) using EHWMA to determine the nature of the request's workload. Let (k) and (I) be denoted by (℘). The conventional Exponentially Weighted Moving Average (EWMA) effectively calculates the average of data points, and it is computationally efficient for resource-constrained devices like fog nodes. Yet, the sensitivity of the outcome is affected due to the unstable selection of the smoothing factor. Therefore, Half-life Function (HF) is utilized to control the responsiveness and stability.

First, the smoothing factor is selected using HF to avoid sensitivity in the outcome.

Where, (β) is the smoothing factor selected using HF and (h) indicates the half-life of (℘). Then, the initial moving average for (℘_j) is calculated as,

Where, (ṁ) indicates the initial moving average. Finally, based on (ṁ), the request growth rate is estimated using the following equation,

Where, (χ) indicates the request growth rate and (ṁt′-1) denotes the moving average of the features at the previous time step (t′−1). Here, the nature of the request's workload is determined based on the following condition rule (ğ).

Where,(J₁), (J₂) signifies the high load and low load of (℘) respectively, (T″) is the threshold based on the usual growth rate of (χ). If (J₁) is detected, then the fog node is scaled up first with optimal fog node deployment, followed by faulty node detection. If (J₂) is detected, the faulty fog node detection is performed directly without scaling.

In this section, the fog nodes are scaled up first to process (J₁) without a latency issue. The scaled-up fog nodes are denoted as (J˘1). Next, (J˘1) is optimally deployed in the fog computing environment using SHSBOA. The traditional Secretary Bird Optimization Algorithm (SBOA) is a meta-heuristic algorithm that simulates the hunting and evasion strategies of the secretary bird to solve optimization problems. Also, SBOA effectively explores the search space by balancing both exploration and exploitation for obtaining the best solutions. On the contrary, SBOA updated the solution space based on the independent random number in each dimension, which broke the structure in the problems by including the correlated variables. To resolve this, the Halton Sequence (HS) function is employed to cover the distributed points across the population.

Primarily, the population members are initialized in the search zone. Here, (J˘1) is considered as the secretary bird (ℑ) population. The initial position of the (l^th) secretary bird in the (z^th) dimension is expressed as,

Where, (r~) is the random number between (0 and 1), and (u.) and (ƛ) denote the lower and upper bound variables, respectively. Next, the fitness is determined by considering the minimum end-to-end delay (d̄).

Where, (ς) denotes the fitness of the population. Based on (ς), the position of the population is updated in the upcoming sections.

The faults in the fog nodes are detected under both low-load and high-load conditions to reduce communication overhead and minimize processing delays. Here, iFogsim data is simulated, and the simulated data features are extracted. Lastly, the fault fog node is detected using BiSHAGRU.

Primarily, the iFogsim input values (q_iFog) are generated using the iFogsim for detecting the fault fog nodes in the fog computing environment. Then, the significant iFogsim features like task execution time, response time, response time, response time, task migration count, and task waiting time in the queue are extracted from (q_iFog). These extracted features are denoted by (G).

Where, (xy) indicates the total number of features. Here, based on (G), the faulty fog nodes are detected using BiSHAGRU to avoid rerouting of the request. The conventional Bidirectional Gated Recurrent Unit (BiGRU) effectively processes the data in both directions and determines the dependency between the process before and after each time step. However, higher losses occur due to the improper tuning of the hyperparameter. Therefore, the Successive Halving (SH) function is utilized to find the best hyperparameter configuration of the model, thereby tuning the hyperparameter efficiently. In addition, the computational burden increased as the BiGRU captures all dependencies for long-range context. To avoid this, the Attention Layer (AL) is employed to focus on the most relevant time steps in the sequences, thereby reducing the complexity. The architecture of the proposed BiSHAGRU is shown in Figure 2.

Initially, the hyperparameters of the network are tuned using the SH function (χ), and it is given as,

Where, (g) is the hyperparameter of the network, and (ε) and (R¨) indicate the reduction factor and maximum epochs of the network, respectively.

In this phase, based on the features of (Z˘) and (k), the requests are evenly distributed to the fog nodes using SHSBOA. Let (Z˘) and (k) be denoted as (ℏ). Here, (ℏ) is considered as the secretary bird population. After initialization, the fitness is determined by considering maximum throughput (y_ab), minimum waiting time (y_bc), minimum response time (y_cd), and minimum latency (y_da).

Where, (ς˘) denotes the fitness of the population. Based on (ς˘), the position of the population is updated in the upcoming sections of SHSBOA, and the detailed explanation of SHSBOA is discussed in section 3.4.

Afterward, the requests are processed by the fog nodes in the fog layer without any latency issues. The fog layer acts as an intermediary between the edge devices and the cloud, thereby balancing computation, storage, and networking needs.

Further, the fog nodes offloaded the complex request or the request processed details to the cloud layer. However, the repeated data (r^rep) during offloading increases the network traffic and congestion. Hence, these (r^rep) are handled to avoid redundant data transmission, which is explained in the upcoming section.

Repeated data (r^rep) is handled by utilizing MAWRRL in the fog nodes to avoid network traffic and congestion. The traditional Multi-Agent Reinforcement Learning (MARL) effectively reduced the need for central control and improved the scalability in large systems, as the agents can learn independently. On the contrary, the agent that contributed to the outcome was not identified when the multiple agents shared a common reward. To avoid this, the Weighted Reward Function (WRF) is employed to differentiate the actions of each agent by assigning different weights to individual rewards.

Primarily, the agents (A) are initialized in the environment (Ĕ) as follows,

Where, (jj) indicates the total number of agents in the environment. Further, the state (ṡ) and rewards (r↔) are also initialized as follows,

Where, (Ψ′) signifies the feature representation of the (ṡ) and (r↔). Then, the policy (P↔) is determined for the agents to maximize the long-term reward. Further, based on (P↔) and (r^rep), the agents choose an action (δ⌢) to execute in the environment.

Finally, the agents receive multiple rewards for (δ⌢) carried out in the environment. Here, WRF (η.) is employed to assign different weights to individual rewards.

Where, (λ¨(r↔)) specifies the multiple rewards given to the agents for (δ⌢) and (ψ⌢) indicates the weight assigned to (r↔) of the (ih^th) agent. This process is repeated iteratively. Finally, after convergence, the agents share their rewards with each other. During this sharing process, if multiple agents have obtained the same reward, only a single instance of that reward is offloaded to the cloud. Conversely, any unique reward obtained by an agent is individually offloaded to the cloud. This approach ensures that redundant data is minimized while all distinct rewards are properly transmitted. Implementation and training parameters are given in Table 1. Thus, the proposed framework processed the enormous requests of the healthcare IoT devices in the fog computing layer by considering the dynamic request-aware fog node deployment and reducing the latency efficiently.

The values are generated using the iFogsim simulator for fault detection in fog nodes. During the simulation, faults are injected into the values to create the fault scenarios, resulting in approximately 23,765 data samples. Among these, 80% samples (19,012) are used for training, and the remaining 20% (4,753) are used for testing.

In this section, the performance of the proposed work is validated regarding various performance metrics. The performance analysis of dynamic request change extraction, request growth rate analysis, load balancing, repeated data handling during offloading, fault node detection is explained in the subsequent subsections.