Offloaded Computation for QoS Routing in Wireless Sensor Networks

Abstract

In Wireless Sensor Networks (WSNs) used for real-time applications, ensuring Quality of Service (QoS) is essential for maintaining end-to-end performance guarantees. QoS requirements are typically defined by a set of end-to-end constraints, including delay, jitter, and packet loss. In multi-hop scenarios, this requires multi-constrained path computation. This research examines the standard Routing Protocol for Low-Power and Lossy Networks (RPL), which employs a Destination-Oriented Directed Acyclic Graph (DODAG) for data transmission. Nonetheless, there are several challenges related to multi-constrained route computation in the RPL: (1) The DODAG originates from an objective function that cannot manage multiple constraints. (2) The process of computing multi-constrained routes is resource-intensive, even for a single path. (3) The collection of QoS-compatible paths does not necessarily form a DODAG. To address these challenges, this paper suggests modifications to the existing protocols that shift computationally demanding tasks to edge servers. Such a strategic adjustment allows for the implementation of QoS-compatible route computation in WSNs using the RPL. It enhances their ability to meet increasingly stringent demands for QoS in numerous application environments.

1. Introduction

In communication networks, Quality of Service (QoS) represents the essential requirements a network must fulfill to provide adequate service to its users. These requirements are articulated through specific conditions that must be satisfied for effective communication between a source and a destination [1]. It is important to acknowledge that QoS requirements can differ significantly among various applications, leading to distinct challenges within large-backbone networks and inter-domain and intra-domain contexts. Various comprehensive tools operating across different layers of the OSI protocol are available to support service providers in delivering QoS to users with particular needs. Traffic Engineering (TE) assumes responsibility for managing queues with designated priorities while employing diverse packet forwarding strategies, primarily at the Media Access Control (MAC) layer.

QoS encompasses the performance, reliability, and availability levels that an application and its underlying infrastructure can deliver effectively. The objectives of QoS are integral to the decision-making processes associated with capacity allocation, load balancing, and admission control. A Service Level Agreement (SLA) is typically established between the service provider and the user to outline the expected services and their corresponding performance metrics. Additionally, the SLA specifies the methodologies for measuring performance and details the consequences of failing to meet the agreed-upon standards.

Performance metrics are generally categorized into two primary classes: functional and non-functional metrics [2].

• Functional Metrics: These metrics define Key Performance Indicators (KPIs) that significantly impact user perceptions. Key examples include latency, energy efficiency, throughput, packet loss rate, and jitter. Each functional metric must be clearly defined for each service provided.
• Non-Functional Metrics: These metrics assess service performance concerning deployment and management considerations. Notable examples include service availability, fault tolerance, service processing, and computational load.

It is essential to highlight that QoS is classified as a functional metric, while performance, reliability, and availability are regarded as non-functional metrics.

Wireless Sensor Networks (WSNs) are increasingly recognized for their effectiveness in collecting and communicating various data types across applications such as environmental monitoring, healthcare, and smart city development. In large-scale WSNs, data transmission to a sink node primarily utilizes a multi-hop routing mechanism, enabling data packets to be relayed through multiple intermediate nodes before reaching their final destination. These networks are designed to gather information that must be forwarded to applications requiring specific levels of QoS, including bandwidth, delay, jitter, and packet loss. Such information must be forwarded reliably to a sink node, base station, or border router (BR) for further processing. It is imperative to effectively address QoS requirements, often characterized by multiple constraints, through routing protocols specifically designed for WSNs, ensuring the reliability and optimal performance of the network.

Recent studies, such as CERP [3], have investigated cooperative routing methods that improve both energy efficiency and QoS guarantees in WSNs. The primary objective of QoS in WSNs is to optimize network performance in alignment with user-defined requirements. Solutions often prioritize different types of traffic and allocate resources necessary to accommodate varying transmission needs, such as data, voice, and video. For instance, the IEEE 802.11e standard modifies the Media Access Control (MAC) layer by introducing different priority levels, known as access categories, which facilitate the effective categorization and scheduling of traffic. In a study by Mangold et al. [4], the Enhanced Distributed Channel Access (EDCA) mechanism was proposed as an improvement to the widely adopted Carrier Sense Multiple Access with Collision Avoidance (CSMA/CA) protocol. This enhancement increases the likelihood of successful message transmission for high-priority traffic directed toward the coordinating access point.

Main Contributions

Although many RPL-based QoS routing extensions have been proposed in recent years [5,6,7], a critical research gap persists: most solutions either rely on modifying the RPL objective functions [8,9], adopt loosely coupled metric composition techniques that reduce transparency and control [10], or lack the computational scalability necessary to efficiently handle multiple concurrent QoS constraints [7,11]. Furthermore, very few approaches leverage edge computing to offload the path computation workload in a centralized and conflict-resilient manner.

This research targets QoS-aware routing in Wireless Sensor Networks (WSNs), where the goal is to find routes that satisfy multiple QoS constraints simultaneously. When multiple QoS criteria are involved, the problem becomes a Multi-Constrained Optimal Path (MCOP) problem, known to be NP-complete. Traditional approaches often require significant computational resources and do not guarantee a feasible solution, even when one exists.

The Routing Protocol for Low-Power and Lossy Networks (RPL) [12] is the de facto standard for routing in WSNs. However, incorporating multi-constrained QoS support within the RPL remains challenging due to the increased processing complexity and associated control overhead. The existing RPL extensions often trade scalability for QoS-awareness or compromise protocol compatibility by modifying objective functions.

To address these challenges, our work proposes a scalable, modular, and standard-compliant architecture that enables QoS-aware routing without altering the RPL internal mechanisms. The main contributions are summarized as follows:

1.

A formal problem formulation that defines multi-constrained QoS routing in WSNs as an NP-complete MC(O)P problem and contextualizes its integration challenges within the structural and computational limitations of the RPL.

2.

A centralized QoS route computation algorithm that computes multiple feasible and non-dominated paths while preserving full compliance with RPL objective functions [5,12,13], enabling seamless deployment over standard-compliant networks.

3.

An edge offloading architecture that delegates path computation and DODAG construction to external servers [2,14,15], significantly reducing the processing burden on constrained sensor nodes. This design contrasts with prior in-network QoS routing approaches [16,17] and aligns with the recent trends in computation offloading to external infrastructures for enhanced QoS, as also explored in hybrid satellite networks [18].

4.

A lightweight conflict detection and redundancy augmentation mechanism that builds robust loop-free DODAGs under QoS constraints without increasing control overhead. This avoids the complexity of previous extensions that depend on metric redefinition or extensive signaling [9,10].

5.

Comprehensive performance evaluation under varying network sizes, QoS constraint profiles, and BR placements. The results show that the proposed approach preserves between 143% and 1282% more QoS-satisfying nodes compared to the heuristic- and composition-based baselines, with an average improvement of over 560%, validating its scalability and robustness under strict multi-constraint conditions.

6.

New insights into QoS routing dynamics in WSNs, including how the number of QoS constraints, path feasibility rates, and route lengths interact. These findings offer practical guidelines for QoS-aware WSN planning and deployment.

To substantiate the novelty of the proposed work,

Table 1. Comparison of the proposed work with representative QoS-aware RPL-based routing solutions.

Aspect	Gaddour et al. [16]	Ghaleb et al. [5]	GRPAR [19]	OMC-RPL [20]	TDL-BasedProtocol [21]	ProposedApproach
Modification of Objective Function	Yes	Yes (Composite metrics)	No	Yes (custom multi-metric)	No (cross-layer based)	No
Increase in Control Overhead	Yes (Fuzzy logic extension)	Moderate (multi-metric dissemination)	Low (greedy heuristic)	Moderate (multi-class weighting)	Moderate (cross-layer metrics)	No
External Offloading to Edge	No	No	No	No	No	Yes
Lightweight Conflict Detection	No	No	No	No	No	Yes
Redundancy Augmentation Mechanism	No	No	No	No	No	Yes
Standard Compliance with RPL	Partial	Partial (Objective Function modifications)	Partial	Partial	No (non-RPL based)	Full

This comparison highlights key architectural and functional improvements of our proposed model over prominent RPL-based QoS-aware routing solutions regarding scalability, protocol compliance, and offloading support.

provides a comparative analysis with selected representative works. The comparison highlights the distinctive features of our approach in terms of protocol compliance, control overhead minimization, and support for lightweight, conflict-free, and redundant path construction.

