Context-Driven Service Deployment Using Likelihood-Based Approach for Internet of Things Scenarios

Abstract

In a context-aware Internet of Things (IoT) environment, the functional contexts of devices and users will change over time depending on their service consumption. Each iteration of an IoT middleware algorithm will also encounter changes occurring in the contexts due to the joining/leaving of new/old members; this is the inherent nature of ad hoc IoT scenarios. Individual users will have notable preferences in their service consumption patterns; by leveraging these patterns, the approach presented in this article focuses on how these changes impact performance due to functional-context switching over time. This is based on the idea that consumption patterns will exhibit certain time-variant correlations. The maximum likelihood estimation (MLE) is used in the proposed approach to capture the impact of these correlations and study them in depth. The results of this study reveal how the correlation probabilities and the system performance change over time; this also aids with the construction of the boundaries of certain time-variant correlations in users’ consumption patterns. In the proposed approach, the information gleaned from the MLE is used in arranging the service information within a distributed service registry based on users’ service usage preferences. Practical simulations were conducted over small (100 nodes), medium (1000 nodes), and relatively larger (10,000 nodes) networks. It was found that the approach described helps to reduce service discovery time and can improve the performance in service-oriented IoT scenarios.

1. Introduction

In service-oriented Internet of Things (IoT) systems, densely deployed users/devices provide and consume services spontaneously from a number of application segments. The services under a given application segment or functionally similar services can be grouped together to form clusters called functional contexts. The provider and/or consumer nodes within each functional context form a functional-context network. In an IoT infrastructure system such as that of a smart city, there can be more than one application segment, such as smart homes, smart health, smart lighting, and smart transport. Each of these application segments or functionally similar services can be referred to as a functional or logical context. The devices or users providing or consuming the services from a single functional context form an overlay of a logical network of nodes. The member nodes for that context are referred to as a functional-context network. It is also possible that a single service can be a member of more than one such functional context, and a node or device can therefore be a member of more than one functional-context network. The existing physical network can thus be viewed as an overlapping network of functional-context networks [1,2,3].

With such a dense deployment, the challenges are as follows: (a) providing services with minimum latency by meeting stringent service-response deadlines; (b) organizing necessary service information inside a distributed service registry within such a heavily dynamic infrastructure; (c) reducing the traffic concentration toward core or cloud infrastructure by serving applications from fog/edge nodes, which can save system resources for future use.

Meeting these challenges by finding better search techniques to distribute services and applications within and around the intended users may lead to more optimal solutions. A large amount of research work has been conducted in this domain. In particular, finding ways in which the required search space is reduced leads to improved performance. Some previous studies have taken into account functional contexts; specifically, in some situations, two nodes may be functionally close together but physically far apart, and this will cause higher latency in finding a service. Thus, considering the functional contexts of services in combination with the locational/physical contexts of users/devices can be used to provide a relatively smaller search space [4,5]. In the present work, we focused on such a combined context to improve performance.

Against the background of such a highly dynamic infrastructure, it is difficult to find a set of stable nodes within an IoT application segment to store necessary service information. It is clear that finding a mechanism to obtain a set of nodes that are relatively less dynamic and reducing the number of service-information entries to a limited-capacity device are the most challenging issues. After studying the service consumption histories of users/devices over a period of time, we can find that each has a specific service consumption pattern, and this is likely to remain fair and consistent [6]. As such, users/devices try to confine their activities within a small number of contexts among a larger number of available contexts; this time-based consumption connection could aid the development of an improved service registry [7]. Through considering the dynamics of the IoT network and the said consumption behavior of users/devices, a distributed service registry can be designed in such a way that it is likely that a service can be discovered within a very minimal amount of time [8]. Examining the temporal usage patterns of services by users/devices allows this distributed registry to be designed with the principle of keeping the information about frequently used services within or around the intended user(s) so that the service search time is reduced and the search performance is thus improved. In the broader context, this helps to save system-wide resources for future use, which helps to extend the life of smaller IoT devices by saving energy. To this end, in the present work, the maximum likelihood estimation (MLE) [9] is exploited to analyze the time-variant correlations within users’ service consumption patterns; the details are discussed in Section 4.

