Fuzzy-Based Multi-Modal Query-Forwarding in Mini-Datacenters

Abstract

The rapid growth of Internet of Things (IoT) enabled devices in industrial environments and the associated increase in data generation are paving the way for the development of localized, distributed datacenters. In this paper, we have proposed a novel mini-datacenter in the form of wireless sensor networks to efficiently handle query-based data collection from Industrial IoT (IIoT) devices. The mini-datacenter comprises a command center, gateways, and IoT sensors, designed to manage stochastic query-response traffic flow. We have developed a duplication/aggregation query flow model, tailored to emphasize reliable transmission. We have developed a dataflow management framework that employs a multi-modal query forwarding approach to forward queries from the command center to gateways under varying environments. The query forwarding includes coarse-grain and fine-grain strategies, where the coarse-grain strategy uses a direct data flow using a single gateway at the expense of reliability, while the fine-grain approach uses redundant gateways to enhance reliability. A fuzzy-logic-based intelligence system is integrated into the framework to dynamically select the appropriate granularity of the forwarding strategy based on the resource availability and network conditions, aided by a buffer watching algorithm that tracks real-time buffer status. We carried out several experiments with gateway nodes varying from 10 to 100 to evaluate the framework’s scalability and robustness in handling the query flow under complex environments. The experimental results demonstrate that the framework provides a flexible and adaptive solution that balances buffer usage while maintaining over 95% reliability in most queries.

1. Introduction

Traditional datacenters are typically designed to handle data at larger scales in terms of zeta bytes $\left({10}^{21}\right)$ for enterprise applications, cloud storage, and services [1,2]. Further, the Internet of Things (IoT) is transforming various sectors [3,4], such as the industries, healthcare, energy, home appliances, agriculture, and business, and according to [5], the IoT is projected to grow to 40 billion devices by 2033. The rapid growth of IoT-connected devices has led to an explosion in data generation [6,7], which is expected to reach 79 zeta bytes in 2025 [8]. Transferring such large amounts of data from various interconnected devices to the cloud for processing would result in severe network congestion, emphasizing the limitations of traditional cloud-centric architectures in handling the demands of modern networks [9,10]. Thus, there is a demand for new approaches that rely on distributed networks instead of centralized processing [11].

To meet the demands of emerging IoT applications and use cases, several computing models, such as edge computing and fox computing, have been developed [12,13,14]. However, edge computing is often treated as an extension of the cloud, requiring advanced infrastructure to support real-time task processing. In industrial monitoring, IoT sensors facilitate query-based data monitoring for runtime verification of machine operations [15,16,17]. However, for applications with minimal computational needs, relying on expensive cloud datacenters is inefficient. Moreover, the traditional datacenters follow a partition/aggregation flow model [18], and the datacenters more often face congestion events [19], as they rely on coarse-grain mechanisms, such as priority flow controls [20], end–end congestion control protocols [21,22], and so on. These mechanisms may not be sufficient in resource-constrained environments, where reliability concerns are more pronounced.

To address this, we propose a mini-datacenter in the form of a wireless sensor network (WSN), featuring a layered-distributed architecture that operates efficiently at the edge of the network for data collection. The mini-datacenter is a three-layered system, consisting of a command center, gateways, and IoT sensors. The command center functions similarly to a central server in a cloud/traditional datacenter, handling query-response flow, analysis, storage, and decision-making. Gateways within the system are integrated and equipped with local storage capabilities, mainly for buffering data before forwarding it either to the command center or to the IoT/sensor devices within the network. The responses from the sensors are aggregated at the respective gateways, and the aggregated responses are refined at the command center in the query processing pipeline, primarily focusing on improving the reliability of the responses.

We have proposed a novel query flow management framework that employs:

➢

A duplication/aggregation query flow model,

➢

A multi-modal query forwarding mechanism, and

➢

A fuzzy logic intelligence-based dynamic query forwarding selection.

We have developed two query forwarding strategies: coarse-grain and fine-grain- based on the granularity of adaptability and reliability during query processing. In the coarse-grain approach, each incoming query is forwarded through a direct path involving the command center, an available gateway, and IoT sensors. Sensor responses are aggregated at the respective gateway and transmitted as a single data stream to the command center. This approach reduces data handling complexity but may compromise reliability. In contrast, the fine-grain approach offers a higher degree of reliability and adaptability. It forwards redundant copies of each query through at least two available gateways. Query processing is handled independently at respective gateways, and the aggregated responses are then compared at the command center to select the most reliable one.

To dynamically manage the granularity of the query flow, the framework is integrated with fuzzy logic intelligence, enabling it to select between two query-forwarding strategies based on the following:

➢

The ratio of fitted gateways to the deployed gateways, and

➢

The ratio of overloaded gateways to fitted gateways.

The coarse-grain approach is preferred in a high-frequency query flow and/or low-resource scenarios for efficient data flow management, while the fine-grain strategy is more suitable for a low-frequency or resource-rich situation, where enhanced reliability is essential. Our contributions in this paper are fourfold:

(i).

Modeling IoT-WSN as a mini-datacenter,

(ii).