The remainder of this paper is structured as follows: Section 2 reviews the related work. Section 3 introduces our model for multi-constrained path computation and its key challenges. Section 4 outlines the architecture and core procedures of the proposed edge-assisted QoS routing approach. Section 5 analyzes the complexity of the proposed algorithms. Section 5.4 presents a comparative evaluation between our offloaded DODAG computation and two heuristic-based solutions. Finally, the conclusions and future research directions are discussed in Section 6.

2. Related Work

Various solutions have been proposed across different levels of communication networks to effectively manage Quality of Service (QoS). For instance, Traffic Engineering (TE) offers tools for classifying flows, utilizing class-based or priority-based frameworks and policy-based scheduling to manage queues, as well as flow rate limitations to mitigate congestion (e.g., flow control in TCP and traffic shaping). Among the most recognized QoS-aware solutions are Integrated Services (IntServ) and Differentiated Services (DiffServ) [22].

2.1. QoS Routing in Wireless Sensor Networks

Extensive surveys have been conducted to analyze QoS-aware routing protocols for WSNs [23,24,25,26].

Table 2. Summary of literature review on QoS in WSNs and IoT.

Ref.	Objectives and Contributions	Limitations
Singh et al. [30]	Introduced reinforcement learning for multi-objective QoS optimization in edge-enabled WSN-IoT systems.	complexity of simultaneous multi-objective optimization.
Benelhourri et al. [31]	Proposed an evolutionary genetic algorithm for Cluster Head (CH) selection in WSNs; energy-efficient CH selection and routing.	Fitness function tuning can be computationally intensive.
Chandnani et al. [32]	Proposed a hybrid protocol for data aggregation and reactive routing to improve QoS at the network layer in WSNs. Enhances routing efficiency and data collection.	Not explicitly tested for energy efficiency in large-scale deployments. Primarily simulation-based, and lacks implementation in diverse environments.
Lenka et al. [33]	Proposed hierarchical routing for IoT using k-means clustering and fuzzy inference. Effective CH selection and reduced intra-cluster communication.	Computational complexity of CH selection in resource-constrained networks.
Ghawy et al. [34]	Developed a multi-path protocol using Particle Swarm Optimization (PSO) for traffic fairness and load balancing in WSNs.	PSO may require high computation time and lacks real-world testing on dynamic WSN topologies.
Pundir et al. [35]	Comprehensive analysis of QoS parameters and frameworks of machine-learning-based QoS techniques in WSNs.	Focused on literature review without detailed implementation.
Gantassi et al. [36]	Combined K-means clustering with a mobile data collector (MDC) for QoS improvement in large-scale WSNs.	MDC introduces additional complexity and latency; mobility optimization is not addressed.
Afroz et al. [37]	Proposed an energy-efficient MAC protocol using Q-learning and adaptive modulation for QoS improvement.	Limited to specific scenarios; may lack scalability in diverse WSN applications.
Samridhi et al. [38]	Compared SDN-enabled WSNs to conventional WSNs using the RPL and identified overhead trade-offs.	Limited to small-scale testbeds.
Mostafaei et al. [39]	Highlighted SD-WSN improvements via OpenFlow for QoS provisioning in resource-constrained environments.	Design flaws identified in SDN-based WSNs, with high computational overhead.
Cisco [22]	Differentiated Services (DiffServ) approach for prioritizing traffic classes to meet QoS requirements.	Less suited for resource-constrained WSNs; focused on Internet-scale networks.
Karakas et al. [40]	Provided a detailed overview of SDN architecture for centralized and programmable flow management to enhance QoS and optimize resource allocation.	Overhead in resource-limited WSNs and latency in centralized SDN designs.

provides a comparative overview of existing approaches, highlighting their objectives, methodologies, and observed limitations. Figure 1 categorizes QoS routing protocols over Wireless Multimedia Sensor Networks (WMSNs) into four main categories. The first category, real-time requirements, classifies protocols based on timing constraints, distinguishing between hard and soft real-time requirements. The second category, decision-making methodology, defines how routing decisions are made, either probabilistically or deterministically. The third category, network topology, organizes protocols based on network structure, including hierarchical, flat, and location-based approaches. Finally, protocol operation groups protocols according to their functional approach, such as QoS-aware, negotiation-based, or multi-path. The categories presented in Figure 1 represent key classifications of QoS routing protocols in Wireless Multimedia Sensor Networks (WMSNs). However, these are not the only possible categorizations. Other classifications exist based on mobility support, fault tolerance, security, and energy efficiency. For a more comprehensive discussion, readers can refer to [26,27,28,29].

One of the paramount applications of WSNs lies within the Internet of Things (IoT). In these networks, sources are often located at considerable distances from the sink, gateway, or BR, necessitating multi-hop communication. According to Lenka et al. [33], intelligent routing in WSNs is critical to enhancing QoS in IoT environments. They proposed a hierarchical structure utilizing K-means clustering, where a Cluster Head (CH) is selected within each cluster through a fuzzy inference system. Subsequently, sensors transmit data packets to their respective CHs, which forward the data to the sink node. To determine suitable CHs, Benelhourri et al. [31] introduced an evolutionary (genetic algorithm)-based routing approach with a novel fitness function. Additionally, Gantassi et al. [36] combined the K-means method with a mobile data collector (MDC) to enhance the clustering efficiency in large-scale WSNs. In parallel, El-Fouly et al. [41] addressed the challenges of real-time data delivery in smart city applications by proposing an environment-aware, energy-efficient, and reliable multi-sink routing scheme. Similarly, Cherappa et al. [42] introduced an adaptive swarm-based fuzzy optimization (ASFO) technique integrated with a cross-layer expedient routing protocol, effectively improving both the energy efficiency and QoS in WSNs.

QoS requirements are typically contingent upon several parameters or metrics. The anticipated outcomes of QoS can be articulated as constraints, suggesting that the pertinent QoS parameters should remain within predefined intervals. The most straightforward method for specifying QoS is establishing a set of such constraints. Additionally, objective functions can be delineated to identify optimal paths. In [10], the authors distinguished between primary and composite metrics. By combining several primary routing metrics, a composite metric can be formulated, optimizing multiple performance aspects. The proposed combinations may either take the form of a weighted sum or a lexical combination of the primary metrics, the latter necessitating an explicit prioritization of the metrics under consideration according to a strict hierarchical order. The foundational routing metrics and their combinations to generate composite routing metrics were outlined in [43]. Utilizing a routing algebra, the authors demonstrated that the routing protocol converges to optimal routes and can be reliably employed within the RPL.

The concept of Software-Defined Networking (SDN) facilitates the realization of advanced software-supported mechanisms. According to [40], SDN is characterized by its centralized nature, where controllers maintain a comprehensive view of the network, programmability, separation of data and control planes, and optimization of flow management and resources. QoS provisioning is rendered more straightforward and practical for network administrators by implementing the OpenFlow standard.

In Software-Defined Wireless Sensor Networks (SD-WSNs), the SDN paradigm enables the remote configuration of forwarding elements with forwarding rules for data packets across various flows. The computation is centralized in the control plane, which can enhance the operational efficiency of WSNs [39]. A comparative analysis of the performance of conventional WSN networks using the RPL versus SD-WSNs was presented in [38]. The experimental findings confirm the anticipated overhead associated with SD-WSNs and reveal design flaws inherent in SDN architectures. A review of Traffic Engineering tools in traditional and Software-Defined Networks can be referenced in [44]. Notably, given that sensors possess limited capacities and energy resources, resource-intensive solutions of Traffic Engineering cannot be applied within WSNs.

2.2. QoS Extensions to RPL

The RPL (Routing Protocol for Low-Power and Lossy Networks) is a standardized protocol designed to establish a multi-hop tree-based mesh topology over networks characterized by lossy links. Its primary objective is to facilitate data delivery from source nodes, such as sensors, to sink nodes or BRs. This protocol, which operates within the framework of IPv6, employs a distributed route construction mechanism overseen by an objective function (OF), tasked with selecting the optimal links for route mapping. Nevertheless, the RPL is susceptible to challenges related to mobility and reliability.