1.1. Combined Context

Services under an application segment or those having functional similarities can be grouped together to form a logical cluster, and this is referred to here as a functional context. The provider and/or consumer nodes of similar services then form a logical network referred to as a functional-context network. Subsequently, as there are a variety of application segments, there will be more than one such functional-context network. We assume that there are N nodes in the physical network and the network provides S services; each node provides a subset of services from S. Consequently, a context C may be described as a logical cluster of services with an equivalent functional structure, $C=\{s_1,s_2,\dots ,s_n\}$. Whenever $s_i\in C_j$ is true, then $s_i$ is in context $C_j$. There is no inherent restriction on a node being a member of more than one such context, depending on the service(s) it has consumed in the recent past or is currently providing. The nodes belonging to a functional context can form a functional-context network, and this is represented as $N_{C_i}$. If $n_1\in N_{C_i}$ and $n_2\in N_{C_i}$, then $n_1$ and $n_2$ are members of the same functional-context network; even though they may be physically far (several hops) apart, $n_1$ and $n_2$ are now logically connected. Hence, a node in a functional-context network has a logical neighborhood with other nodes within the same functional-context network. These nodes also have physical neighbors (for any h hops) among the existing physical nodes. The complete physical network can thus be seen as an overlapping network of such usable context networks, as illustrated in Figure 1.

Based on the above, corresponding to each individual node, we determine a physical context as well as a functional context. We can then consider combining the physical context and the functional contexts of a node to determine a more precise set of neighbors or contexts. This is referred to as a combined-context network, as discussed by Banerji and Choudhury [10]. For a particular service, the search procedure will function only within the relevant combined-context network; this reduces the universal search space into a relatively smaller region or region, which will certainly reduce the search time and, thus, the chance of service drop.

Let, $C=\{c_1,c_2,\dots ,c_{\left|c\right|}\}$ be the set of overlapping combined-context networks. If we assume that the nodes are uniformly distributed over the combined-context networks and on average a node belongs to l contexts, then the average number of nodes per combined-context network will be given by

$$|C_i|={\displaystyle \frac{\left|N\right|}{\left|C\right|}}\times l$$

(1)

1.2. Research Contributions

Through considering the existing constraints and overheads, the contributions of this work can be summarized in the following points:

• The necessary search space is reduced by leveraging the concept of combined context.
• Further, this reduction takes place due to a time-variant correlation among the previously consumed services. This reduction has a subsequent effect on minimizing the average service discovery time, service-completion time, and service-advertisement time (at the time of service registration).
• Additionally, this extends to the efficient utilization of system resources. This provides the advantage that the system will be able to serve more clients with the same resources, and this ultimately increases its overall efficiency.

1.3. Paper Structure

The remainder of this paper is structured as follows. In Section 2 and Section 3, the previous literature and the necessary background are, respectively, outlined. Section 4 presents a discussion on the proposed technique. Simulations were conducted using this technique, and their design and outcomes are detailed in Section 5. Finally, Section 6 presents the conclusions of this work.

2. Related Work

There are a number of challenges relating to existing state-of-the-art systems [11] in the smart city IoT space. In this literature survey, we first discuss works related to the association of service-oriented architecture (SOA) with the IoT [12,13]. Then, a survey is presented of state-of-the-art service discovery mechanisms relevant to peer-to-peer (P2P) systems [14], mobile ad hoc networking (MANET) [15], fog and/or cloud scenarios [16], and context-aware service discovery in IoT.

Chen et al. [17] advocated for the use of sufficient and necessary infrastructure to incorporate SOA into the IoT environment. Their aim was to analyze the SOA features and the contexts (e.g., locational, physical, personal) of the services. Zhang et al. [18] recommended that SOA be incorporated into IoT systems to improve their performance, and they outlined the challenges and opportunities of using SOA in the IoT. Zhang et al. [19] further suggested that real-world applications within the IoT should use the Simple Object Access Protocol (SOAP) for web services; additionally, they suggested that for enabling components, the representational state transfer (RESTful) API can be used to design ultra-scale, elastic IoT systems.