Modeling the query-response task-flow within the proposed mini-datacenter,

(iii).

Deriving a relationship between redundancy, reliability, backlog, and buffer occupancy to account for the influence of these factors on query forwarding, and

(iv).

Defining fuzzy membership functions to select the granular forwarding strategies to manage the query flow.

In this paper, we have proposed a mini-datacenter in the form of a wireless sensor network for IIoT data collection, integrated with an intelligence query forwarding framework. The framework uses an objective function to determine the most effective number of redundant gateways that maximize the reliability while minimizing buffer overload. We have proposed and developed two forwarding strategies, such as coarse-grain and fine-grain, where the granularity is defined by the system’s adaptability and reliability needs. To support dynamic forward decision-making, we have defined fuzzy-logic membership functions that describe the relationship between fitted gateways and buffer occupancies, and help to select the level of granularity at the time of forwarding. We have found the effectiveness of the proposed mechanism from three aspects: (i) locating gateways with saturated buffer spaces that may lead to data drop, (ii) real-time inclusion or exclusion of gateways based on buffer status, and (iii) introducing controlled redundancy to maintain the reliability of the responses while avoiding buffer saturation.

We have implemented the framework prototype in a Python 3.12.7 programming environment and carried out a set of experiments with gateway counts ranging from 10 to 100 to analyze the scalability and robustness in complex environments. The experiments were repeated multiple times under varying environmental conditions, and the results were analyzed using several statistical evaluation methods, such as confidence intervals and error bars. The confidence interval analysis across varying gateway counts shows increasing reliability with narrower uncertainty bounds, highlighting the consistency and precision of the framework’s performance. The experimental results in network environments with heavily loaded buffers demonstrate that the developed framework managed the query traffic in mini-datacenters, maintaining over 95% reliability in most transmissions.

The rest of the paper is organized into six sections. Section 2 details the related work, and Section 3 discusses the architecture of the mini-datacenter. Section 4 details the modeling of query flow within the proposed mini-datacenter and the modeling of input and output fuzzy membership functions. Section 5 presents the computational flow of the proposed method, and Section 6 presents and discusses the outcomes of the experiments. Finally, Section 7 concludes the paper.

2. Related Work

Datacenters are evolving to meet the growing demands of escalating data volumes. In general, datacenter networks require multi-path load-balancing routing to optimize bandwidth usage. Many existing network forwarding protocols are optimized to select a single path. However, the data forwarding in enterprise and datacenter environments often use equal cost multi-path (ECMP) [23] to statically distribute flows across available paths through random flow hashing. This method resulted in overwhelming switch buffers. The authors in [24] proposed a simple algorithm to manage the dataflow within a datacenter using a centralized controller called ‘arbiter.’ This algorithm enabled the arbiter to distribute flows over different time points and paths in a preemptive scheduling and traffic load-balancing manner. He et al. [25] proposed pushing load balancing to the soft network edge (virtual switches), enabling load balancing without centralized traffic engineering, where the authors claimed that no changes in the transportation layer were needed. Conga et al. [26] employed congestion-aware switching on specialized switch chips to balance the load; however, the technique demanded hardware modification and it lacked awareness of local switch status. Vanini et al. [27] developed “LetFlow,” an algorithm that randomly picks a path for balancing network load, but the scheme did not react to congestion.

In recent years, the expansion of IoT has led to a growing number of intelligent information-aware devices, resulting in an exponential increase in generated data volume [28]. IoT data is of interest to both industry and research, making the collection and analysis of data essential for many purposes [29]. Moreover, the rise of ubiquitous computing has introduced numerous sensors and small devices, which have led to the connection of the devices to the cloud [30]. As IoT devices communicate through cloud datacenters, much of the data stored in the cloud is of little importance, leading to wastage of resources. Saqlain et al. [31] proposed a framework for an industrial data management system, where the authors focused on retrieving and collecting data generated by factory devices using a standard communication protocol. Srinivas et al. [32] proposed the development of geographically distributed cloud datacenters to manage the load, highlighting the need for distributed cloud datacenters instead of relying on centralized datacenters.

A paradigm shift from large cloud datacenters to small datacenters led to the introduction of edge datacenters [33], designed to handle data locally, thereby decreasing the dependency on the cloud datacenters [34]. On the other hand, decentralized cloud computing helps to distribute data to several nodes as a way of forming small datacenters, which increases the system’s ability to cope with node failures [35]. Sengupta et al. [36] presented a fog computing-based secure IIoT architecture by offloading a few tasks carefully to fog nodes. The authors claimed that these features secured the system while reducing the burden on the cloud and resource-constrained devices. However, the fog/edge datacenters require scaled-down versions of traditional datacenters’ infrastructure, making the implementation still expensive. Thus, it is necessary to propose a mini-datacenter that reduces both infrastructure and operational costs. However, the efficiency of data forwarding can be improved if it is incorporated with intelligence mechanisms.

The Industrial Internet of Things (IIoT) is central to digitizing manufacturing processes and enhancing automation across smart factories. As automation becomes increasingly integral to industrial operations, reliability emerges as a crucial performance indicator, measuring how consistently and accurately these systems function. However, maintaining high reliability in IIoT systems remains a significant challenge due to the unpredictable and dynamic nature of industrial environments [37].