The routing architecture employed in the RPL is structured as a Destination-Oriented Directed Acyclic Graph (DODAG). An effective and adaptive link quality estimation (LQE) is crucial for selecting the optimal routing paths, especially under dynamic network conditions. Research by Ancillotti et al. [45] presented a link quality estimation method that leverages reinforcement learning techniques. Additionally, Khallef et al. [17] introduced a novel objective function and two heuristic routing algorithms that adhere to QoS constraints for multi-constrained QoS routing within Low-Power and Lossy Networks (LLNs). Their approach accommodates constraints and metrics for QoS routing, allowing for non-linear path lengths.

Definition 1 

(Non-linear length). Let $\overrightarrow{w\left(e\right)}$ be the vector of K values of QoS parameters in the edge e and $\overrightarrow{L}$ be the vector of the K-tolerated end-to-end values for any QoS paths. The non-linear length of a path P is a scalar

$$w_{NL}\left(P\right)=\underset{i=1,\dots ,K}{max}{\displaystyle \frac{{\sum }_{e\in P}{w}_i\left(e\right)}{L_i}}$$

In a related study by Xue et al. [46], an auxiliary edge weight was computed as $w_a\left(e\right)={max}_{i=1,\dots ,K}{\displaystyle \frac{w_i\left(e\right)}{W}}$ for each edge e using a constant value W. The authors suggested that this constant could be replaced with an application-specific value $L_i$, providing a “projection” of the non-linear length onto the edge. The shortest path can then be determined using this auxiliary weight to identify QoS-compliant routes.

Furthermore, a method compatible with the RPL that incorporates non-linear length considerations was proposed by Khallef et al. [17]. Within the DODAG construction process, each node is expected to retain a weight vector computed from the sink to itself. The preferred parent node among neighbors is identified as the one that offers the minimal non-linear path length for the given node, and this selection is communicated to the neighboring nodes. This algorithm links all the nodes within the subtree, rooted at the respective node, along the same path, although this may not always yield feasible solutions for certain nodes.

Khallef et al. [17] discussed modifications to determine the optimal paths for all nodes, striving for an ideal solution. These modifications involve a decision-making mechanism that allows nodes sufficient time to gather alternative paths from potential parent and child nodes. This strategy ensures that comprehensive information is available to inform optimal decision-making. It is important to note that this solution demands considerable computational resources and may introduce significant delays in the system’s response.

Additional modifications are suggested, including limiting the number of analyzed paths to a specified integer value k, which aligns with the computational approaches outlined in [47]. The findings indicate that exact route computations may not be advisable given the resource constraints inherent in LLNs.

2.3. Recent Trends

The recent literature indicates a growing interest in QoS-aware solutions that utilize machine learning techniques. Machine learning is recognized as an effective approach that enhances performance through training, observation, and analysis of historical data, enabling predictive capabilities regarding future outcomes based on accumulated data. A systematic review by Pundir [35] offers insights into various performance parameters. The key QoS parameters discussed in this context include scalability, throughput, energy consumption, latency, packet loss ratio, packet error ratio, reliability, availability, maintainability, bandwidth, jitter, cost, bit error rate, periodicity, priority, deadlines, confidentiality, integrity, safety, and security.

Ensuring robust QoS is crucial in the realm of next-generation 6 G-enabled devices. Effective QoS protocols are essential for optimizing network performance and enhancing user experience quality. The authors of [48] proposed a reinforcement-learning-based multi-objective optimization method for addressing QoS in edge-enabled WSNs and the IoT, focusing on simultaneously optimizing objectives such as energy consumption, latency, throughput, and coverage to achieve Pareto-optimal solutions.

The key challenges associated with this topic encompass the feasibility of QoS requirements, inadequate formulations, oversimplification, the homogenization of diverse scenarios, dynamic network conditions, unstable routing paths, and substantial overloads.

The noteworthy solutions to tackle these issues involve traffic classification, prioritization, centralized computations, leveraging fog and edge resources, hierarchical organization, clustering, applying machine learning techniques, and implementing multi-path routing strategies. The subsequent section will elaborate on the objectives of our recent investigation into QoS routing in WSNs.

3. System Model and Problem Formulation

This section introduces the problem formulation for multi-constrained QoS routing in WSNs.

3.1. Network and Graph Model

Our goal is to enable the WSN to utilize the RPL mechanism for routing while meeting multiple QoS constraints. The objective is to identify a set of paths from sources to destinations within a multi-objective and multi-constraint framework, specifically using aggregated additive metrics. We require an exact model based on evaluated graphs to tackle the associated challenges and develop effective propositions. This section outlines a graph model representing the network topology, which is essential for formulating the fundamental routing decision problem. From this model, we will discuss the key issues and assumptions that must be addressed to achieve QoS routing for WSNs. We assume wireless communication, where the graph nodes correspond to sensors, relays, actuators, sinks, and more. For simplification, we consider sensors as the sources, which can also function as relays, while the sinks are defined as gateways or BRs. In large networks, sending messages directly to sinks is often impossible, necessitating multi-hop communication.

We assume symmetric communication links. Under this assumption, the topology is represented by an undirected graph $G=(V,E)$ (or a directed graph in the case of asymmetric links). Positive values for QoS-related metrics are assigned to the edges in E. It is important to note that critical QoS-related metrics and constraints, such as the remaining energy or state of the routers, can also be considered for routing. However, this study focuses solely on calculating QoS paths based on link values. The most commonly used metrics and their types are mentioned in RFC6551 [49]. Metrics can be categorized as either aggregated or recorded.

In this discussion, we will assume aggregated metrics. The values that characterize a path can be derived or cumulative values from the link values. In summary, metrics are classified into three categories: additive metrics: the value associated with the path is the sum of the link values (e.g., delay); multiplicative metrics: the path value is the product of the link values (e.g., the probability of lossless transmission); and bottleneck-type metrics: the most critical link value characterizes the path (e.g., bandwidth).

3.2. Multi-Objective vs. Multi-Constrained Routing

In the multi-objective formulation, multiple objective functions are established to be optimized simultaneously. For example, one objective might minimize cost, while another aims to maximize bandwidth. These objectives can often contradict one another; the path that minimizes cost may not be the best for bandwidth and vice versa. A solution is deemed Pareto-optimal if no objective can be improved without compromising at least one other objective. Consequently, there may be several Pareto-optimal solutions for a given problem. Related routing analyses can be found in [50], with examples in [51]. Additionally, multiple metrics can be combined into a composite metric, allowing multi-objective research to be reformulated into a single-objective optimization problem.

The goal of multi-constrained routing is to identify a feasible (or, in some cases, optimal) path that satisfies a set of QoS constraints. In our study, the parameters are additive. Since this problem is NP-complete, the solutions proposed in the literature either take considerable time or do not reliably locate a solution, even if one exists. The most efficient algorithm for solving this routing problem is SAMCRA [52]. This routing is essential for supporting QoS in real-time multimedia applications within wireless mesh networks [51]. Further examples of routing protocols can be found in [17,53]. Multiple objectives and constraints can be integrated to define the goals of the routing process further.

3.3. Key Challenges

The focus of our study is on the issue of multi-constrained routing from sensors to sinks and BRs. Given that the RPL is a recognized standard, our investigation primarily revolves around this protocol. The RPL establishes a structured, tree-like, Destination-Oriented Directed Acyclic Graph (DODAG) for routing purposes. The paths from sensors to the sink/BR constitute a directed incast route. It is evident that, under multiple QoS constraints, a singular directed tree may not always suffice [17].

Challenge 1: A Unique DODAG Cannot Satisfy the QoS Requirements of All Sensors.

A single DODAG may not adequately address the multi-constrained QoS routing needs in a specific WSN and its QoS specifications. The illustration in Figure 2 demonstrates that a DODAG cannot accommodate all nodes, even within a limited domain. For instance, consider two additive QoS parameters (e.g., delay and cost). The maximum tolerated values, delineated as ${\overrightarrow{L}}^T=(13,13)$, indicate the QoS limits at the BR, with corresponding link values depicted in Figure 2. Only the specified blue and red QoS paths from nodes E, F, and G to the BR can be utilized. Given that these paths share a common prefix, the routes from G and F combine to form a single DODAG. However, it is crucial to note that no single QoS-compatible DODAG can incorporate the path from E to the BR. The figure presents two distinct DODAGs (red and blue) that cannot be unified. Nodes B, C, and D are present in both QoS paths and can, therefore, choose between the blue and red paths to transmit messages to the BR. The routing decisions for messages originating from these nodes lack clarity, rendering the unambiguous configuration of the routing table challenging. For example, at node C, messages from node E must be routed to node D, while messages from F must be directed to node B.