Due to the memory and energy-constrained devices that tend to be used in the IoT, the management of a very large registry can become difficult. Furthermore, the mobility of an IoT device in such a network becomes a big issue for achieving seamless connectivity and service availability. A distributed registry is an obvious choice to address this problem, and several attempts have been made to reduce the service discovery time as well.

Regarding the state of the art for P2P service discovery, Liu et al. [20] proposed a model of dual-layer P2P service discovery through the semantic web. This points to multiple ontologies, connects them by registers, and creates an inner layer of registers; each community has an agent to communicate with the rest of the system. The model of Jia et al. [21] is a predictive approach that uses the the “spray and wait” [22] method of P2P routing. Zhang et al. [23] proposed a self-organized P2P service discovery mechanism. The system is organized by several managers, such as the peer manager, query manager, and service manager, to make the system well behaved for collaboration in an enterprise architecture; however, this was not studied in depth for an IoT device with limited capacity as the authors intended to create a classical SOA-based integration of P2P for a manufacturing unit.

The approach of Benghida and Boufaida [24] creates clusters over the underlying physical layer of a P2P system, producing a hybrid P2P system over the top of a pure P2P structure. In this system, the cluster heads are connected to create an overlay network; however, the way in which these clusters are constructed—whether by analyzing physical or logical parameters—has not been discussed clearly [25]. For simpler and more effective service discovery, Yulin et al. [26] combined P2P and centralized Universal Description Discovery and Integration (UDDI); in contrast, the discussion of Cirani et al. [27] points to the issues of autonomous mechanisms for service discovery [28]. The authors suggested the use of an IoT gateway to connect the application level with the IoT nodes [29] using the Constrained Application Protocol (CoAP). This tries to avoid denial-of-service attacks and also collaborates with HTTP. Nonetheless, the use of a central gateway may lead to a single point of failure, and the concentration of traffic over the gateway may also lead to a degradation in performance due to higher latency in service discovery [30].

The consideration of geographical boundaries confines fundamental algorithms to local regions; however, due to mobility, the locational contexts of devices may change, and this has not yet been comprehensively considered. Guinard et al. [31] recommended combining SOA with the IoT to make the system smoother and more efficient. Ref. [32] and Singh et al. [33] pointed out the challenges of finding adequate services for solving a task using SOA [34], they also discussed a “plug-and-play” model for service registration using a new device. Different distributed hashing-based algorithms and protocols have already been proposed; the most significant of these is Chord [35] due to its simple and flexible design and high efficiency.

Some works have also been published on the use of P2P systems for service discovery. In the study of Kaffille et al. [36], the authors applied the concepts of distributed hashing for service discovery without flooding the entire network. Eventually, the reduction in the search space that results from this approach helps to find services more quickly; hence, it improves the overall performance of the system by reducing message passing and saving system resources such as bandwidth and energy [37]. Distributed machine learning (ML)-based solutions [38] are being proposed on an ongoing basis with the advent of TinyML approaches [39] by considering the recent consumption behavior of users. Nonetheless, the solutions proposed so far do not have enough depth due to the low availability of consumption-history data, as most of the available data are from heterogeneous sources with diverse correlations.

3. Background

This section covers some important and necessary concepts that are likely to help readers more easily connect with the proposed approach.

3.1. Least Recently Used

The least recently used (LRU) page-replacement strategy is a good approximation to an optimal algorithm; this is based on the observation that pages that have been heavily used in the recent past will probably be heavily used again in the near future. In our design approach, the concept of LRU replacement is used to replace the contexts of temporal service consumption information to/from the context cache of the users/devices.

3.2. Maximum Likelihood Estimation

Maximum likelihood estimation (MLE) is a method for estimating parameters in a probability space from a data sample. In this method, the parameters are obtained and estimated by finding parameter values that the likelihood function will maximize. We define the sample set $X=\{x_1,x_2,\dots ,x_n\}$ obtained from a probability model with a standard probability density function (PDF) $f_x(x;\lambda )$, which depends on the parameter $\lambda$ in the parameter space $P_s$. The MLE is obtained according to the following procedure:

• The likelihood function $L\left(\lambda \right)$ is defined as

  $$L\left(\lambda \right)=\prod _{i=0}^n{f}_x(x_i;\lambda )$$

  (2)

  that is, it is the product of the n density function terms (where the ith term is the density function evaluated at $x_i$) viewed as a function of $\lambda$.
• Take the natural logarithm of the likelihood and collect terms involving $\lambda$.
• Find the value of $\lambda \in P_s$, $\widehat{\lambda }$, for which $logL\left(\lambda \right)$ is maximized, for example by differentiation. If $\lambda$ is a single parameter, find $\widehat{\lambda }$ by solving

  $${\displaystyle \frac{d}{d\lambda }}\{logL\left(\lambda \right)\}=0$$

  (3)

  in the parameter space $P_s$. If $\lambda$ is vector-valued, say $\lambda =({\lambda }_1,{\lambda }_2,\dots {\lambda }_k)$, then find $\widehat{\lambda }=(\widehat{{\lambda }_1},\widehat{{\lambda }_2},\dots ,\widehat{{\lambda }_k})$ by simultaneously solving the k equations given by

  $${\displaystyle \frac{\partial }{\partial {\lambda }_j}}\{logL\left(\lambda \right)\}=0,j=1,2,\dots ,k$$

  (4)

  in parameter space $P_s$. If $P_s$ is a bounded interval, then the MLE may lie on the boundary of $P_s$.
• We then have to check that the estimate $\widehat{\lambda }$ obtained from Equation (4) truly corresponds to a maximum in the (log) likelihood function by inspecting the second-order derivative of $logL\left(\lambda \right)$ with respect to $\lambda$.

In the proposed model, we use MLE to select the set of most-liked (most frequently availed) contexts of a node. This determines the set of contexts in which the node has a higher chance of being used in the near future. This, in combination with the concept of combined context, leads to a set of stable nodes to which we can distribute the registry shares if the nodes have enough residual memory.

4. Proposed Technique

A user’s context will change with time in line with the instantaneous demands for services; however, these changes will usually be confined to a limited number of contexts and will be repeated many times. The probability of a change to a previously known/visited context will be higher than the probability of a change to an unknown or new context. This probability is obtained from long-term observation of the service consumption patterns of users/devices. It would be better if all the services were available within an IoT device itself; however, this is not possible due to the limited capacity of devices. It would thus be more useful to organize a distributed service registry if the required services are available around an IoT device, as this can reduce the necessary search time for a service.

The present work considers the reduction in the search space by exploiting the temporal service usage patterns of users/devices blended with the combined context, and this leads to better organization of the distributed service registry to improve the average discovery time for a service. Hence, the overall performance of the system is also likely to improve. The design approach seeks to obtain the required services available around an IoT device in an optimized way to maximize social welfare [37,40]. Initially, we explore the formation of combined contexts by considering the functional contexts of services in combination with the physical/locational contexts of users/devices, taking into account the dynamics of the service consumption pattern. This also addresses the reduction in the service search space, through which the service search time is likely to be minimized.

Subsequently, we analyze the formation of a distributed service registry by considering the temporal service consumption patterns of users/devices in such a way that the services are available around an IoT device in an optimized arrangement to maximize social welfare. Figure 2 illustrates the workflow of the proposed approach at a glance. In addition, for ease of understanding, the detailed steps of the entire procedure are elaborated as follows:

• Nodes or devices gather the initial configuration by exchanging their functional-context information and physical neighborhood via message passing. Each node gathers its functional-context information from its service consumption in the recent past and its physical neighborhood by a standard neighbor-discovery protocol. In Figure 2, this combined context neighborhood information is referred to as CN.
• Through exchanging the combined information about the functional context and physical neighborhood, the context networks are formed. Subsequently, the distributed service registry (DR in Figure 2) is configured for each context network.
• The system starts attending to the service consumption requests from users. The DR has the information related to each service. The search procedure starts by searching the URL of the service provider for the requested service inside the DR. As the DR is constructed by considering the concept of combined-context awareness, the number of nodes inside a particular context network is relatively small compared to those in the entire network. This is the benefit that the system is likely to obtain by leveraging context awareness through the service consumption patterns of nodes.
• MLE plays a crucial role here by finding the services that have a high probability of being used according to the consumption history of the recent past. This likelihood is obtained by configuring the CN with those nodes that have similar service consumption patterns. This enhances the chance that a node will be stably inside a particular context network and thus participate in holding the distributed registry shares.
• The memberships of nodes in certain functional contexts and the context networks themselves will subsequently change over time. If the consumption of a node’s service(s) has a higher likelihood score, that node will be more stable inside a particular context network; this is beneficial for the construction of a stable service registry, which is desirable in IoT scenarios.
• The entire process is executed in a finite-time window-based approach. The execution is carried out rigorously with finite intervals to capture the dynamics of the IoT system, including topological vulnerabilities and node failures.

Figure 2. System flow diagram.

Figure 2. System flow diagram.

4.1. System Model

Each node in the network has a finite cache to store its recent service consumption history. In Figure 3, there are six nodes ($N_1$ to $N_6$), and each is associated with a finite cache (sketched as rectangular boxes with nodes).

As the services are used, nodes gather temporal service consumption information, and this is used to guide the proposed model in predicting the future contexts of nodes. The cache is updated using the LRU method, and the gathered temporal information is analyzed with the MLE technique to obtain a preferred set of services (and contexts) for which an IoT device has a higher preference. From a context network point of view, an IoT device will be confined within the (set of) context(s) in the near future or become a member of a new context if an IoT device is currently not a member of that context.

Gathered service consumption information is passed through the MLE algorithm to find the set of services preferred by an IoT device. For ease of analysis, the continuous domain is divided into a set of regular intervals of T time units starting from $t_0$ (where $T>0$), as shown in Figure 4. Then, the temporal service consumption information samples are supplied as an input into the MLE algorithm that, by finding the probabilities of frequently used services, gives some preferred set of services to be used by an IoT device in the near future. For this, the MLE algorithm takes each temporal sample with some probability to obtain $\widehat{\lambda }$. After obtaining $\widehat{\lambda }$, the MLE algorithm selects the preferred set of services whose probabilities are higher than or equal to the probability obtained with $\widehat{\lambda }$.

The service consumption traffic within the network follows a probabilistic distribution, which can be of any type. In an ad hoc scenario, the traffic maintains a standard average over a certain finite interval; hence, Poisson’s distribution is more likely to be fitted in the considered smart city IoT scenario. The details of the MLE analysis were presented earlier. The variables $X_i$ and $\theta$ are the parameters that illustrate the combined-context network and the consumed services, respectively.

The goal of this approach is to find out whether an IoT device will remain in its current context membership or change its context membership frequently; the MLE algorithm acts as a decision engine for this purpose. After finding the estimation for a combined-context network, it becomes easier to locate the registry shares among the nodes that encounter the maximum likelihood. The greater the likelihood values, the more stable the combined-context network; however, this kind of stability depends on numerous external parameters, such as mobility, context cache size, residual memory, and remaining energy. The proposed approach explores the likelihood-based arrangement of registry shares in a context-aware smart city IoT scenario. The next subsection elaborates on the details of the associated granular/atomic events associated with the distributed service registry.

4.2. Estimation Based on Consumption Frequency

Suppose there are n distributed nodes/IoT devices at a certain point in time T. Each of these takes a measurement of its context-membership information with parameter $\theta \in {\mathbb{R}}^m$ according to the following linear equation:

$$y_i\left(T\right)=A_i\left(T\right)\theta +v_i\left(T\right),i=1,\dots ,n;T\ge 0$$

(5)

where $y_i\left(T\right)\in {\mathbb{R}}^{m_i}$ is the evolved context information from the ith node at time T, $v_i\left(T\right)\in {\mathbb{R}}^{m_i}$ is the recent context information, and $A_i\left(T\right)\in {\mathbb{R}}^{m_i,m}$ is the time-varying information of its context represented as a regression matrix.