Fuzzy logic has found numerous applications in artificial intelligence (AI) due to its ability to model human reasoning and decision-making processes. Fuzzy intelligence is utilized in data forwarding schemes, as it utilizes more than one parameter to make decisions. Tayyaba et al. [38] developed an IoT-based system for the safe mobility of blind people, as an added gadget to a smart home model. The authors utilized a fuzzy logic controller to develop an obstacle avoidance system and utilized fuzzy-based simulations to verify the developed model. Kan and Lim [39] utilized fuzzy logic for the selection of cluster heads while designing a data forwarding system to push the critical data generated during emergency situations, such as accidents, without data collision. A fuzzy-logic-based hierarchical routing is proposed by Raman et al. [40] to design a better IoT technologies-based healthcare. Kait et al. [41] proposed a fuzzy-logic-based trusted routing protocol for vehicular cloud networks to determine the node candidacy value while identifying a secure path.

We have previously explored various aspects of a WSN, with our prior work focusing on data aggregation in periodic data collection environments at the gateways [42,43]. The primary objective was to aggregate sensor responses at the gateways through task scheduling; the classical scheduling algorithms, such as ‘as soon as possible’ (ASAP), ‘as late as possible’ (ALAP), and ‘branch-and-bound’ (BB), were utilized for effective data aggregation. In subsequent research [44,45,46], we developed a fuzzy logic framework to assess the trustworthiness of sensors at the gateways and utilized the resulting trust values as control parameters to facilitate data transmission under uncertain environments [44,45,46]. We further developed a fuzzy framework that has enabled sensor nodes to become aware of the equipped resources and the environment conditions for implementing opportunistic transmissions for conserving energy within a wireless sensor network [47].

In this work, we have proposed a mini-datacenter in the form of a WSN for query-driven data collection within an IoT environment, and we have proposed and developed a fuzzy-logic-based multi-model data forwarding technique to dynamically adjust the granularity of transmission to ensure reliability.

3. Mini-Datacenter

We propose a mini-datacenter architecture that builds on top of the existing IoT framework that comprises many sensors. It is designed as a three-layered system: a data acquisition layer (sensors and actuators), an aggregation layer (gateways), and a query-response processing layer (the command center), as illustrated in Figure 1. The command center operates as a central coordinator, similar to a server in a traditional cloud datacenter, overseeing query and response flows, performing data analysis, and making system-level decisions.

Figure 1. Proposed three-layered mini-datacenter.

The command center (CC) has a queue to hold the incoming queries from the users and a queue to store the outgoing aggregated responses from the gateways. Gateways within the system are equipped with mini-storage facilities, allowing them to temporarily buffer data before either routing it to the IoT sensors or forwarding the aggregated response to the command center. In this architecture, the sensor responses are first aggregated at the respective gateways and then refined at the command center, primarily focusing on improving the reliability of the responses.

4. Modeling the Query Flow Within the Mini-Datacenter

We assume that there are M gateways $\left(G_1,G_2,G_3,\dots ,G_M\right)$, and each gateway has a fixed inflow and outflow storage capacity$B_i$, where$i=\mathrm{1,2},3,\dots ,M$. Each gateway has a buffer capacity $\left(B_{max}\right),$ and the forwarded queries stored in each gateway’s buffer cannot surpass its capacity. Each query burst at the command center (CC) is itemized and categorized into two types: an initial query $q_i$, which is part of the incoming query burst of size K $\left(Q=\left\{q_1,q_2,\dots ,q_K\right\}\right),$ and a set of generated queries $Q_R$, where $Q_R=q_i\times R\left(t\right)$, which are redundantly forwarded through the gateways. Here, the term $R\left(t\right)$ represents the number of redundant gateways selected at time instance t, and it varies according to the available gateways and backlog at the CC queue. Each gateway is associated with multiple sensors, and the incoming query $q_i$ is micro-partitioned by the gateway for processing by the sensors. We have developed two query forwarding approaches to forward the query from CC to G: (i) coarse-grain and (ii) fine-grain, as shown in Figure 2a,b.

Figure 2. Query forwarding approaches: (a) Course-grain and (b) Fine-grain.

In the coarse-grain approach, the query flow is directed from the command center (CC) to the sensors (S) through a selected gateway that can be viewed as a single directed acyclic graph (DAG). The sensor’s responses are aggregated at the respective gateway and then sent to the command center as a single data stream. In contrast, the fine-grain forwarding approach involves redundantly forwarding each query through multiple parallel pathways, with at least two, thus forming a parallelized directed acyclic graph (PDAG). The fine-grain approach offers a finer level of granularity to manage the system’s reliability and flexibility in response to variations in the query flow environment. Here, the flexibility refers to the system’s ability to respond to changes in the network conditions, such as fluctuations in workload distribution and available buffer space, while the reliability is influenced by the degree of redundancy. A query processing is performed individually at each selected gateway, and the aggregated responses are then compared at the command center to select the most reliable one.