Challenge 2. Paths from sensors far from the BR may not meet QoS demands.

Let $L^T=(11,11)$ represent the vector of the QoS requirements in the network shown in Figure 2. None of the routes from nodes E, F, and G to the BR fulfill this QoS requirement. The routes from nodes E, F, and G to the BR satisfy this QoS requirement.

Challenge 3: The optimal DODAG under QoS constraints is NP-hard.

Assuming that distances are calculated using a non-linear length function based on multiple additive metrics, the DODAG can be viewed as a minimum-cost, diameter-constrained arborescence directed from its non-root nodes (sources) to the root node (BR). The undirected version of this problem, which involves only one additive hop distance, is known to be NP-hard [54]. Furthermore, the minimum cost r-arborescence problem, where r refers to the root node, is also NP-hard. We conjecture that the problem of directed diameter-constrained r-arborescence using non-linear weights is also NP-hard.

4. Proposed Methodology

This section outlines the architecture and core procedures of the proposed edge-assisted QoS routing approach. As the RPL is the standard Low-Power and Lossy Network (LLN) routing protocol, this work enhances its applicability under challenging QoS routing conditions through architectural and procedural extensions. A viable strategy to address the limitations of resource-constrained devices in Wireless Sensor Networks (WSNs) is to offload computationally intensive tasks to external edge resources. Such offloading extends the network’s functional capacity and enables scalable support for multi-constrained QoS routing.

4.1. Architectural Overview

While cloud computing is widely adopted, its physical distance from WSN devices can introduce unacceptable latency for time-sensitive QoS applications. The drawbacks of relying solely on cloud infrastructures are emphasized in [15], where data centers struggle to meet real-time data processing demands. To address these limitations, edge and fog computing paradigms have emerged, providing localized computation to reduce latency and alleviate central processing bottlenecks.

Among these, multi-access edge computing (MEC) offers particular advantages by enabling proximity-aware task delegation and high-performance processing. MEC architectures for WSNs, as highlighted in [55], have demonstrated improved support for distributed QoS routing. Furthermore, MEC reduces the energy and computational burden on sensors [14], although optimal offloading remains a complex optimization problem [56,57,58].

4.1.1. Centralized Computation Framework

In QoS-aware WSNs, path computation is a multi-constrained optimization problem. The classical RPL cannot efficiently support this process as it relies on distributed in-network computations. Such computations are unfeasible under tight QoS constraints due to sensor nodes’ limited processing and memory capacities, as well as their lack of global network visibility. To address these limitations, we propose a centralized offloading approach in which edge servers compute feasible conflict-free DODAGs and disseminate them to the network. The proposed system is implemented using a custom C++ framework built on the LEDA library. This framework enables efficient dominance checks, Pareto-optimal path enumeration, and scalable DODAG construction—capabilities not natively supported in NS-3 or Cooja. The design explicitly separates the route computation phase from runtime operation, facilitating modularity and protocol compliance. The framework consists of the following key components:

(a)

QoS-aware route computation on the topology graph under given constraints.

(b)

Network (re)configuration, where DODAGs are deployed and adjusted across nodes.

(c)

Monitoring, where nodes report status changes that may trigger reconfiguration.

Once deployed, the network uses a standard RPL over precomputed DODAGs, preserving protocol compliance while enabling enhanced QoS guarantees.

4.1.2. Feasible and Non-Dominated Path Computation (Algorithm 1)

This algorithm computes the set of high-quality paths from the BR to all other nodes in the network, where each path must (i) satisfy multiple Quality of Service (QoS) constraints and (ii) be non-dominated concerning the considered metrics (e.g., delay, energy, and reliability). The output of this process is a collection of Pareto-optimal routing options that serve as candidates for DODAG construction.

The algorithm operates iteratively in the following manner:

1.

Initialization: Each node is assigned an initially empty set of paths. The algorithm starts by injecting a fictive zero-weight path containing only the BR.

2.

Path Expansion: Using a breadth-first search style expansion, every path is iteratively extended by one-hop neighbors. For each new candidate path:

• The path’s cumulative QoS metrics are computed.
• If the path exceeds any QoS threshold, it is discarded.

3.

Dominance Checking: Feasible paths are compared to existing paths at the destination node:

• If a new path dominates an existing one, the latter is discarded.
• If it is dominated by another, it is not stored.

4.

Path Limiting: At most, k non-dominated paths are stored per node to limit complexity.

5.

Termination: The expansion continues until no new feasible non-dominated paths are found.

The final result is a structure that captures up to k high-quality paths per node, all originating from the BR, and forms the basis for conflict-free DODAG construction.

Algorithm 1 Feasible and Non-Dominated Path Computation

Require:  Network graph $G=(V,E)$                 QoS weights per edge                 Maximum number of paths per node k Ensure:  $Paths\left[n\right]$: feasible, non-dominated paths for each node neach node $n\in V$ 1: Initialize: 2: for all nodes $n\in V$ do 3:     $Paths\left[n\right]\leftarrow \varnothing$ 4: end for 5: Insert initial trivial path at BR: $Paths\left[BR\right]\leftarrow \left\{\right[BR\left]\right\}$ 6: Mark all paths as unprocessed 7: repeat 8:     $new\_paths\_found\leftarrow$ false 9:     for all nodes $current\_node\in V$ do 10:         for all unprocessed paths $path\in Paths[current\_node]$ do 11:            for all edges $link$ from $current\_node$ do 12:                $next\_node\leftarrow$ target of $link$ 13:                $extended\_path\leftarrow$ append $link$ to $path$ 14:                if $extended\_path$ satisfies QoS constraints then 15:                    $dominated\leftarrow$ false 16:                    for all $existing\in Paths[next\_node]$ do 17:                        if $extended\_path$ dominates $existing$ then 18:                           Remove $existing$ from $Paths[next\_node]$ 19:                        else if $existing$ dominates $extended\_path$ then 20:                           $dominated\leftarrow$ true 21:                        end if 22:                    end for 23:                    if not $dominated$ and $\left|Paths\right[next\_node\left]\right|<k$ then 24:                        Add $extended\_path$ to $Paths[next\_node]$ 25:                        $new\_paths\_found\leftarrow$ true 26:                    end if 27:                end if 28:            end for 29:            Mark $path$ as processed 30:         end for 31:     end for 32: until  $new\_paths\_found=\mathbf{false}$       return  $Paths$

4.2. Conflict-Free DODAG Construction (Algorithm 2)

The computation of optimal DODAGs is a well-known NP-hard problem. Although exact solutions based on Integer Linear Programming (ILP) have been proposed [59], they are computationally prohibitive due to the exponential number of feasible path combinations. In such formulations, routing is modeled as a directed flow from the BR to each destination node, where each flow corresponds to a valid path. The superposition of these flows yields the optimal hierarchical structure. However, computing the exact solution is often unfeasible in practical deployments. Therefore, our work adopts a greedy conflict-avoidant strategy aimed at constructing efficient and structurally consistent DODAGs that meet QoS requirements while avoiding the computational overhead of exhaustive search.

Algorithm 2 Conflict-Free DODAG Construction

Require:  Set of feasible and non-dominated paths $P\left[n\right]$ from Algorithm 1 for all $n\in V$ Ensure:  Set of conflict-free DODAGs $\mathcal{D}=\{D_1,D_2,\dots \}$ 1: Initialize $\mathcal{D}\leftarrow \varnothing$                                               ▹ Set of constructed DODAGs 2: Let $U\leftarrow \{n\in V\setminus \{BR\}\mid P[n]\ne \varnothing \}$          ▹ Unintegrated nodes with feasible paths 3: while  $U\ne \varnothing$  do 4:     Initialize a new DODAG $D\leftarrow \varnothing$ 5:     $integrated\leftarrow$ false 6:     while true do 7:         $selected\leftarrow$ null 8:         $minCost\leftarrow \infty$ 9:         for all $n\in U$ do 10:            for all $path\in P\left[n\right]$ do 11:                if $conflicts(path,D)=false$ and $cost\left(path\right)<minCost$ then 12:                    $selected\leftarrow path$ 13:                    $minCost\leftarrow cost\left(path\right)$ 14:                end if 15:            end for 16:         end for 17:         if $selected=\mathbf{null}$ then 18:            break                                       ▹ No more conflict-free paths can be added 19:         else 20:            Add $selected$ to D 21:            Remove destination node of $selected$ from U 22:            $integrated\leftarrow$ true 23:         end if 24:     end while 25:     if $integrated=true$ then 26:         Add D to $\mathcal{D}$ 27:     end if 28: end while       return  $\mathcal{D}$