It is noticeable that if the service registry was fully centralized, then it would be quite easy to estimate and design the additional necessary changes within it; however, the scenario considered here is purely distributed in nature, and the estimation scenario and derivation formula change accordingly. Although this can be proved in theory, in practice, the scenario differs slightly due to shortfalls in communication constraints; in general, a pure distributed system will suffer from massive message passing among peers. This compromise is acceptable for the sake of a uniform (sometimes nearly and favorably uniform) distribution of services, yielding better reachability and service provisioning. The details of the distributed estimation scheme are discussed in the next section.

Distributed Estimation Scheme

It is assumed that each node is caching its own context information at each decision epoch (a finite time interval); it is also assumed that this is achieved by a lossless information-gathering scheme. A node $n_i$ can assume that ${\sum }_i^{-1}\left(T\right)=0$ if it has no update for that considered interval T, where $-1$ in the upper limit signifies the update from the recent past (previous time interval). The scheme has two stages of estimation, as discussed by Stigler [9]. In connection with this, each node keeps its local cache of context information and composite stage information—represented as $p_i\left(T\right)$ and $q_i\left(T\right)$, respectively—and updates at certain regular intervals (or decision epochs). The equations are as follows:

$$p_i\left(T_{+}\right)={\displaystyle \frac{T}{T+1}}{p}_i\left(T\right)+{\displaystyle \frac{1}{T+1}}{A}_i^T\left(T\right)\sum _i^{-1}\left(T\right)A_i\left(T\right)$$

(6)

$$q_i\left(T_{+}\right)={\displaystyle \frac{T}{T+1}}{q}_i\left(T\right)+{\displaystyle \frac{1}{T+1}}{A}_i^T\left(T\right)\sum _i^{-1}\left(T\right)y_i\left(T\right)$$

(7)

The current time T, which is actually a finite but small interval, is eventually sufficient for executing and updating the necessary context information on the concerned nodes. The interval T is a scalable parameter that can be tuned depending on the network density and other physical parameters of the scenario under consideration. After gathering the recent context information, each node needs to share its updates with the immediate neighbors within its combined-context networks. This is actually a spatial update to be encountered and performed, and it influences the corresponding changes in context-network configurations. These changes can be expressed as follows:

$$W_{ij}\left(T\right)=\left\{\begin{array}{cc}(T+1){\tilde{W}}_{ij}\left(T\right)\hfill & \mathrm{if}(i,j)\in \epsilon \left(T\right),\hfill \\ \\ 1-{\sum }_{j\in {\mathbb{N}}_i\left(T\right)}{W}_{ij}\left(T\right)\hfill & \mathrm{if}i=j,\hfill \\ \\ 0\hfill & \mathrm{otherwise}.\hfill \end{array}\right.$$

(8)

If necessary, the system then updates the service registry by merging the temporal and related spatial changes in the respective context networks.

4.3. Changes in IoT Device Contexts

Initially, the contexts of users/devices depend on the services they are providing. As the service consumption starts, the contexts of users/devices change depending on the service(s) they are consuming. The service caches of the users/devices are limited, so they update with instantaneous service consumption. As the caches update, each node’s context membership changes over time. As the users show some preferences in their service consumption patterns, a set of services will be repeatedly consumed by an IoT device. During the initial stage of consumption, the changes in context will be frequent; however, as time goes on, there will be fewer changes, and after a certain interval, the changes in the users’ contexts will become stable.

4.4. Changes in Distributed Service Registry

Due to a change in service consumption, a node $N_i$ may withdraw its membership from some contexts and eventually add some new contexts; hence, the contexts of the nodes/users can change often, as shown in Figure 5. In these cases, the respective context networks undergo some changes in configuration, and if needed, changes must also be applied to holders of the distributed registry (DR). Initially, in our design, not every change in a context network requires a change in the DR; a change occurs only if a holder of a share the registry is ready to withdraw its membership from the context network or if an already participating node has an exhausted or full cache. The DR has the functionalities of the registration of services, inclusion of new nodes, and exclusion of existing nodes. In all cases, the dynamics of a system with a temporally varying service usage pattern will guide the rearrangement of the DR as and when necessary.

4.4.1. Service Registration

Providers will advertise new services to the DR for registration. The relevant service information (e.g., service ID and provider ID) is mapped to a DR shareholder node with a hashing technique. The distribution of services takes place in our design specification according to the method described by Stoica et al. [35]. For each context, there is a smaller sub-registry to keep the service information of those services that belong to that specific context. Each sub-registry is illustrated by a logical ring, and all such rings are connected by an inner ring called the core. The core ring helps with the switching between two context sub-registries.

4.4.2. Joining of a New Node

A node (IoT device) can become a member of a context network at any time, depending on its service usage pattern. The inclusion of a node in a context network does not automatically mean that that node will becomes a participant among the shareholders of the distributed registry; participation depends on the necessity of the inclusion of the concerned node. If an existing shareholder has an exhausted/full cache or if an existing participator node is leaving the context network, the newly joined node may participate as a registry shareholder. The participation of a node as a shareholder in the distributed registry is therefore situation-aware:

• Situation-I: if the cache of an existing shareholder is already full, a newly joined node can take some shares from it, preventing the necessary service information from being lost.
• Situation-II: if an existing node is leaving the system, the shares held by that leaving node can be transferred to the newly joined node.

In both the above situations, middleware is used to execute the necessary modules.

4.4.3. Removal of an Existing Node

At any time, an existing node can leave existing context network(s). At such a point in time, we may lose required information; if this information is handed over to any of its candidate neighbors before leaving, this loss can be prevented. In a reactive approach, the search for a candidate node will be triggered after the system has already incurred some loss. During that period, services may not be available due to the unavailability of necessary service information. In our proposed model, the system proactively prepares to find candidate nodes among the neighbors of a departing node before incurring losses. The probabilistic approach to finding the upcoming contexts of nodes makes it easier to find candidate neighbor nodes for holding registry shares.

4.5. Improvement in Service Discovery/Search Time

Service search time depends on the size of the search space. In our approach, the use of combined contexts reduces the necessary search space, as discussed earlier. Furthermore, the inclusion of the temporal service consumption patterns of users/devices reduces the search choices; the options for searching for a service are therefore reduced. This helps to improve the service discovery time.

5. Results and Discussion

The system conducts its analysis by means of the MLE framework, which is generally used for density estimation with a supervised learning model. This provides the basis for the foundation of linear modeling techniques, such as linear regression for predicting numerical values and logistic regression for binary classification. In the case of linear regression, the model is constrained to a line, and this involves finding a set of coefficients for that line that best fit the observed data; hence, the problem can be solved analytically using linear algebra.

Let us take a simple example as a test case for a toy simulation application at our lab. In this scenario, the users/nodes consume services infinitely often. The MLE helps to find the predicted probability of each service being used, and based on this, we designed the DR arrangements for the most likely/most frequently used services. For simplicity of discussion, we assume 02 atomic services ($s_1$ and $s_2$). We also assume that in the service bucket(s) of the server(s), both services have an equal number of ready instances that can be served to a user/users on demand. The services can be consumed in any possible combination. As an instance, we assume $s_1$ with 09 instances and $s_2$ with 01 instances to be served for consumption. There are thus 10 possible consumption variations, as shown in Figure 6.

Each of these 10 possible combinations has the probability $0.5^{10}=0.0977\%$. Since there are 10 such possibilities, we can multiply this by 10 and obtain the probability as $0.977\%$. The same process was conducted by simulation, and we obtained a probability of $0.972\%$. We can conclude that the simulated result is close to the calculated probability, although it differs slightly because of the variance in the simulation framework due to the use of randomized functions guided by seed values. Each time a seed value changes, the randomization algorithm produces different outcomes; this is actually a demonstration of the beauty of randomness in mathematics.

Graphs showing the likelihood of the consumption of services with different probabilities are shown in Figure 7, Figure 8 and Figure 9 for 100, 1000, and 10,000 incoming service requests, respectively. These graphs show a clear picture of the evolution of the likelihood of the consumption of each service over time.

We chose service-search latency as a metric to illustrate the performance gain achieved by implementing the proposed method. In this analysis, the load of the system was calculated by obtaining the amount of service consumption requested during a decision epoch (a small finite interval). As illustrated by the comparison graph in Figure 10, this metric was tested with three scenarios: scenario I, in which no context awareness or MLE is applied and implemented (NCA_Non _LH system); scenario II implemented with context awareness but without the concept of MLE (CA _Non _LH system); and finally, scenario III implemented with both context awareness and the MLE (CA _LH system). As described, the design of this system leverages the advantages of spatio-temporal correlations within service consumption patterns. The results show that the proposed method performs better than the existing non-MLE-estimator-based approach as well as the context-aware approach.

5.1. Challenges Addressed

The following challenges have been addressed by this work:

• Dynamic Contextual Changes. Contextual elements in IoT contexts—such as device locations, user activity, and network circumstances—can undergo rapid changes. If these modifications are not appropriately handled, they can potentially create security risks. The approach proposed herein is a likelihood-based method that adjusts service deployment tactics in response to dynamic contextual changes. This approach helps to reduce security risks that arise from using obsolete or wrong contextual information.
• Time-Variant Consumption Patterns. This paper focuses on the issue of time-varying consumption patterns, in which the preferences of users for service consumption may change over time. These modifications can have an effect on both the efficiency of the system and its level of protection against potential threats. The system uses MLE to measure the effect of altering consumption patterns on system performance, aiding in the identification of potential security vulnerabilities linked to variations in user behavior.

5.2. Scope for Future Research

This section notes some of the challenges that need to be addressed to enhance the existing systems. The likelihood-based strategy can improve the security and privacy of context-driven service deployment in IoT environments by actively addressing the following problems:

• User Consent and Control. Users should have authority over the gathering and use of their contextual data during the process of deploying context-driven services. Ensuring user privacy and trust requires transparency in data collection processes, explicit permission mechanisms, and the provision of opportunities for users to opt out or modify their data preferences. The insufficient provision of user consent and control methods may result in privacy breaches and erode user trust in the system.
• Data Privacy. The deployment of services driven by context relies primarily on the collection and analysis of contextual data from an IoT device and their users. This often contains sensitive information such as location data, behavioral patterns, and user preferences. The acquisition and manipulation of such data give rise to issues relating to the violation of privacy. Any unauthorized attempt to access this data—whether by individuals with malevolent intent or to exploit weaknesses in the system—has the potential to result in privacy breaches and undermine the confidentiality of users.
• System Vulnerabilities. Similar to other software systems, the likelihood-based approach may have weaknesses that can be exploited by attackers to compromise the system’s security. If vulnerabilities such as buffer overflows, injection attacks, or insecure authentication techniques are not swiftly recognized and corrected, they could provide substantial hazards. Performing regular security assessments, code reviews, and vulnerability scans is crucial to detecting and addressing any potential vulnerabilities in the system.

6. Conclusions and Future Work

The initial configuration of a distributed service registry for a service-oriented IoT platform is static in nature; however, the consumption of services is random, and users often consume certain services more frequently. If the search latency were the same or similar for all consumed services regardless of their level of use, then this is not an ideal design. Therefore, by considering the most frequently used services, the service-registry design presented herein has been constructed in such a way that the search latency for frequently used services can be minimized in comparison to the general case.

In our proposed model, the necessary search space is reduced by exploiting the concept of combined context. Further, a reduction takes place due to temporal correlations found among the previously consumed services. This reduction has an effect on minimizing the average service discovery time, service completion time, and service advertisement time (at the time of service registration); it further helps in the efficient utilization of system resources. This shows that the system will become able to serve more clients with the same level of resources, ultimately increasing its overall efficiency. Here, MLE helps to establish the probabilities of repetitively consumed services, and the service registry is constructed using these probabilities. The proposed technique results in a difference in service search and service discovery times by exploiting the MLE algorithm with the pool of service consumption history. Hence, the service registry becomes dynamic, situation-aware, and applicable to context-aware IoT scenarios.