4.1. Modeling Coarse-Grain Forwarding

In the coarse-grain approach, the gateway selection is modeled based on the availability of gateways and buffer occupancies, as shown in Equation (1). If there is only one gateway available, it is selected by default. However, if there are l multiple gateways with heavily loaded buffers $\left(B_i\approx B_{max}\right)$; then, the selection of a gateway may be the one with the least occupancy or a random one in case of similar occupancies. With the availability of multiple gateways, we have defined a score $S_{g_i}=(1-B_i\left(t\right)/B_{max})$ to each gateway based on its buffer occupancy, ranging from 1 (empty buffer) to 0 (completely filled buffer), as shown in Equation (1); the $g_i$, which has a maximum score, will be selected from the available gateways.

$$g_i^{selected}=\left\{\begin{array}{c}{g}_{i=}{G}_{avail}\\ P\left(g_{selected}=g_i\right)={\displaystyle \frac{1}{l}}\\ \left\{g_i|S=max\left(S_{g_1},S_{g_2,}\dots ,S_{g_l}\right)\right\}\end{array}\right.\begin{array}{c}if\left|G_{avail}\right|=1\\ if\left|G_{avail}\right|>1and(S_{g_1}=S_{g_2}=\dots =S_{g_l})\\ if\left|G_{avail}\right|>1and(S_{g_1}\ne S_{g_2}\ne \dots \ne S_{g_l})\end{array}$$

(1)

4.2. Modeling Fine-Grain Forwarding

Fine-grain forwarding approach selects multiple gateways to forward any query $q_i$ redundantly from the command center (CC); the selection of the number of gateways is restricted by the gateways’ buffer occupancy and the backlog of incoming queries waiting to be serviced at the CC. In the following subsections, we define and derive the fitness factor and the gamma factor to determine the number of gateways to be selected as redundant gateways, ensuring reliability while minimizing overflow at the gateways’ buffers.

4.2.1. Modeling Redundancy

A redundant query flow enhances the system’s reliability by creating backup channels for data and commands. We have modeled the redundancy based on two factors: the buffer capacity of gateways and the backlog of incoming queries in the command center’s queue. A redundant gateway list is defined to hold the fitted gateways, where the fitness $Fit(g_i$) of each gateway $g_i$at a given time t evaluates its readiness to handle additional traffic. This is determined by the gateway’s current buffer occupancy $B_i\left(t\right),$ relative to the maximum buffer capacity $B_{max},$ as stated in Equation (2). The fitness value ranges from 0 to 1, and it is defined in a piecewise manner to account for varying levels of buffer occupancy:

➢

When the buffer capacity of the gateway is less than or equal to half of the maximum capacity, the fitness is equal to 1, representing a state where the gateway has sufficient capacity.

➢

As the buffer occupancy increases from 50 to 100%, the fitness value decreases proportionally.

➢

Once the buffer is full, the fitness becomes equal to 0, indicating that the respective gateway cannot accept further data. This formulation ensures that gateways with sufficient buffer space are preferred for redundancy, while those nearing saturation are gradually excluded from the forwarding process.

$$Fit\left(g_i\right)=\left\{1-\begin{array}{cc}1& if{B}_i\left(t\right)\le 0.5\ast B_{max}\\ {\displaystyle \frac{B_i\left(t\right)-0.5\ast B_{max}}{0.5\ast B_{max}}}& if{0.5\ast B_{max}\le B}_i\left(t\right)\le B_{max}\\ 0& if{B_i\left(t\right)=B}_{max}\end{array}\right.$$

(2)

The gateways in the redundant list are sorted based on their fitness values, and those with a fitness value greater than a selected threshold (th) are designated as fitted gateways, as presented in Equation (3). The threshold value is determined according to the sensitivity requirements of the selected application, such as its accuracy or responsiveness.

$$G_{fitted}\left(t\right)=\left\{\left.g_i\right|{Fit(g}_i)>th\right\}$$

(3)

We have added the influence of incoming query backlog at the command center (CC) on redundancy by introducing a gamma factor$\gamma \left(t\right)$, as stated in Equation (4). A high backlog may indicate a surge in queries awaiting processing. At this point, selecting all fitted gateways will ramp up the buffer occupancies, leading to delays or data loss. To mitigate this, the gamma factor $\gamma \left(t\right)$ is modeled as a decreasing function that reduces the proportion of redundant gateways selected as the CC backlog $\left({BkLog}_{CC}\left(t\right)\right)$ increases. The term $\alpha$is a constant that controls the sensitivity of $\gamma \left(t\right)$ to changes in the backlog, and the term ${BkLog}_{CC}\left(t\right)$ represents the current query backlog at the command center at time t. The term qₘₐₓ refers to the maximum queue capacity of the CC’s input queue, while the term $q_{occupancy}\left(t\right)$ refers to the current occupancy of the queue. The gamma factor $\gamma \left(t\right)$ ranges from 0 to 1, representing the system’s adaptation from maximum backlog to no backlog.

$$\gamma \left(t\right)={\displaystyle \frac{1}{1+\alpha \ast {BkLog}_{CC}\left(t\right)}}\ast (1-{\displaystyle \frac{q_{occupancy}\left(t\right))}{q_{max}}})$$

(4)

As the backlog of queries increases, the term $1+\alpha \ast {BkLog}_{CC}\left(t\right)$ increases, which makes γ(t) to decrease. The second term, $\left(1-{\displaystyle \frac{q_{occupancy}\left(t\right))}{q_{max}}}\right)$ reduces the redundancy based on the queue occupancy. If $q_{occupancy}\left(t\right)$ approaches$q_{max}$, then the gamma factor $\gamma \left(t\right)$ decreases; thus, it reduces redundancy to avoid overwhelming the system when it is already heavily loaded. The number of redundant gateways selected from the fitted gateways is represented as in Equation (5). This mechanism helps maintain a balance between reliability and resource efficiency in real-time IIoT query processing.