To structure the offloaded computation, three categories of paths are distinguished:

• Feasible paths: those satisfying all end-to-end QoS constraints.
• Dominated paths: Pareto-dominated by other feasible paths.
• Ready paths: those for which no feasible successors can be obtained by adding adjacent edges.

The offloaded computation proceeds in three stages:

1.

Computation of feasible and non-dominated paths that meet the QoS constraints.

2.

DODAG construction: Construction of one or more DODAGs from the selected paths.

3.

Redundancy augmentation: Addition of redundant links to enhance robustness and support local repair.

After computing all feasible and non-dominated paths using Algorithm 1, the second stage involves organizing these paths into valid DODAGs. This is non-trivial because multiple paths may conflict structurally when forming a shared hierarchy. Algorithm 2 constructs DODAGs using a greedy conflict-avoidance strategy to address this. The process follows these key steps:

• Initialization: Identify all nodes with at least one feasible QoS-compliant path. These nodes are candidates for DODAG construction. Begin with an empty DODAG set.
• Greedy Path Selection: For each candidate node, select the path with the shortest non-linear length (a cumulative cost over multiple QoS metrics).
• Conflict Detection: Before integrating a path into the DODAG, verify its structural compatibility:

  –

  Compute the common prefix between the candidate path and the current DODAG, starting from the BR.

  –

  A conflict is detected if the candidate path shares a node with the DODAG outside of this common prefix, which may lead to ambiguous routing decisions.

• Path Integration: If no conflict is detected, the path is added to the DODAG, and the corresponding node is marked as integrated.
• Iteration and Expansion: Repeat the process until no additional non-conflicting paths remain. If any feasible nodes are still unintegrated, initiate a new DODAG and repeat.
• Output: A set of conflict-free DODAGs that preserve QoS constraints and allow for consistent routing semantics.

This method efficiently avoids the computational cost of evaluating all combinations of path superpositions, which would be necessary for exact optimization. This approach avoids the combinatorial explosion associated with exact path superposition and efficiently produces conflict-free topologies.

The first step of this pipeline—feasible path computation—is implemented by Algorithm 1, which explores the network in the reverse direction, from the BR to the source nodes. The output is an array P where each element $P\left[n\right]$ contains a set of feasible non-dominated paths ending at node n.

Initially, a fictive path with zero weight is created for the BR and marked as not ready. A main while loop then iterates over all paths and nodes. If a path is not yet ready, its successors are generated by appending one-hop neighbors. Each new path is evaluated for feasibility and dominance; if both conditions are satisfied, it is added to the respective node’s path set as a not ready path. Once all of a path’s successors are evaluated, it is marked as ready, thus preventing redundant checks.

DODAG construction: Using these feasible paths, Algorithm 2 incrementally builds the DODAG by evaluating paths in increasing order of non-linear length. A path is added only if it introduces no conflicts, as described above. Figure 3 illustrates a typical conflict scenario, where two paths share a node beyond the common prefix, making routing decisions at that node unfeasible. If the constructed DODAG does not cover all feasible nodes, additional DODAGs are created using the same method, restricted to the remaining nodes.

Redundancy augmentation: The third step in the pipeline enhances robustness by adding redundant links that support local repair. For each path from a leaf node to the BR, potential alternative parents are evaluated as follows:

Let a be a node with rank k (i.e., k hops from the BR), and let $\overrightarrow{L_a}$ be the cumulative QoS metric vector for the subtree rooted at a. For each adjacent node b (with rank $\le k$), we compute

$$\overrightarrow{L_a}+\overrightarrow{L_{a,b}}+\overrightarrow{L_b}$$

where $\overrightarrow{L_{a,b}}$ is the metric vector on arc $(a,b)$, and $\overrightarrow{L_b}$ is the cumulative vector from b to the BR. If this sum satisfies the global QoS bound $\overrightarrow{L}$, then arc $(a,b)$ is added as an alternate link to support local recovery. The procedure is implemented in Algorithm 3.

The first step in the proposed architecture involves the computation of feasible non-dominated paths. Algorithm 1 describes the centralized computation of these paths in the reverse direction: from the sink, i.e., the BR, to all source nodes. This reverse construction is reverted at the end of the computation to match the data-forwarding direction.

The algorithm maintains an array P, where $P\left[n\right]$ stores a set of feasible non-dominated paths from the BR to node n. Initially, a fictive zero-cost path consisting of a single node (the BR) is created and marked as not ready. The algorithm then iteratively expands each path in P by appending adjacent edges. Whenever a successor path satisfies all QoS constraints and is non-dominated with respect to existing paths in $P\left[n\right]$, it is stored as a candidate. Each new path is initially marked as not ready to allow for its further expansion in subsequent iterations. Once all possible successors of a path have been evaluated, the path is marked as ready to avoid redundant computation.

Based on the set of feasible non-dominated paths, the second step constructs the DODAGs. Computing the optimal DODAG structure—or the minimal number of DODAGs that span all feasible nodes—is known to be NP-hard [59]. Existing exact solutions, such as Integer Linear Programming (ILP), require evaluating all possible combinations of path superpositions, which is computationally unfeasible for large networks. The ILP formulation interprets each path as a flow from the BR to a destination, and the optimal hierarchy emerges from the superposition of these flows.

To overcome the scalability limitations of such approaches, we propose a greedy and conflict-resilient algorithm (cf. Algorithm 2) to construct one or more conflict-free DODAGs. The stored paths are explored in ascending order of non-linear length—a composite metric reflecting the aggregated QoS cost.

Before integrating a candidate path into the DODAG under construction, a conflict check is performed as follows:

(a)

A common prefix between the candidate path and the current DODAG is computed, starting from the BR. If no common prefix exists, the prefix is simply $\left\{BR\right\}$.

(b)

A conflict is detected if the candidate path shares any nodes with the DODAG that lie beyond the common prefix. This structural ambiguity could render routing decisions invalid or contradictory.

An example conflict is illustrated in Figure 3. Suppose a path $P_2$ is to be added to a DODAG that already includes path $P_1$. If node f exists in both paths but is reached via different parent nodes (c in $P_1$ and e in $P_2$), this results in an inconsistency in routing decisions, thereby violating DODAG correctness.

The candidate path is added to the DODAG if no conflict is found. The algorithm proceeds iteratively until no further paths can be integrated without conflict. At this point, if feasible nodes remain not yet included in any DODAG, a new DODAG is initialized, and the process repeats. The final result is a set of conflict-free DODAGs covering all feasible nodes. For use in the RPL, the direction of the arcs is reversed.

If the computed DODAG(s) do not span all nodes with feasible paths, the greedy algorithm is reapplied to construct additional DODAG(s) from the remaining paths.

The third and final step introduces redundancy into the DODAG(s) to support local repair mechanisms. Paths from the leaves to the BR are examined to identify alternate parent links. Let a be a node on such a path with rank k (i.e., hop distance from the BR), and let $\overrightarrow{L_a}$ be the maximum vector of QoS metrics from the leaves up to a in its subtree. Consider an adjacent node b with rank $\le k$ that is reachable via a different path. Denote the QoS metric vectors along edge $(a,b)$ and from b to the BR as $\overrightarrow{L_{a,b}}$ and $\overrightarrow{L_b}$, respectively. If the total cost $\overrightarrow{L_a}+\overrightarrow{L_{a,b}}+\overrightarrow{L_b}\le \overrightarrow{L}$ (where $\overrightarrow{L}$ denotes the end-to-end QoS threshold), then $(a,b)$ is considered a valid backup link and is added as an alternative arc. This process is formalized in Algorithm 3.

Algorithm 3 Add Redundant Links to a DODAG

Require:  Topology graph $G=(V,E)$;                  a constructed DODAG $D=(V_D,E_D)$;                  maximum allowable QoS vector $\overrightarrow{L}$ Ensure:  Modified DODAG D with additional redundant links 1: for all $a\in V_D$ do                                             ▹ For each node already covered in the DODAG 2:     $Adj\leftarrow \mathrm{adjacentNodes}\left(a\right)$ 3:     for all $b\in Adj$ do 4:         if $b\in V_D$ and $\mathrm{rank}\left(a\right)\ge \mathrm{rank}\left(b\right)$ then 5:            Compute $\overrightarrow{L_a}\leftarrow$ max QoS from leaves to a in subtree 6:            Compute $\overrightarrow{L_{a,b}}\leftarrow$ QoS on link $(a,b)$ 7:            Compute $\overrightarrow{L_b}\leftarrow$ QoS from b to BR in D 8:            if $\overrightarrow{L_a}+\overrightarrow{L_{a,b}}+\overrightarrow{L_b}\le \overrightarrow{L}$ then 9:                $E_D\leftarrow E_D\cup \left\{(a,b)\right\}$                                                       ▹ Add alternative parent link 10:            end if 11:         end if 12:     end for 13: end for       return  D

4.2.1. Redundancy Augmentation (Algorithm 3)

After conflict-free DODAGs are constructed using Algorithm 2, routing robustness is enhanced by introducing redundant links. These links function as backup forwarding paths, thereby improving the fault tolerance and resilience of the network. Such links are particularly valuable for enabling the RPL local repair mechanisms, allowing recovery from transient failures without requiring global recomputation. Including redundant links is performed in a controlled manner that preserves adherence to the original QoS constraints, ensuring that the augmented DODAGs remain compliant with end-to-end requirements such as delay, reliability, and energy consumption.

Algorithm 3 examines each node a in the DODAG and its adjacent neighbors b. For each neighbor b, a link $(a,b)$ is considered for addition if three conditions are met:

1.

Node b is part of the DODAG and its rank is not higher than that of node a.

2.

The aggregated QoS cost along the path from a leaf node to a, the direct link $(a,b)$, and the path from b to the BR, denoted by $\overrightarrow{L_a}+\overrightarrow{L_{a,b}}+\overrightarrow{L_b}$, satisfies the global QoS constraint $\overrightarrow{L}$.

3.

The resulting path structure remains acyclic and consistent with RPL directionality.

Each successful insertion of a backup edge expands the routing graph without disrupting its primary hierarchical structure. This strategy ensures that nodes have alternative forwarding options in case of link failures, supporting improved reliability and load balancing during runtime.

The network must be (re)configured either initially or when modifications occur, requiring a new set of DODAGs. The reconfiguration process involves removing outdated connections and establishing new ones. An effective reconfiguration should minimize disruption to ongoing communications with the BR and be executed as efficiently as possible. Prior research on reconfiguration processes for paths and trees, particularly multicast trees in optical networks, can be found in [60,61].

The reconfiguration generally follows a predefined schedule, where, at each step, a subset of nodes are updated. The list of nodes requiring reconfiguration (highlighted as gray nodes in Figure 4) is provided, while other nodes retain their original parent–child relationships in both the old and new DODAGs. In this example, we assume that node M can switch to an alternative parent F, while nodes J and N can adopt H as their alternative parent. Additionally, the newly established paths from M, J, and N to the BR meet the required QoS constraints.

A key feature of DODAG-based reconfiguration is that the new configuration automatically replaces the old one. During this process, existing traffic remains uninterrupted while new connections are established. The new DODAG is calculated by edge servers, ensuring that each covered node has a viable path. Throughout the reconfiguration, the previous version of the topology remains accessible on the server. Figure 4 illustrates the transition between the $old$ and $new$ topologies. As shown in the figure, a subset of nodes requires reconfiguration, while others retain their previous settings. The initial network setup is a special case in which all nodes need to undergo configuration.

4.2.2. Greedy, Priority-Based, and Descending Reconfiguration

A greedy, priority-based, and descending reconfiguration approach is proposed. The process begins at the BR and progresses rank by rank, configuring the necessary nodes in sequence (ranks of the ’new’ DODAG are indicated in Figure 4). Initially, nodes without parents must be configured. This descending method ensures uninterrupted message transmission to the BR by maintaining an active path between the nodes in the $old$ DODAG and the BR at each step.

4.2.3. Lightweight Network Monitoring

The WSN must guarantee operation without interruptions (or minimal disruption) and meet the QoS requirements for QoS-aware applications. If the topology changes (due to mobility, disappearance of nodes, or important changes in QoS link values), advertisements for the edge servers are needed. If a local repair of the RPL can correct the problem, no intervention is needed from the servers. The changes are indicated thanks to monitoring performed by the sensor nodes. Since the availability of the nodes and the quality of the communications (the link values) should be controlled, active monitoring is applied [58].

To balance the power load of monitors, an alternating and scheduled set of active monitors is applied [62]. The measured values are sent to the BR (and edge servers) using a dedicated simple DODAG.

Note that the protocol is also suitable for applications where finding multiple feasible paths is important (e.g., in networks where fault tolerance or alternative paths are required).

5. Theoretical and Experimental Evaluation

In this section, we analyze the worst-case time complexity of the proposed algorithms. Each algorithm’s complexity is derived by examining its key operations, including initialization, loops, and computational steps. The summary of the algorithms’ complexities is provided in

Table 3. Summary of algorithm complexities.

Algorithm	Worst-Case Complexity
Algorithm 1 (Non-Dominated QoS Paths)	$O\left(\right|V{|}^3{k}^2)$
Algorithm 2 (DODAG Computation)	$O\left(\right|V{|}^3)$
Algorithm 3 (DODAG Redundancy)	$O\left(\right|V{|}^2)$

.

5.1. Complexity of Algorithm 1: Computation of Non-Dominated QoS Paths

This algorithm computes non-dominated QoS paths in a graph. The worst-case complexity is determined by analyzing its loops and path-processing steps.

5.1.1. Initialization

• The algorithm initializes paths for each node in P, taking $O\left(\right|V\left|\right)$ time, where $\left|V\right|$ is the number of nodes.
• Creating a fictive path and assigning it to the border router ($BR$) takes constant time, $O\left(1\right)$.

5.1.2. Main Loops and Path Processing

• While Loop (Line 13): Runs until all paths are evaluated. Since paths do not revisit nodes, a path can contain at most $\left|V\right|-1$ nodes. Thus, the While loop executes at most $O\left(\right|V\left|\right)$ times.
• For Loop (Line 15): Iterates over all nodes, contributing another $O\left(\right|V\left|\right)$ factor.
• Path Comparisons (Lines 17–30):

  –

  Each node stores at most k paths.

  –

  Every adjacent edge is processed, bounded by $O\left(\right|V\left|\right)$.

  –

  The number of path comparisons is $O\left(k^2\right)$ per node.

Thus, the worst-case total number of path comparisons is

$${O\left(\right(\left|V\right|-1)}^2{k}^2\left|V\right|)={O\left(\right|V|}^3{k}^2)$$

(1)

Final complexity of Algorithm 1:

$$O\left(\right|V{|}^3{k}^2)$$

(2)

This complexity arises due to nested loops and path comparisons involving $O\left(k^2\right)$ operations per edge and node.

5.2. Complexity of Algorithm 2: Computation of the DODAG(s)

This algorithm computes DODAGs from QoS paths. The worst-case complexity is derived by analyzing the key operations.

5.2.1. Initialization

• The set of nodes $QoSN$ (nodes with at least one QoS path) are constructed in $O\left(\right|V\left|\right)$ time.
• Initializing the set of DODAGs $SD$ is conducted in $O\left(1\right)$ time.

5.2.2. Main Loops and DODAG Construction

• While Loop (Line 12): In the extreme case, each node forms a separate DODAG. Since there can be at most $\left|V\right|-1$ DODAGs, this loop executes at most $O\left(\right|V\left|\right)$ times.
• For Loop (Line 14): Iterates over all nodes in $QoSN$, adding another $O\left(\right|V\left|\right)$ factor.
• While Loop (Line 17): Processes paths, with operations involving set operations that take at most $O\left(\right|V\left|\right)$ time.

Final complexity of Algorithm 2:

$$O\left(\right|V{|}^3)$$

(3)

The worst-case complexity is due to nested loops iterating over nodes and paths and the processing involved in constructing the DODAGs.

5.3. Complexity of Algorithm 3: Adding Redundancy to a DODAG

This algorithm enhances redundancy in a DODAG by evaluating and adding new edges based on adjacency constraints.

5.3.1. Initialization and Main Loops