$$R\left(t\right)=\mathrm{m}\mathrm{i}\mathrm{n}(\gamma \left(t\right)\ast {|G}_{fitted}|,\left|G_{fitted}\right|)$$

(5)

4.2.2. Modeling Reliability

We define the reliability (Re) of query-forwarding in the mini-datacenter as the probability that the query-forwarding has been performed successfully from CC to sensors through the gateways, which depends on the number of fitted gateways$\left|G_{fitted}\left(t\right)\right|$, redundancy R(t), and the probability of individual gateway reliability. We assume a reliability of P for a query flow with a single gateway availability, where P is the probability that a single gateway works successfully. We define reliability as in Equation (6), where it is varied between 0 and 1. Here, the term $G_{fitted}\left(t\right)$ represents the fitted gateways enumerated using Equations (2) and (3). If no fitted gateways are available, query-forwarding becomes entirely unreliable (Re = 0), and no queries are forwarded. If there is only one fitted gateway, the reliability is calculated as P, and if there are more than one fitted gateway, the failure probability of each gateway is raised to the power of the redundancy. If there are n gateways available, each with individual reliability P, the system fails only if all gateways fail. As the redundancy (R) increases, the term ${(1-P)}^R$ becomes smaller, thus the overall reliability (Re) approaches 1 (the maximum reliability).

$$Re=\begin{array}{cc}0& if\left|G_{fitted}\right|=0\\ P& if\left|G_{fitted}\right|=1\\ 1-{(1-P)}^R& if\left|G_{fitted}\right|>1\end{array}$$

(6)

4.3. Fuzzy Modeling of Granular Selection in Query Forwarding

We have utilized fuzzy modeling to select the appropriate query forwarding strategy for the mini-datacenter, which utilizes multi-modal query forwarding. Fuzzy logic can be computationally simple to implement in the resource-constrained WSN environment, and does not require heavy calculations like machine learning models; moreover, fuzzy rules can be easily designed to reflect the behavior of the system. The main objective is to determine when to use fine-grain forwarding (redundant) vs. coarse-grain forwarding (direct) based on the dynamic states of the number of available gateways and the localized congestion in the selected gateway buffers. Fuzzy logic enables a gradual transition between the coarse-grain and fine-grain strategies, allowing for decisions based on degrees of certainty rather than pre-defined thresholds.

We have considered two fuzzy input parameters: the proportion of available gateways ($G_{available}$) relative to the deployed, which reflects the degree of possible redundancy for query forwarding at time t, and the proportion of overloaded gateways ($G_{overload}$) against the available, which indicates the probable level of congestion. These parameters help to ensure a smooth query forwarding under varying load while minimizing the risk of data loss.

An output parameter is defined to select the forwarding strategy, which is either fine-grain or coarse-grain, based on the input conditions. The fuzzy system adapts in real-time to fluctuating conditions, making decisions that maximize the system’s reliability. Fine-grain forwarding is further subdivided into ‘low’, ‘medium’, and ‘high’, where redundancy is varied based on the mini-datacenters’ load; it maintains a minimum redundancy to enhance reliability. Instead, coarse-grain forwarding is preferred when gateways are heavily loaded or redundancy is not feasible, ensuring a seamless data flow.

4.3.1. Modeling Fuzzy Input Parameters

We have modeled the two input parameters (i) gateway availability ratio and (ii) proportion of overloaded gateways, by defining fuzzy sets and membership functions. A combination of triangular (to model a smooth increase or decrease) and trapezoidal membership functions (to represent conditions of saturation) is utilized to define the input membership functions. The gateway availability ratio ranges from 0 to 1, where a value of 0 represents no available gateways, while a value of 1 indicates that all deployed gateways are available. We have categorized this input parameter into three fuzzy sets: low, where less than 30% of the gateways are available, indicating more inclination towards coarse granularity, medium, where between 30% and 70% of the gateways are available, indicating moderate redundancy with possible fine granularity, and high, where more than 70% of the gateways are available, providing fine granularity with significant redundancy. We have selected a triangular membership function for low with peaks at 0.2, whereas a trapezoidal function for medium and high with flat peaks from 0.4 to 0.6 and 0.7 to 1, respectively, as demonstrated in Equations (7)–(9). The degree of membership variation is shown in Figure 3.