• Outer For Loop (Line 5): Iterates over $\left|V\right|$ nodes.
• Inner For Loop (Line 7): Iterates over the adjacent nodes of each node. In the worst case, each node has at most $\left|V\right|-1$ neighbors.

5.3.2. Edge Feasibility Check (Line 8)

Checking whether a new edge can be added is a constant-time operation $O\left(1\right)$.

Final complexity of Algorithm 3:

$$O\left(\right|V{|}^2)$$

(4)

The quadratic complexity results from the nested loops iterating over nodes and their adjacent neighbors.

5.4. Experimental Evaluation

This section presents an in-depth performance evaluation of the proposed offloaded QoS routing framework. The assessment compares the proposed method (EX) with two heuristic baselines under varying QoS constraints, network settings, and topological configurations. All the reported results are averaged over 20 randomized simulation runs on synthetic WSN topologies derived from the existing literature.

5.4.1. Experimental Setup

This subsection presents the experimental configuration used to evaluate the proposed approach. The setup includes the routing algorithms, simulation environment, and the variable parameters used across different scenarios.

Compared Methods. Three routing strategies were evaluated:

• EX: The proposed offloaded computation framework constructs QoS-compliant conflict-free DODAGs based on centralized multi-constrained path computation.
• H₁: A heuristic baseline inspired by [46], where auxiliary weights are derived and a shortest-path tree is constructed using additive metrics.
• H₂: A heuristic approach based on [17], in which each node selects its parent based on the minimum cumulative non-linear path length to the BR.

All three strategies were implemented in C++ using the LEDA graph library [63]. This ensured consistent data structures, path models, and execution environments across all the experiments for fair comparison.

Network and QoS Settings. The simulations were conducted on synthetic WSN topologies under the following assumptions:

• Node coordinates were randomly distributed within a square region.
• Communication links were created between nodes within a fixed communication range.
• Each link was assigned k uncorrelated additive QoS parameters uniformly drawn from the interval $(0.0,5.0)$.
• The number of QoS parameters k and the threshold vector $\overrightarrow{L}=(L_1,L_2)$ were varied to simulate different levels of constraint tightness and metric dimensionality.
• The number and placement of BRs were modified across experiments to explore topological effects on feasibility and coverage.
• Definition of Path Length. In this context, path length refers to the non-linear additive cost of a routing path, not the simple hop count. Specifically, this metric is computed by aggregating multiple QoS parameters (e.g., delay and ETX) in a weighted or non-linear fashion, as described in our methodology. Consequently, the resulting values may be fractional even though the underlying topology is discrete. This allows us to more accurately represent the performance of different routing strategies under multi-constrained QoS formulations.

For example, in one scenario, two additive QoS parameters ($k=2$) were used with threshold vectors such as $\overrightarrow{L}=(9.0,11.0)$ and $\overrightarrow{L}=(12.0,14.0)$, representing tight and relaxed constraint configurations, respectively.

Interpretation of Thresholds. It is important to emphasize that the values in $\overrightarrow{L}$ represent end-to-end cumulative constraints over an entire path, not per-link limits. Since link metrics are additive, as formally defined in RFC 6551 [49], the total cost of a path is the sum of its individual link values. Therefore, even though each link metric lies within $[0.0,5.0]$, a feasible path comprising 3 to 6 hops can naturally yield an aggregate QoS cost between 9 and 30. For example, a 4-hop path with an average per-link delay of 3.5 will accumulate an end-to-end delay of approximately 14. This threshold model aligns with the multi-constrained routing formulations used in the SAMCRA and TAMCRA algorithms [52], which verify path feasibility based on cumulative metric sums. Similar additive thresholding strategies are employed in recent work by Khallef et al. [17,59], where constraints represent total end-to-end limits rather than per-hop boundaries.

This setup enables a comprehensive analysis of the performance and scalability of the proposed method under diverse and realistic WSN operating conditions.

5.4.2. Impact of QoS Constraint Tightness

This subsection evaluates the impact of the end-to-end QoS constraint threshold L on routing performance. The experiments are conducted on randomly generated WSNs within a $100\times 100$ square area, with each node having a communication range of 20 m. Each network comprises 60 nodes, including a single BR located at the center. (See

Table 4. Number of nodes with feasible and unfeasible paths by varying the QoS requirement L.

L	Connected to the BR	Feasible Nodes ($\mathit{E}\mathit{X}$)	Unfeasible Nodes ($\mathit{E}\mathit{X}$)	Nodes in the First DODAG	Unfeasible Nodes Using ${\mathit{H}}_1$	Unfeasible Nodes Using ${\mathit{H}}_2$
9	55.85	41.9	13.95	35.9	17.25	15.3
10	55.85	41.85	14	37.1	16.2	14.85
11	56.1	49.1	7	40.75	10.9	8.5
12	56.7	52.65	4.05	45.45	6.1	4.9
13	55.85	50.95	4.9	43.25	6.5	5.85
14	57	53.9	3.1	44.95	3.9	3.7

).

Key Observations:

• Significant performance gain: As shown in

  Table 5. Percentage improvement in the number of QoS-satisfying nodes preserved by the proposed method (EX) over the better-performing heuristic baseline ($H_1$ or $H_2$) across varying QoS constraint thresholds.

  QoS Threshold (L)	EX	${\mathit{H}}_1$	${\mathit{H}}_2$	Baseline Max	Preservation (%)
  9	41.90	17.25	15.30	17.25	142.90
  10	41.85	16.20	14.85	16.20	158.64
  11	49.10	10.90	8.50	10.90	350.46
  12	52.65	6.10	4.90	6.10	763.11
  13	50.95	6.50	5.85	6.50	683.08
  14	53.90	3.90	3.70	3.90	1282.05

  , the proposed EX method consistently outperforms both heuristic baselines (H₁ and H₂) across all tested QoS thresholds, achieving up to 1282.05% gain in the number of feasible nodes, with an average improvement of 563.45%.
• Feasibility trend with relaxed constraints: Figure 5 confirms that the number of QoS-compliant nodes increases as the QoS bound L is relaxed, growing from approximately 42 nodes at $L=9$ to 54 nodes at $L=14$, validating the sensitivity of path feasibility to the constraint level.
• Improved path efficiency: The EX approach achieves lower average and maximum non-linear path lengths than both heuristics (

  Table 6. Average of non-linear lengths (NLs) and maximal non-linear lengths by varying the QoS requirement L.

  L	Average NL with $\mathit{E}\mathit{X}$	Average NL with ${\mathit{H}}_1$	Average of Max NL with ${\mathit{H}}_1$	Max NL with ${\mathit{H}}_1$	Average NL with ${\mathit{H}}_2$	Average of Max NL with ${\mathit{H}}_2$	Max NL with ${\mathit{H}}_2$
  9	0.86868405	0.7970677	1.7778945	2.70073	0.7702697	1.7467435	2.62914
  10	0.86217155	0.7661964	1.6855505	1.70626	0.7437832	1.600896	3.07739
  11	0.8869539	0.6627487	1.4499615	2.06338	0.6373038	1.3756695	2.01094
  12	0.8927291	0.5788719	1.28033855	2.29483	0.5586699	1.2328301	2.36877
  13	0.8978134	0.59460195	1.2450855	2.34292	0.5738024	1.21144645	2.35253
  14	0.90484325	0.52155955	1.2165917	1.81337	0.5088827	1.1766933	1.80848

  ), contributing to more reliable and uniformly distributed routing paths.
• Structural advantage with BRs: The effectiveness of multi-BR deployment is validated in Figure 8, which shows that optimal BR placement significantly boosts feasible coverage, especially under low-range settings. For example, in the 120-node case with range 12, the number of feasible nodes increased from 25 (1 BR) to over 80 (4 BRs), demonstrating the importance of both BR count and location.
• General scalability: Across varying network sizes and link constraint dimensions, the centralized offloading model maintains high feasibility, adaptability, and topological flexibility. This reinforces its suitability for real-world constraint-sensitive WSN applications.

These insights collectively validate that the centralized edge-assisted strategy yields structurally reliable and efficient routing topologies, making it a practical solution for real-world QoS-sensitive WSN deployments.

5.4.3. Impact of Number of QoS Parameters

In this experiment, we varied the number of additive link parameters, k, while maintaining the same setup as before (60 nodes within $100\times 100$ m², a communication range of 20, and a fixed $L=10$). The link parameters were assigned $2,3,4,$ or 5 uncorrelated values from the interval $(0.0,5.0)$ (as depicted in the first column of

Table 7. Number of feasible and unfeasible nodes/paths by varying the number of parameters.

Number k of Parameters	Feasible Paths	Feasible Nodes ($\mathit{E}\mathit{X}$)	Nodes in DODAG	Feasible Nodes (${\mathit{H}}_1$)	Unfeasible Nodes (${\mathit{H}}_1$)	Feasible Nodes (${\mathit{H}}_2$)	Unfeasible Nodes (${\mathit{H}}_2$)
2	2490.2	43.65	39.85	40.85	15.95	42.55	14.25
3	666.5	36.95	32.9	31.9	24.15	35.35	20.7
4	404.5	34	30.6	30.45	25.55	33.05	22.95
5	382.65	31.35	28	27.85	29.1	29.45	27.5

). The results are also averaged across 20 runs. The second column in the table indicates the average all-inclusive number of feasible paths during the computation (regardless of their use, the feasible and theoretically possible paths). This column illustrates that increasing the number of uncorrelated parameters decreases the number of feasible solutions.

The results are illustrated in Figure 6. The second part shows the performance of the three algorithms. In the observed cases, the heuristic $H_1$ based on the derived auxiliary length covers $90\%$ of the feasible nodes. For the heuristic $H_2$, this ratio is $96\%$. Following the results in Table 7, the number of uncorrelated QoS parameters influences the number of feasible solutions. Increasing this number from 2 to 5 shows that overall feasible paths decrease.

Table 8. Non-linear length (NL) depending on the number k of QoS parameters.

Number k of Parameters	Feasible Paths ($\mathit{E}\mathit{X}$)	Average NL with $\mathit{E}\mathit{X}$	Average NL with ${\mathit{H}}_1$	NL with ${\mathit{H}}_1$	Average NL with ${\mathit{H}}_2$	Max NL with ${\mathit{H}}_2$
2	43.65	0.86887645	0.76564	1.6954283	0.73822055	1.60968735
3	36.95	0.86503695	0.88879065	1.809788	0.8404888	1.737761
4	34	0.85768205	0.9211531	1.842404	0.88596795	1.727532
5	31.35	0.85400845	1.08513055	2.2432795	1.04401305	2.0862665

further demonstrates that, as the number of QoS parameters increases, the non-linear path lengths from source nodes to the BRs also increase. This indicates that fewer paths can simultaneously satisfy all QoS constraints.

Key Observations:

• Increasing the number of QoS parameters from 2 to 5 significantly reduces the number of feasible solutions (Table 7; Figure 6).
• The proposed method remains consistently superior, maintaining higher feasibility even as dimensionality increases.
• Table 8 shows that both average and maximum path lengths increase with k, indicating higher routing complexity.

5.4.4. Impact of Border Router Number and Placement

More sensors can transmit data when multiple BRs are available while satisfying QoS constraints. Optimal BR placement significantly improves coverage, resembling a special case of the area coverage problem. If the BRs are placed carefully, the number of sources covered by QoS-aware paths linked to at least one BR can be considerably increased. Careful sizing of data collection involves a thorough analysis of the network geometry (the number and placement of sensors, communication ranges, and existing links). Based on these elements and the QoS requirement, the number and position of the BRs needed can be determined. Methods such as the well-known K-means and/or the distance-based decomposition of Voronoï can be useful. Figure 7 illustrates the effect of BR placement:

• In Figure 7a, the first BR covers a limited set of sensors, and adding a second BR provides minimal improvement.
• In Figure 7b, strategically placed BRs enable better coverage, as shown by the Voronoï diagram (dotted lines).

Our simulations explored two scenarios:

1.

Sixty sensors with a communication range of 25:

• BRs were initially placed at the center, and additional BRs were equitably distributed.
• The first BR covered approximately 50 feasible nodes, while multiple BRs increased coverage to 57–59 nodes (out of 59).
• The improvement from adding more BRs was slight since the first BR already covered most feasible nodes.

2.

One-hundred-twenty sensors with a smaller communication range (12):

• Initially, only 20–25 nodes were feasible out of 120.
• Adding 2 to 4 BRs significantly increased feasible nodes and improved coverage in the first computed DODAG.

The results are visualized in Figure 8 and Figure 9.

Key Observations:

• Adding BRs increases the number of feasible nodes, especially in low-connectivity settings (e.g., 120 nodes, range = 12).
• Optimal BR placement leads to substantial coverage gains—up to 82 out of 120 nodes become feasible with four BRs.
• For denser topologies (e.g., 60 nodes, range = 25), marginal gains are observed since the first BR already covers most nodes.
• Table 9. Illustration for the effect of multiple BRs.

  	Number of BRs	Not Conn. to the First BR	Feasible with the First BR	Feasible (All BRs)	Active BRs from 4	Feasible Nodes	Nodes in DODAG
  1st case
  Nb of	1	0	57	57	1	48	40
  Nodes = 60	2	1	50	58	2	58	47
  	3	4	47	58	3	58	50
  Range = 25	4	5	48	59	4	59	54
  2nd case
  Nb of	1	48	25	25	1	22	20
  Nodes = 120	2	55	20	40	2	42	29
  	3	68	21	43	3	61	37
  Range = 12	4	57	22	82	4	82	46

  Note: All numerical values are rounded to the nearest whole number. Original values represent the mean across multiple simulation runs.

  summarizes these effects,

Interpretation of Columns. In Table 9, the column “Number of BRs” represents the total number of border routers (BRs) deployed in each scenario. In contrast, the column “Active BRs from 4” indicates how many deployed BRs were utilized to serve at least one QoS-compliant source node in the resulting DODAGs. This distinction illustrates that not all deployed BRs may be effective; depending on their location and the underlying network structure, some BRs may remain unused if no feasible routing paths exist.

5.4.5. Summary of Findings

• The proposed EX framework preserves QoS feasibility under tight constraints significantly better than heuristic approaches.
• It scales robustly with increasing QoS dimensionality and supports improved coverage through intelligent BR deployment.
• By enabling conflict-free multi-DODAG routing, EX ensures both structural resilience and better performance metrics (feasibility, delay, and path uniformity).

6. Conclusions and Perspectives

This work presents a scalable standard-compliant framework for offloaded multi-constrained QoS routing in RPL-based Wireless Sensor Networks (WSNs). By shifting the computational burden from constrained nodes to edge servers, the proposed architecture enables centralized DODAG construction while preserving RPL compatibility and minimizing protocol disruption.

The methodology comprises three key algorithms: Algorithm 1 for computing feasible non-dominated paths; Algorithm 2 for conflict-free DODAG construction; and Algorithm 3 for redundancy augmentation to support local repair. The experimental evaluation demonstrates substantial advantages over the heuristic baselines regarding QoS feasibility and routing efficiency. Specifically, it preserved between 142.90% and 1282.05% more QoS-satisfying nodes, with an average gain of 563.45%, across a wide range of constraint thresholds. This performance far exceeds the previously reported margins and affirms the approach’s scalability under real-time constraint-intensive deployments. Furthermore, the framework supports conflict-resilient DODAG construction, dynamic adaptation to multiple BRs, and a lightweight redundancy mechanism, making it robust under both static and evolving network conditions. These capabilities ensure that high-QoS coverage is maintained even as network parameters shift.

The prospective research directions include (i) integrating approximate multi-constrained routing algorithms such as TAMCRA to accelerate DODAG computation, (ii) extending the framework to hybrid fog/edge–cloud architectures, and (iii) evaluating runtime responsiveness and fault tolerance under dynamic workloads and monitoring-driven triggers. The emerging tools from graph-based learning and AI also present promising opportunities for predictive QoS-aware routing scenarios. Although $H_1$ and $H_2$ reflect common heuristics, future work will expand the comparison to include RPL-based QoS protocols such as mRPL [5] and CA-RPL [10]. These algorithms incorporate objective function tuning, composite metrics, and constraint-awareness—each offering complementary insights. Adapting and benchmarking them within our experimental framework will help to clarify the operational trade-offs between centralized and distributed decision-making under real-world conditions.

Overall, the proposed framework bridges a critical gap between theoretical multi-constrained routing models and their practical implementation in WSNs. It offers a deployable solution for QoS-sensitive industrial and smart infrastructure applications.