$${\mu }_{low}\left(x\right)=\left\{\begin{array}{c}0\\ x\ast 5\\ -10\ast (x-0.3)\end{array}\begin{array}{c}x\le 0orx>0.3\\ 0<x\le 0.2\\ 0.2<x\le 0.3\end{array}\right.$$

(7)

$${\mu }_{Med}\left(x\right)=\left\{\begin{array}{c}0\\ \left(x-0.3\right)\ast 10\\ 1\\ 1-(\left(x-0.6\right)\ast 10)\end{array}\right.\begin{array}{c}x\le 0.3orx\ge 0.7\\ 0.3<x\le 0.4\\ 0.4<x\le 0.6\\ 0.6<x\le 0.7\end{array}$$

(8)

$${\mu }_{Hi}\left(x\right)=\left\{\begin{array}{c}0\\ \left(x-0.6\right)\ast 10\\ 1\end{array}\begin{array}{c}x\le 0.6orx>1\\ 0.6\le x\le 0.7\\ 0.7<x\le 1\end{array}\right.$$

(9)

Figure 3. Input membership function—gateway availability.

The proportion of overloaded gateways ranges from 0 to 1, where a value of 0 represents low overloaded gateways, while a value of 1 indicates that gateways are highly overloaded. We have categorized this input parameter into three fuzzy sets: low, where less than 30% of the gateways are overloaded, reflecting minimal overloading, medium, where between 30 and 60% of the gateways are overloaded, indicating moderate overloading, and high, where greater than 60% of the gateways are overloaded, providing significant congestion. We have selected a triangular membership function for low with peaks at 0.2, whereas a trapezoidal function for medium and high with a flat peak from 0.4 to 0.6 and 0.7 to 1, as demonstrated in Equations (10)–(12), and the degree of membership variation is shown in Figure 4.

$${\mu }_{low}\left(x\right)=\left\{\begin{array}{c}0\\ x\ast \left({\displaystyle \frac{10}{2}}\right)\\ -10\ast (x-0.3)\end{array}\begin{array}{c}x\le 0orx>0.3\\ 0<x\le 0.2\\ 0.2<x\le 0.3\end{array}\right.$$

(10)

$${\mu }_{Med}\left(x\right)=\left\{\begin{array}{c}0\\ 10\ast (x-0.3)\\ 1\\ 1-(10\ast \left(x-0.6\right))\end{array}\right.\begin{array}{c}x\le 0.3orx>0.7\\ 0.3<x\le 0.4\\ 0.4<x\le 0.6\\ 0.6<x\le 7\end{array}$$

(11)

$${\mu }_{Hi}\left(x\right)=\left\{\begin{array}{c}0\\ 10\ast (x-0.6)\\ 1\end{array}\begin{array}{c}x\le 0.6orx>1\\ 0.6\le x\le 0.7\\ 0.7<x\le 1\end{array}\right.$$

(12)

Figure 4. Input membership function—overloaded gateways.

4.3.2. Modeling Rules

We have formulated a set of rules, as tabulated in Table 1, to define how the input variables “G_availability” and “G_overloaded” affect the state of the output variable, such as low, medium, and high. A low availability of gateways and a high congestion at the gateway buffers mapping to ‘low’ output state, leading to the selection of coarse-grain forwarding. The rules are designed to cover a range of input conditions to ensure that the fuzzy system provides appropriate outputs for various scenarios.

Table 1. Set of fuzzy rules.

No.	${\mathit{G}}_{\mathit{a}\mathit{v}\mathit{a}\mathit{i}\mathit{l}\mathit{a}\mathit{b}\mathit{i}\mathit{l}\mathit{i}\mathit{t}\mathit{y}}$	${\mathit{G}}_{\mathit{o}\mathit{v}\mathit{e}\mathit{r}\mathit{l}\mathit{o}\mathit{a}\mathit{d}\mathit{e}\mathit{d}}$	Output	Forwarding Technique
1	Low	Low	Low	Coarse
2	Low	Medium	Low	Coarse
3	Low	High	Low	Coarse
4	Medium	Low	Medium	Fine
5	Medium	Medium	Medium	Fine
6	Medium	High	Medium	Fine
7	High	Low	High	Fine
8	High	Medium	High	Fine
9	High	High	Low	Coarse

In the case of fine-grain forwarding, the medium and higher values of the fuzzy output are constrained by the redundant gateways, which are estimated from Equations (2)–(5) in Section 4.2.1.

4.3.3. Modeling Output Membership Function

The output membership function describing the forwarding technique is modeled as stated in Equations (13)–(15), and the degree of membership variation is demonstrated in Figure 5.

$${\mu }_{low}(x)=\left\{\begin{array}{c}x/0.3\\ 0\end{array}\right.\begin{array}{c}0\le x<0.3\\ x>0.3\end{array}$$

(13)

$${\mu }_{medium}(x)=\left\{\begin{array}{c}(x-0.3)/0.1\\ 1\\ (0.6-x)/0.1\\ 0\end{array}\begin{array}{c}0.3\le x<0.4\\ 0.4\le x\le 0.5\\ 0.5\le x\le 0.6\\ x>0.6\end{array}\right.$$

(14)

$${\mu }_{high}(x)=\left\{\begin{array}{c}0\\ (1-x)/0.4\\ 1\end{array}\right.\begin{array}{c}x<0.6\\ 0.6\le x\le 1\\ x>1\end{array}$$

(15)

Figure 5. Output membership function.

Each fuzzy rule generates a fuzzy set (membership function) for the output variable, and these fuzzy sets need to be combined to form the final output fuzzy set. The max operator is used to perform this aggregation, meaning that the fuzzy output set is created by taking the maximum membership degree of the individual rule outputs at each point.

5. Proposed Methodology

The proposed methodology, as demonstrated in Figure 6, begins by checking for the presence of a query or a set of query bursts at the command center (CC) queue. The query arrival rate is set greater than the service rate, so with an arrival of a set of query bursts, there will be a backlog of queries at the queue. The queries are dequeued in a FIFO fashion, and once a query with a specific burst size is dequeued, the burst size is set as a count to repeat the query forwarding loop. The framework itemizes the query burst into independent queries, and for each query, it selects a list of fitted gateways from the deployed ones to redundantly forward the selected query. This selection is driven by the current buffer occupancies, which are monitored using the buffer-watching algorithm. Gateways with fitness values greater rather the defined threshold are selected as ‘fitted gateways.’

Figure 6. The proposed methodology.

With the available list of fitted gateways, the gamma factor (backlog at CC) at the time of query forwarding is calculated to estimate the redundant number of gateways to be selected to forward that query. We have defined an overload threshold to list the overloaded gateways among the fitted gateways. Say, if the fitted gateways have fitness values ranging from 30 to 100%, overloading is checked against buffers with occupancies greater than 70%. So, there is a possibility for a gateway to be listed in the fitted and overloaded category at the same time. The proportion of fitted to available gateways and the proportion of overloaded gateways against the fitted gateways enables fuzzy intelligence to estimate the granularity level, resulting in the selection of an appropriate forwarding technique. The forwarding may be either coarse-grain with overloaded buffer occupancies or fine-grain with low or medium overloading. The procedure gets repeated until all queries are forwarded.

6. Results and Discussion

The experimental setup is comprised of a mini-datacenter equipped with a command center, 10 gateways equipped with 10 buffers of 20 units of length each, and the command center receives the queries with varying frequencies and with varying burst sizes. We have simulated an environment where the buffer occupancy varies with low, medium, and high to show the selection of forwarding techniques and the number of redundant gateways under varying operating environments. The buffer occupancies vary during query forwarding based on the defined arrival and service rate, increasing by one unit if the corresponding gateway is selected for redundant transmission and decreasing by one unit for all gateways for every three query forwarding, while maintaining the incoming rate greater than the service rate.

Based on the available gateways and buffer occupancies, the fuzzy logic technique utilizes the defined set of rules to calculate the performance and also selects the forwarding technique. We have varied the input membership parameters to change the selection of the forwarding technique.

6.1. Query Forwarding Behavior Within Mini-Datacenter

Several experiments have been performed to analyze and justify the proposed architecture to be suitable for query flow under various buffer occupancies, by measuring the reliability of transmissions as the evaluation metric.

6.1.1. Buffer Occupancy Nearing Saturation

The experimental setup is comprised of gateways with buffer occupancies ranging from 75 to 95% while they started receiving queries. The buffer occupancy of a gateway $g_i$ is varied with the query arrival rate greater than the service rate, as shown in Equation (16). The buffer occupancy variation over the query forwarding is demonstrated in Figure 7.

$${\displaystyle \frac{\partial B_{g_i}\left(t\right)}{\partial t}}=\left\{\begin{array}{cc}1& if{g}_{i}isincludedinredundanttransmission\\ -1/3& forall{g}_i\in G\end{array}\right.$$

(16)

Figure 7. Buffer occupancies of gateways during query forwarding.

The proportion of fitted gateways against the redundant gateways is plotted in Figure 8. The redundancy is influenced by the fitness factor and gamma factor, representing the current buffer occupancy and query backlog at the command center. Here, the fitted gateways with fitness values greater than 0.3 were selected to maximize the participation of available gateways.

Figure 8. Variation of redundant gateways against fitted gateways during query forwarding.

The gateway availability, buffer overloading, gamma factor, and redundancy selection all contribute to the query forwarding reliability is as illustrated in Figure 9. A sensitivity analysis was conducted to select the value for the parameter $\alpha$ (used in the gamma factor), where the values of $\alpha$ were varied from 0.01 to 0.1 to find out how the proportion of the query backlog influenced the selection of redundant gateways. Initially, the gamma factor was low (0.21) due to a high query backlog at the command center. As the query backlog decreased, the gamma factor increased to 0.73, which in turn increased the proportion of redundant gateways.

Figure 9. Query forwarding within the mini-datacenter.

The fitness value is selected as greater than 0.3, and the gateways with buffer occupancies of 70% or more were considered overloaded. The reliability is defined as the probability of successfully forwarding a query through the gateways, and it increases as the number of gateways increases. While the query forwarding mechanism is designed to consider buffer occupancy and network load for fair distribution, occasional imbalances were observed. Specifically, in scenarios with fewer gateway nodes (around 10), the inherent randomness in gateway selection sometimes caused a repeated selection of the same gateway, leading to localized buffer overload. Although constraints were introduced to prevent immediate reselection, limited gateway availability under these conditions still resulted in repeated assignments and uneven load distribution.

In this study, we assumed a probability (P) of 0.8 for successful direct transmission using a single gateway, according to [48]. The reliability ranges from 0.8 (for direct query forwarding) to a maximum of 0.9999 (with more than 50% redundancy). Based on the experimental results, it is observed that for a full gateway availability (10/10), with 50% redundancy (5/10), a 45% query backlog, and 50% buffer overloading, the reliability is close to its maximum value of 0.9968.

6.1.2. Buffer Occupancy with Medium Occupancy

In this experimental setup, the gateways were equipped with medium-occupied buffers, where the buffer occupancies ranged from 35 to 65%, as illustrated in Figure 10, and the buffer occupancies were found to be below 50% around 80% of the simulation time. The variation in gateway availability, overloading, gamma factor, and reliability is demonstrated in Figure 11. Since most of the buffer occupancies were less than 50%, the gamma factor was primarily influenced by the query backlog at the command center (CC), varying from 17% to a maximum of 100%. However, when the buffer occupancy reached 60%, the proportion of overloaded gateways increased towards the end of the simulation, and the gamma factor dropped to a lower value, which negatively impacted the number of redundant gateways involved in query forwarding. Gateway overloading was found to be minimal (zero) during 80% of the simulation, but it started to increase, reaching a maximum of 60% near the end. Here, the reliability of the query flow fluctuated between 96% and a maximum of 99%.

Figure 10. Gateways buffer occupancies during query forwarding with medium initial buffer levels.

Figure 11. Query forwarding with medium buffer occupancies.

6.1.3. Fuzzy Logic Intelligence in Query Forwarding

We have defined the query forwarding techniques based on the calculated performance from the fuzzy input variables. The proportion of overloaded gateways that have higher buffer occupancy compared to the total number of available gateways would give insight into the level of congestion across the gateways. If the performance is low (<0.2), then it is coarse-grain forwarding, and if it is medium, around 0.4, then it corresponds to fine-grain forwarding with minimal redundancy. For heavily overloaded buffers showing low performance, the forwarding technique is coarse-grain forwarding with no redundancy. For a gateway availability of 30% and overloading of 70%, the performance output is 0.17619, as demonstrated in Figure 12. Here, the forwarding technique is coarse-grain forwarding with a reliability of 0.8.

Figure 12. Performance for coarse-grain forwarding.

For high performance, the forwarding technique is a fine-grain forwarding with higher redundancy. For a gateway availability of 80% and overloading of 60%, the performance output is 0.7851, as demonstrated in Figure 13. Here, the forwarding technique is fine with higher redundancy (50%). The reliability is 0.96.

Figure 13. Performance for fine-grain forwarding.

6.2. Behavior of Mini-Datacenter Under Higher Nodes

We have carried out multiple experiments to analyze the query flow within the mini-datacenter for 100 gateway nodes, as shown in Figure 14. In run 8, the reliability index was slightly lower, ranging from 0.9 to 0.95, due to high buffer occupancy, which reduced the selection of redundant gateways. The average reliability across all runs was 0.9028, which is close to the average of 0.918 observed with 10 gateway nodes.

Figure 14. Reliability measurement for 100 gateways under heavy buffer occupancy.

6.3. Statistical Evaluation of Reliability in Scalable Mini-Datacenter

We have consolidated multiple experimental runs, as shown in Figure 15, and it is observed that the mean occupancy metrics increase as the gateway count rises from 25 to 100. This suggests that adding more gateways contributes to higher average occupancy performance, likely due to more efficient distribution of load or reduced congestion. Further, it is observed that the confidence intervals do not overlap between 25 and 50, while there is a slight overlap between 50 and 100, but still show an upward shift in performance.

Figure 15. Reliability against gateways count with 95% confidence interval.

7. Conclusions

In this paper, we presented a novel mini-datacenter architecture in the form of wireless sensor networks to efficiently manage query-based data collection from IIoT devices. The proposed system addressed the challenges of query forwarding under resource-constrained, fluctuating query traffic by incorporating a layered architecture, a query-flow management framework, and a multi-modal query forwarding approach. A command center, a set of gateways, and a set of IoT sensors formed the layered mini-datacenter architecture, where redundant query forwarding through multiple fitted gateways resulted in reliable transmission. Two forwarding techniques, such as coarse-grain and fine-grain, were proposed and developed for query transmission. Fuzzy-based intelligence was integrated within the developed framework, which facilitated dynamic selection between the two granularities, adapting to varying network conditions, ensuring a balance between reliability and congestion control. We tested the proposed framework with 10 to 100 gateway nodes to evaluate its scalability and robustness in complex environments, and the results show adaptive buffer usage while maintaining over 95% transmission reliability.