An Efficient Applications Cloud Interoperability Framework Using I-Anfis

Abstract

Cloud interoperability provides cloud services such as Software as a Service (SaaS) or customer system to communicate between the cloud providers. However, one of the most important barriers for existing researches was to adopt the application’s or data’s in cloud computing environments so as to obtain efficient cloud interoperability. This paper focuses on reliable cloud interoperability with a heterogeneous cloud computing resource environment with the objective of providing unilateral provision computing capabilities of a cloud server without the help of human interaction and allowing proper utilization of applications and services across various domains by using an effective cloud environment available at runtime. Moreover, the framework uses hybrid squirrel search genetic algorithm (HSSGA) to select the relevant features from a set of extracted features in order to eliminate irrelevant data which provides advantages of low computational time and less memory usage. Thereafter, for a proper selection of cloud server with respect to the selected features, the system has developed the improved adaptive neuro-fuzzy inference system (I-ANFIS) which provides accurate server selection and helps against uncertainties caused by servers or applications. Hence, the experimental result of the proposed framework gives an accuracy of 94.24% and remains more efficient compared to existing frameworks.

1. Introduction

With the increasing need of computing resources such as server, storage, CPU, application, database and network, which enables a new computing paradigm named cloud computing. Cloud infrastructure which are available in a data centers have to be shared among organizations through pay as you go models use service anytime anywhere [1]. Cloud service can be provisioned rapidly and released with minimum human intervention in a cost effective manner. Cloud service can be scaled based on user needs [2]. Intensive need of cloud computing services such as network-demanded web application, computation resource intensive application [3] and storage dependent application [4] are drivers of this technology.

Vendors such as Amazon [5,6], IBM Cloud, Openstack, Google [7], Pivotal Web, Microsoft Azure [8] and Salesforce [9] have seen rapid growth in their cloud business for the past 10 years. Each of the cloud providers have their own format to access the cloud, which results in the consumer opting for one cloud provider. There are no widely accepted standards for accessing and deploying cloud services for cloud consumers. Multi-clouds need to work seamlessly with other cloud services in an interoperable manner [10]. Using the Service Level Agreement (SLA) format, authorization and authentication token [11], it is possible for the data and workload available in a public or private cloud to move between one cloud provider to another cloud provider which enable interoperability between clouds. Interoperability in cloud computing will have three kind of interoperable cloud services such as platform, application and management interoperability with response to management, application and platform components [12].

In recent years, industry and academia have highlighted the need for cloud interoperable services. Many cloud standards address interoperability due to increasing demand. Cloud standards address the issue of interoperability when there is an exchange of data, applications and Virtual Machine (VMs) between different cloud providers [13]. These inconsistencies can be either specialized, for example incongruent virtualization executions (VMware, Xen and KVM), or contrary programming code (Java-based, PHP-based) or semantic. Notwithstanding that, data synchronization is a specific issue when resource components in various clouds interact, regardless of whether they are indistinguishable [14]. Such resource components regularly keep duplicates of similar information, and these duplicates should be maintained in a steady state. Interaction between clouds ordinarily have high latency, which makes synchronization troublesome [15].

Many cloud interoperability standards have been proposed based on state-of-the-art efforts, such as Distributed Management Task Force (DMTF) [16], Storage Networking Industry Association (SNIA) [17], Open Virtual Machine Format (OVF) standards [18], NIST Cloud Computing related standards [19], et cetera, to enable cloud interoperability and to be implemented soon. However, a technological challenge still remains in terms of different hypervisors for virtualization in cloud environments and platforms for developing applications and non-technological challenges in terms of the policy as well as management in cloud interoperability [20]. In order to overcome the challenges faced by existing research, this work has developed an efficient applications interoperability framework using the I-ANFIS algorithm.

Therefore, the rest of the paper is organized as follows: Section 2 reviews various frameworks developed for cloud interoperability; Section 3 briefly explains the proposed methodology for cloud interoperability; Section 4 discusses the results achieved by the proposed work based on various performance metrics, and finally; Section 5 concludes the work with future scope.

2. Literature Review

This section illustrates the various existing works or frameworks carried out for cloud interoperability and the corresponding challenges faced by the framework.

Huedo et al. [21] developed a BEACON framework which allows cloud applications and services to be deployed automatically across different data centers and different clouds with emphasis on intercloud networking and security issues and enables the provision of federated cloud infrastructures. BEACON has contributed to the OpenNebula and OpenStack cloud management platforms so as to manage the data interoperability and it is a open-source software. The management of data interoperability was modeled well. However, they had repeated data or imbalanced distribution of data, which were the big challenges in the framework.

Castane et al. [22] illustrated mOSAIC ontology for inter-cloud interoperability which was extended to create the cloud lightning ontology (CL-ontology). CL-ontology was the incorporation of heterogeneous resources and high performance computing (HPC) environments in the cloud. To help the CL-ontology, a conventional architecture was introduced as a driver to address heterogeneity in the cloud, and as a utilization case illustration of the architecture, the internal processes of the cloud lightning framework were updated and introduced to show the plausibility of joining a semantic engine to reduce interoperability issues to encourage the consolidation of HPC in the cloud. Based on the inter-cloud interoperability, the approach was developed. However, when it considered various platforms, the respective execution of an application did not match with the corresponding server environment.

Nodehi et al. [23] discussed a framework that supports interaction between different cloud resources to support inter cloud interoperability with the objective of dispatching the remaining workloads to the best cloud service accessible at runtime. Additionally, a genetic algorithm (GA)–based employment scheduler was created as a part of the interoperability system that offered remaining job movement with the best execution at any event cost. The cloud resource selection model [24] was evaluated with an agent-based simulation. The approach used features selection techniques to provide accurate placement of the data or applications with the respective cloud server environment; but the selection of features remained more complex and time-consuming.

K. Chandrasekaran et al. [25] used service level agreement to implement interoperable cloud services. To provide sufficient cloud resources during the deficiency of resources of one cloud, it encouraged concurred administrations by the client. Adaptable resource management methodology was created for interoperability-based cloud services. At first, the service level agreement (SLA) layouts of private and public clouds were mapped with the soft term frequency inverse document frequency (TF-IDF) metric with case-based reasoning (CBR) approach. At that point, in light of the mapped SLA, various groups of cloud suppliers were framed with the assistance of the K-means clustering technique. Lastly, when one of the clouds in a cluster confronted the issue of resource deficiency, adaptable cloud resource assignment was given through the adaptive dimensional search algorithm. The developed interoperable cloud computing with SLA remains to provide unwanted resources needed for an application to get executed.

Huedo et al. [26] used an SLA-based service virtualization which a self-manageable architecture gives an approach for easing interoperable service executions in an assorted, heterogeneous, distributed and virtualized universe of cloud services. In a distributed environment, to achieve reliable and efficient service operation, a model with the combination of negotiation, brokering and deployment with SLA-aware extensions and autonomic computing principles was used. The method remained more challenging at the time of big file size or application which required installation of wide setup files.

Loulloudes et al. [27] used a utility-based approach for provisioning on demand cloud computing resource to IT solutions. Currently, cloud computing consumers, who are willing to deploy cloud applications across different cloud resource providers do not have any automated user application programming interface (API) nor support tools. The approach presented current efforts to develop an open-source cloud application management framework (CAMF) based on the Eclipse Rich Client Platform. The framework facilitated cloud application lifecycle management in a vendor-neutral way to avoid interoperability issues. The framework conflicted with a vendor in a neutral way to avoid interoperability but the technological issues reduced its efficiency.

Sehgal et al. [28] has addressed interoperability at application-level which paves the path to understanding allocation of cloud resources at distributed infrastructure level. The approach was widely used, and it had the ability to capture the primary challenges in developing distributed applications. It used MapReduce as the fundamental exemplar and it developed an interoperable implementation of MapReduce with an application programming interface (API) called Simple API for Grid Applications (SAGA) to support distributed programming. Thereafter, the work provided a canonical word count application that used SAGA-based MapReduce. At last, the performance measures were provided and analyses of the SAGA-map were done based on multiple, different, heterogeneous infrastructures concurrently for the same problem instance. As for the same problem instance, the framework was analyzed and stated to be efficient for mapping the application according to the respective servers but non-technological issues caused an obstacle in terms of providing efficient interoperability.

Thus, the above investigation illustrates various existing works to conquer cloud interoperability and to provide smooth application-based computing. However, technological challenges as well as non-technological challenges remain that cause inefficient data or application interoperability in the cloud. In order to overcome the challenge, the work has initiated efficient application interoperability in cloud computing, which meets the current trend requirements and scope towards future needs.

3. Proposed System

For the various platforms on the source and objective clouds, a separate transfer procedure has to be started to pack, copy, download, install, deploy and configure in order to allow interoperability. Nevertheless, there are open problems with how systems communicate with others when the originating cloud does not accept additional cloud services or when a specific system in the original cloud does not support the particular cloud operating system. This type of issue may create unwanted congestion of the data or applications and may affect the whole process of interaction with the cloud. In order to conquer these types of challenges, the work has proposed an efficient application or data interoperability framework containing the following phases: feature extraction, feature selection, cloud server arrangement and cloud server selection.

The proposed framework illustrated in Figure 1 provides a simple exchange of data and services among different applications hosted on different platforms and infrastructures on the cloud, and allows utilization of applications and services across various domains. Therefore, detailed discussion of each phase is done in later sections.

3.1. Feature Extraction

This is the initial stage of the proposed framework. The initialization of the proposed framework with feature extraction provides various features extracted from the application or data and cloud server. Features extraction helps the work to know the important relationships among the data without losing any relevant information and also provides for identifying the redundant features so as to reduce the computational time. Some of the extracted features based on the task manager and cloud server that have been extracted are stated below:

Task Manager

The task manager helps us to know about the currently running applications on a system. The seasonal requests of multiple users are divided into a series of tasks, and these tasks are managed by a task manager. The task manager (T_m) contains several features, such as task speed (I₁), task cost (I₂), task weight (I₃), and size of the data (I₄). These features are extracted for the process of resource allocation. The explanation for some of the features is given below:

(a) Task speed: It can be calculated by taking the ratio of the turnaround time for allocating cloud resources to the amount time taken to respond to the cloud consumer from the time of the request, which can be expressed as

$${\mathrm{I}}_1=\frac{{\mathsf{\Gamma }}_a}{\omega }$$

(1)

where, I₁ is the task speed, ${\mathsf{\Gamma }}_a$ is the turnaround time for allocating cloud resources and $\omega$ is the amount of time taken to respond to the cloud consumer from the time of the request.

(b) Task cost: The cost of the task is defined as the amount required to be paid before the request can be attained. The demand cost is determined using the equation:

$${\mathrm{I}}_2=\tau \times {\mathsf{\Gamma }}_d$$

(2)

where, I₂ is the task cost, $\tau$ is the rate at with cloud resource are allocated to the cloud consumer and ${\mathsf{\Gamma }}_d$ is the amount time taken to respond to the cloud consumer from the time of the request.

(c) Task weight: The amount of weight depends on the speed and cost of the demands, which is expressed as

$${\mathrm{I}}_3=x \times \left({\mathrm{I}}_1\times {\mathrm{I}}_2\right)$$

(3)

where, $x$ denotes a constant value and $x\in \left(0,1\right)$.

(d) Data size: Data size of a request can be estimated from the following expression,

$${\mathrm{I}}_4=\frac{{\mathrm{T}}_s}{1+{\mathrm{T}}_s{e}^2}$$

(4)

where, I₄ denotes the user’s data size, T_s represents the total size of the user’s request and $e$ denotes the allowed probability of committing an error in selecting a small representative of the user’s request.

3.2. Cloud Server Features

The features of cloud servers, such as memory resources (I₅), bandwidths (I₆), disk space (I₇) and number of requests (I₈) are extracted [29]. The explanations of some of the cloud server features are given below:

3.2.1. Memory

The cloud memory in a server is used to store, retain and retrieve information by the user and it is calculated as follows,

$${\mathrm{I}}_5=\left({\mathrm{S}}_L\times {\mathrm{S}}_S\right)$$

(5)

where, I₅ denotes the memory of the cloud server, S_L represents the number of storage locations, and S_s denotes the size of each storage location.

3.2.2. Bandwidth

The transferring rate of data is known as bandwidth. It is calculated by taking the product of several tasks and weight of the applications.

$${\mathrm{I}}_6=\left({\mathrm{N}}_t\times u_w\right)$$

(6)

where, I₆ denotes the bandwidth of the cloud server and N_t represents a number of tasks, u_w denotes the usage weight.

3.2.3. Disk Space

Disk space of the cloud server is the total used space and the amount of free space available, which is expressed as,

$${\mathrm{I}}_7=f_s+u_s$$

(7)

where, I₇ denotes the disk space of the cloud server, f_s and u_s represents the free space and the used space of the cloud server.

3.2.4. Number of Requests

The total number of requests to the cloud server is denoted as,

$${\mathrm{I}}_8=R_1+R_2,\dots R_n$$

(8)

where, I₈ denotes the number of requests sent, and R₁ + R₂, …, R_n denotes the requests from the user.

The extracted features are expressed in the form of an equation as stated below:

$${\mathrm{I}}_{(A,C)}=\left\{{\mathrm{I}}_1,{\mathrm{I}}_2,{\mathrm{I}}_3,{\mathrm{I}}_4,{\mathrm{I}}_5,{\mathrm{I}}_6\dots \dots {\mathrm{I}}_n\right\}$$

(9)

where, I_(A,C) denotes the extraction of the features from “1” to n-th values of the application and cloud servers.

4. Proposed Algorithm

The feature selection process contributes to the proposed work by selecting most of the important features from the extracted features to select the cloud server in order to eliminate the irrelevant features that might reduce model accuracy and also may lead to more computational time. In order to optimize the extracted feature, the work developed a Hybrid Squirrel Search Genetic (HSSG) algorithm.

4.1. HSSG Algorithm

The HSSG algorithm [30] provides a complete summary of all the features and the important features required to suit the cloud server for meeting all the application needs. This reduces the error rate and tends to achieve a good accuracy rate. The HSSG algorithm follows the convergence theorem that is the time taken so as to achieve an optimal solution or best solution. The HSSG algorithm takes the extracted features as input and finds the best fitness value between the corresponding squirrel (features) and the server (food). Finally, the minimum value is chosen to be the best fitness value, which is an important feature to map the cloud server. The convergence time of the HSSG algorithm is faster and obtains relevant features so as to provide good accuracy rate. The HSSG algorithm follows certain steps which have been discussed in depth below.

Step 1:

Random Initialization

There are n number of flying squirrels (extracted features) in a forest (working space) and the location of i-th flying squirrel can be specified by a vector [30]. The location of all the flying squirrels can be represented by the following matrix:

$${\mathrm{Y}}_{FS}=\left[\begin{array}{ccccc}{\mathrm{I}}_{1,1}& {\mathrm{I}}_{1,2}& \cdots & \cdots & {\mathrm{I}}_{1,d}\\ {\mathrm{I}}_{2,1}& {\mathrm{I}}_{2,2}& \cdots & \cdots & {\mathrm{I}}_{2,d}\\ ⋮& ⋮& ⋮& \hfill ⋮& ⋮\\ {\mathrm{I}}_{n,1}& {\mathrm{I}}_{n,2}& \cdots & \cdots & {\mathrm{I}}_{n,d}\end{array}\right]$$

(10)

where, I_i,j represents the j-th dimension of i-th flying squirrel. A uniform distribution (Equation (2)) is used to allocate the initial location of each flying squirrel in the forest.

$${\mathrm{Y}}_{FS(i)}={\mathrm{I}}_L+U(0,1)\times ({\mathrm{I}}_U-{\mathrm{I}}_L)$$

(11)

where, I_L and I_U are lower and upper bounds respectively of i-th flying squirrel in j-th dimension and U (0, 1) is a uniformly distributed random number in the range (0, 1).

Step 2:

Fitness evaluation

The fitness value of each flying squirrel is calculated by substituting the decision variables into the user-defined fitness function equation and the respective values are stored in arrays [30] as illustrated below:

$$F_{EVAL}=\left[\begin{array}{rrrrr}{F}_{EVAL1}& \left(\right[{\mathrm{I}}_{1,1}& {\mathrm{I}}_{1,2}& \cdots & {\mathrm{I}}_{1,d}\left]\right)\\ F_{EVAL2}& \left(\right[{\mathrm{I}}_{2,1}& {\mathrm{I}}_{2,2}& \cdots & {\mathrm{I}}_{2,d}\left]\right)\\ & & ⋮& & \\ F_{EVALn}& \left(\right[{\mathrm{I}}_{n,1}& {\mathrm{I}}_{n,2}& \cdots & {\mathrm{I}}_{n,d}\left]\right)\end{array}\right]$$

(12)

where F_EVAL = (F_EVAL1, F_EVAL2, …, F_EVALn) is the fitness value for each flying squirrel location.

Step 3:

Sorting, declaration and random selection

Furthermore, the quality of the food source (cloud server) based on the fitness value is sorted in ascending order.

$$Sort(F_{EVAL})=[sorted\_F_{EVAL},sorted\_index]$$

(13)

Based on the sorting of the food source of each flying squirrel location, the optimization algorithm consists of three trees, such as hickory tree (hickory nuts food source), oak tree (acorn nuts food source) and the normal tree, which evaluates the best nuts or food source, which is located by the flying squirrel. Within this tree, the hickory tree represents the best solution that is the minimal fitness value, which is denoted as (I_HT), then the next three best flying squirrels are considered to be on the acorn nut trees (I_AT) and the rest are considered as normal trees (I_NT).

Step 4:

Generate new locations

Under dynamic foraging conditions, that is, in search of an efficient solution, there are three situations. In every situation, it is assumed that the predator is absent so that it encourages the flying squirrel to search for a better solution over a wide area or forest or working space [31]. The three scenarios are:

• Scenario 1: The new location generated by the flying squirrels when it tends to move from acorn nut trees to hickory nut trees. The new locations can be generated as follows:

$${\mathrm{I}}_{AT}^{new}=\{\begin{array}{cc}{\mathrm{I}}_{AT}^{old}+{\lambda }_g\kappa \left({\mathrm{I}}_{HT}^{old}-{\mathrm{I}}_{AT}^{old}\right),\hspace{0.17em}& if\hspace{0.17em}{U}_1\ge P_{AB}\\ randomlocation,& Otherwise\hspace{0.17em}\end{array}$$

(14)

where, ${\mathrm{I}}_{AT}^{new}$ denotes the newly updated value for flying squirrel of acorn nut trees to hickory nut tree, ${\lambda }_g$ represents the gliding distance, $\kappa$ states the gliding constant, $U_1$ is a function which returns a value from the uniform distribution on the interval (0, 1), and $P_{AB}$ is the absence of predators.

• Scenario 2: The new location generated by the flying squirrel when it tends to move from normal trees to acorn nut trees. The new locations can be generated as follows:

$${\mathrm{I}}_{NT}^{new}=\{\begin{array}{cc}{\mathrm{I}}_{NT}^{old}+{\lambda }_g\kappa \left({\mathrm{I}}_{AT}^{old}-{\mathrm{I}}_{NT}^{old}\right),\hspace{0.17em}& if\hspace{0.17em}{U}_2\ge P_{AB}\\ randomlocation,& Otherwise\hspace{0.17em}\end{array}$$

(15)

U₂ is a function which returns a value from the uniform distribution on the interval (0, 1).

• Scenario 3: The new location generated by the flying squirrels when it tends to move towards hickory tree if they have already fulfilled their daily energy requirements in this scenario, the new location of squirrels can be generated as follows:

$${\mathrm{I}}_{NT}^{new}=\{\begin{array}{cc}{\mathrm{I}}_{NT}^{old}+{\lambda }_g\kappa \left({\mathrm{I}}_{HT}^{old}-{\mathrm{I}}_{NT}^{old}\right),\hspace{0.17em}& if\hspace{0.17em}{U}_3\ge P_{AB}\\ randomlocation,& Otherwise\hspace{0.17em}\end{array}$$

(16)

U₃ is a function which returns a value from the uniform distribution on the interval (0, 1).

Step 5:

Seasonal monitoring condition

Due to seasonal conditions (outliers), the behavior of the flying squirrel may be changed. So as to cope up with the seasonal conditions and to avoid getting trapped within the local minima or solutions, a seasonal monitoring condition is introduced in the algorithm

$$Se{a}_C^t=\sqrt{{\displaystyle \sum _{k=1}^d{\left({\mathrm{I}}_{AT,K}^t-{\mathrm{I}}_{HT,k}\right)}^2}}$$

(17)

$$Se{a}_{\min }=\frac{10e^{-6}}{{(365)}^{t/(t_m/2.5)}}$$

(18)

Then, the seasonal monitoring condition is checked. Under the condition of $Se{a}_C^t<Se{a}_{\min }$, the winter is over and the flying squirrels which lose their abilities to explore the forest will randomly relocate their searching positions for food sources again:

$${\mathrm{I}}_{NT}^{new}={\mathrm{I}}_L+Levy(n)\times ({\mathrm{I}}_U-{\mathrm{I}}_L)$$

(19)

where Levy distribution is a powerful mathematical tool to enhance the global exploration capability of most optimization algorithms

$$Levy(x)=0.01\times \frac{u_a\times \xi }{{\left|u_b\right|}^{1/\kappa }}$$

(20)

where, u_a and u_b are two functions which return a value from the uniform distribution on the interval (0, 1), $\kappa$ is the constant and $\xi$ is the Levy Index and it is calculated as:

$$\xi ={\left(\frac{\mathsf{\Gamma }(1+\kappa )\times \sin (\pi \kappa /2}{\mathsf{\Gamma }\left((1+\kappa )/2\right)\times \kappa \times 2^{((\kappa -1)/2)}}\right)}^{1/\kappa }$$

(21)

where, $\mathsf{\Gamma }(\kappa )=(\kappa -1)!$

Step 6:

Crossover and Mutation

In order to achieve an accurate location of the flying squirrel which is in search of food, crossover and mutation are performed on the flying squirrel. That is, among the updated new locations of the flying squirrel (${\mathrm{I}}_{HT}^{new}$), a crossover point is chosen randomly. Now, within the selected crossover point, the new location of the flying squirrel is updated until the crossover point is reached. Now, these updated new locations are added the previous locations, and the mutation is performed so as to obtain better selection accuracy. Initially, two squirrels are selected with the best fitness value and after that, crossover probability ${ƛ}_C$ and mutation probability ${ƛ}_m$ are calculated using the equation below:

$${ƛ}_C=\{\begin{array}{ll}{ƛ}_{c_0},& {\mathrm{I}}_{NT}\le {\mathrm{I}}_{avg},\\ {ƛ}_{c_1}{\left(\frac{{ƛ}_{c_0}}{{ƛ}_{c_1}}\right)}^{(({\mathrm{I}}_{HTMAX}-{\mathrm{I}}_{NT})/({\mathrm{I}}_{HTMAX}-{\mathrm{I}}_{avg}))},& {\mathrm{I}}_{NT}>{\mathrm{I}}_{avg},\end{array}$$

(22)

$${ƛ}_m=\{\begin{array}{ll}{ƛ}_{m_0},& {\mathrm{I}}_{NT}^{″}\le {\mathrm{I}}_{avg},\\ {ƛ}_{m_1}{\left(\frac{{ƛ}_{m_0}}{{ƛ}_{m_1}}\right)}^{(({\mathrm{I}}_{HTMAX}-{\mathrm{I}}_{NT}{}^{|\prime })/({\mathrm{I}}_{HTMAX}-{\mathrm{I}}_{avg}))},& {\mathrm{I}}_{NT}^{″}>{\mathrm{I}}_{avg},\end{array}$$

(23)

where, ${ƛ}_{c_0}$ and ${ƛ}_{m_0}$ represent the higher crossover and mutation probabilities, ${ƛ}_{c_1}$ (${ƛ}_{c_1}$ < ${ƛ}_{c_0}$) and ${ƛ}_{m_1}$ (${ƛ}_{m_1}$ < ${ƛ}_{m_0}$) are the lower probabilities, ${\mathrm{I}}_{NT}$ and ${\mathrm{I}}_{NT}^{″}$ are the lower fitness values of the flying squirrel, and ${\mathrm{I}}_{HTMAX}$ and ${\mathrm{I}}_{avg}$ are the optimal and average fitness values in the population.

• When the fitness of a flying squirrel is greater than the average one in the population (total features), it shows that the squirrel is better, and ${ƛ}_C$ and ${ƛ}_m$ should be correspondingly reduced.
• When the fitness of a flying squirrel is smaller than the average one, it indicates that the squirrel has a poor performance, and ${ƛ}_C$ and ${ƛ}_m$ should keep their initial configurations.
• When the fitness of a flying squirrel is close to the maximum one, ${ƛ}_C$ and ${ƛ}_m$ should be kept as small as possible to retain the best individual.

Step 7:

Stopping criterion

The algorithm terminates if the maximum number of iterations is satisfied. Otherwise, generating new locations and checking seasonal monitoring conditions are repeated.

Thus, the HSSG algorithms tend to provide the best overall fitness value-based features so as to select the respective cloud server. The selected features are stored in an array for further processing as shown below in the equation:

$$F_{SELECT}=\left[\begin{array}{cc}{\mathrm{I}}_{1,1}& {\mathrm{I}}_{3,2}\\ {\mathrm{I}}_{2,1}& {\mathrm{I}}_{3,1}\end{array}\begin{array}{cc}\cdots & {\mathrm{I}}_{1,d}\\ \cdots & {\mathrm{I}}_{2,d}\end{array}\right]$$

(24)

Thus, the pseudo code for the proposed HSSG algorithm is illustrated in Algorithm 1, which gives an overall outline of the proposed HSSG method.

Algorithm 1

Input:$\mathrm{Extracted}\mathrm{Features}{Y}_{FS}=\left({\mathrm{I}}_{1,1},{\mathrm{I}}_{1,2},\mathrm{.....}{\mathrm{I}}_{1,\mathrm{d}}\right)$

Output: Relevant Features

Begin

Initialize the input parameters

Initialize the location of squirrel randomly

While (the stopping criterion is not satisfied)

Calculate the fitness value using,

${\mathrm{F}}_{EVAL}={\mathrm{F}}_{EVAL1}\left(\left[{\mathrm{I}}_{1,1},{\mathrm{I}}_{1,2},\mathrm{.....}{\mathrm{I}}_{1,\mathrm{d}}\right]\right)$

for t = 1 to U1

Generate new location scenario1:

if $f({\mathrm{U}}_1\ge P_{AB}$)

${\mathrm{I}}_{\mathrm{AT}}^{new}={\mathrm{I}}_{\mathrm{AT}}^{old}+{\lambda }_{g}K({\mathrm{I}}_{\mathrm{NT}}^{old}-{\mathrm{I}}_{\mathrm{AT}}^{old}$)

else

Random position of search space

end for

for t = 1 to U2

Generate new location scenario2:

if $f({\mathrm{U}}_2\ge P_{AB}$)

${\mathrm{I}}_{\mathrm{NT}}^{new}={\mathrm{I}}_{\mathrm{NT}}^{old}+{\lambda }_{g}K\left({\mathrm{I}}_{\mathrm{AT}}^{old}-{\mathrm{I}}_{\mathrm{NT}}^{old}\right)$

else

Random position of search space

end for

for t=1 to U3

Generate new location scenario3:

if $f({\mathrm{U}}_3\ge P_{AB}$)

${\mathrm{I}}_{\mathrm{NT}}^{new}={\mathrm{I}}_{\mathrm{NT}}^{old}+{\lambda }_{g}K\left({\mathrm{I}}_{\mathrm{HT}}^{old}-{\mathrm{I}}_{\mathrm{NT}}^{old}\right)$

else

Random position of search space

end for

Calculate seasonal constant ${\mathrm{Sea}}_C^{t}and Se{a}_{min}$

if ${\mathrm{Sea}}_C^t<Se{a}_{min}$

Randomly relocate flying squirrels using,

${\mathrm{I}}_{\mathrm{NT}}^{new}={\mathrm{I}}_L+\mathrm{Levy}\left(\mathrm{n}\right)\times \left({\mathrm{I}}_{\mathrm{U}}-{\mathrm{I}}_L\right)$

end

Evaluate crossover probability ${\lambda }_c$ and mutation probability ${\lambda }_m$

Locate the new location of squirrel on hickory nut tree obtained by crossover

and mutation is the final optimal solution

End While

End Begin

4.2. Cloud Server Arrangements

After selecting the features, they are sorted depending upon the fitness value of the features of application as well as cloud servers. The sorting of the features is carried out by the quick-sort algorithm. The sorting of the features helps the cloud server to improve its reliability.

The key process in quick sort is partitioning. The target of the partitions is $F_{SELECT}$, given an array and a fitness value of the feature of the array is chosen as the pivot, so the quick-sort algorithm puts the pivot value at its correct position in a sorted array and puts all smaller features before the pivot value and put all greater feature fitness value after the pivot value. Thus, the sorting is represented in the equation below:

$$\{\begin{array}{l}QuickSort(F_{SELECT},low,high)\\ pivot\_index=partition(F_{SELECT},low,high);\\ \mathrm{QuickSort}(F_{SELECT},low,pivot\_index-1);\\ \mathrm{QuickSort}(F_{SELECT},high,pivot\_index+1);\end{array}\left(if(low<high)\right)$$

(25)

Based on the above equation, the sorting of the features has been done. Now, the features are arranged more reliably so as to avoid any errors while selecting the cloud server, which allows the full utilization of the resource and provides a good accuracy rate. Thus, the sort feature is represented in the equation below:

$$F_{SORT}=\left[\begin{array}{cc}{\mathrm{I}}_{1,1}& {\mathrm{I}}_{1,2}\\ {\mathrm{I}}_{2,1}& {\mathrm{I}}_{2,2}\end{array}\begin{array}{cc}\cdots & {\mathrm{I}}_{1,d}\\ \cdots & {\mathrm{I}}_{2,d}\end{array}\right]$$

(26)

4.3. Cloud Server Selection

Cloud server selection is the most important step for cloud interoperability. Based on the sorted features the selection of a cloud server takes place. As the existing techniques faced an inappropriate cloud server selection and improper utilization of resources which caused a high error rate. In order to select the cloud server, the work uses the improved adaptive neuro-fuzzy inference system (I-ANFIS) [32]. The primary goal of I-ANFIS is to allocate an appropriate resource to the application or software with maximum resource utilization and minimum delay. The I-ANFIS provides accurate selection of the cloud server due to the Gaussian kernel membership function which tends to reduce the possibility of error. The I-ANFIS structural layers are presented below in Figure 2. The workings behind each structural layer of the I-ANFIS are stated below:

Fuzzification layer: This transforms the crisp input that is the collection of the selected features of the application and the VM servers into linguistic labels with a degree of membership as explained below in Equations (27) and (28).

$$\mathrm{Rule}1: \mathrm{if} {\mathrm{I}}_i \mathrm{is}{\hslash }_i\mathrm{and} {\mathrm{I}}_{i+1}\mathrm{is}{\widehat{ƛ}}_i, \mathrm{then} {\mathsf{\Phi }}_i=x_i{\mathrm{I}}_i+y_i{\mathrm{I}}_{i+1}+{\Im }_i$$

(27)

$$\mathrm{Rule}2: {\mathrm{I}}_i \mathrm{is} {\hslash }_{i+1}\mathrm{and} {\mathrm{I}}_{i+1}\mathrm{is}{\widehat{ƛ}}_{i+1}, \mathrm{then} {\mathsf{\Phi }}_{i+1}=x_{i+1}{\mathrm{I}}_i+y_{i+1}{\mathrm{I}}_{i+1}+{\Im }_{i+1}$$

(28)

where ${\hslash }_i$, ${ƛ}_i$, ${\hslash }_{i+1}$ and ${ƛ}_{i+1}$ signify the fuzzy sets; and ${\mathrm{I}}_i$ and ${\mathrm{I}}_{i+1}$ denote the input set (task features and VM status details). ${\Im }_i$, $x_i$, $y_i$, ${\Im }_{i+1}$, $x_{i+1}$ and $y_{i+1}$ values are the parameter set and $\mathsf{\Phi }$ is a first-order polynomial and represents the outputs of the first-order Sugeno fuzzy inference system. I-ANFIS is composed of five functional layers. The function of each layer is given as follows:

The output of each node in the first layer is defined as,

$${\prod }_i^1={\Omega }_i({\mathsf{\Phi }}_i)\hspace{0.17em}\hspace{0.17em}\hspace{0.17em}\hspace{0.17em},i=1,2,\dots \dots$$

(29)

where, ${\prod }_i^1$ signifies the output of layer 1, ${\mathsf{\Phi }}_i$ is the collection of input nodes and ${\Omega }_i$ represents the Gaussian kernel membership function (GKMF). To improve the performance of I-ANFIS the proposed work performs the Gaussian kernel membership (GKMF) function, which is computed as follows,

$${\Omega }_i=\exp \left(-\frac{{\Vert {\mathrm{I}}_i-y_i\Vert }^2}{2{\varpi }^2}\right)$$

(30)

where, $y_i$ is the central value and standard deviation $\varpi$ which should be greater than 0 $\left(\varpi >0\right)$. If the Standard Deviation (SD) value is smaller, then the membership value will be accurate in identifying the features. Membership values are computed for each input value in $\mathrm{I}$.

Product layer: Every node in layer 2 is a fixed node, which admits first layer input values and turns to represent fuzzy sets of respective input variables as a membership function. The output of each node multiplies the entire signal coming towards it and represents the firing strength of a rule.

$${\prod }_i^2=w_i={\Omega }_i{\mathrm{I}}_i\times {\Omega }_i{\mathrm{I}}_{i+1}$$

(31)

Here, $w_i$ $\to$ firing strength.

Normalization layer: The output of each node in this layer represents their normalization position to the firing strengths from the previous layer.

$${\prod }_i^3=E_y({\overline{w}}_i)=\frac{E_y(w_i)}{{\displaystyle \sum _{i=1}^n{E}_y(w_i)}},i=1,\hspace{0.17em}2,\dots$$

(32)

Here, $E_y({\overline{w}}_i)$ signifies normalized firing strength entropy value.

Defuzzification layer: Each node of this layer gives a firing strength output of the first order Sugeno-type fuzzy if-then rule as follows,

$${\prod }_i^4=E_y({\overline{w}}_i).{\mathsf{\Phi }}_i$$

(33)

Output layer: It has only one node, and it calculates the sum of all the outputs coming from the nodes of the previous layer to produce the overall I-ANFIS output as in Equation (24).

$${\prod }_i^5={\displaystyle \sum _{i=1}^n{E}_y({\overline{w}}_i).\hspace{0.17em}\hspace{0.17em}{\mathsf{\Phi }}_i}=\frac{{\displaystyle \sum _{i=1}^n{E}_y({\overline{w}}_i).{\mathsf{\Phi }}_i}}{{\displaystyle \sum _{i=1}^n{E}_y({\overline{w}}_i)}}$$

(34)

Here, ${\prod }_i^5$ is the overall output of I-ANFIS. That is to say, the output ${\prod }_i^5$ signifies the best cloud server that is regarded as a chosen VM to execute the application or software.

Thus, the overall outline of the proposed I-ANFIS is given in the form of pseudo code illustrated in Algorithm 2.

Algorithm 2

Input: Application and VM features

Output: Cloud Server Selection

Begin

Initialize the linear parameters, ${\Im }_{i,}{x}_i,y_i$

For i = 1 to n

Generate fuzzy output from crisp input using,

${{{\displaystyle \prod }}^{\text{}}}_{\mathrm{i}}^1\leftarrow \mathrm{Gaussian}\mathrm{kernal}\mathrm{membership}\mathrm{function}\left({\mathrm{I}}_1:c,\sigma \right)={\Omega }_i\left({\mathrm{I}}_i\right)$

Calculate firing strength for each rule using,

${{{\displaystyle \prod }}^{\text{}}}_{\mathrm{i}}^2\leftarrow {\Omega }_i\left({\mathrm{I}}_i\right)\times {\Omega }_{i+1}\left({\mathrm{I}}_{i+1}\right)={\omega }_i$

Normalize the firing strength using,

${{{\displaystyle \prod }}^{\text{}}}_{\mathrm{i}}^3\leftarrow \frac{{\mathrm{E}}_{\mathrm{y}}\left({\omega }_i\right)}{{{\displaystyle \sum }}^{\text{}}{\mathrm{E}}_{\mathrm{y}}\left({\omega }_i\right)}={ῶ}_i$

Calculate Defuzzify the output of 3rd layer using,

${{{\displaystyle \prod }}^{\text{}}}_{\mathrm{i}}^4\leftarrow {\mathrm{E}}_{\mathrm{y}}\left({ῶ}_i\right)\left(x_i\left({\mathrm{I}}_i\right)\times y_{i+1}\left({\mathrm{I}}_{i+1}\right)\right)={\mathrm{E}}_{\mathrm{y}}\left({ῶ}_i\right)\times {\mathsf{\Phi }}_i$

Evaluate the output by converting fuzzy result into crisp output using

${{{\displaystyle \prod }}^{\text{}}}_{\mathrm{i}}^5\leftarrow {{\displaystyle \sum }}^{\text{}}{\mathrm{E}}_{\mathrm{y}}\left({ῶ}_i\right)\times {\mathsf{\Phi }}_i$

End for

End Begin

5. Discussion and Results

This section provides a detailed analysis of the proposed efficient application cloud interoperability based on various performance metrics and thereafter a comparative analysis is done with the existing methodologies in order to state its efficiency.

5.1. Performance Analysis

Based on performance metrics, such as accuracy, precision, F-measures, recall, fitness value vs. iteration, sorting time and training time, the evaluation of the proposed methods is carried out. The analysis of the proposed work is split based on proposed feature selection, sorting of features and selection of cloud server.

5.1.1. Performance Analysis of Proposed HSSG Algorithm for Selecting Features

The proposed HSSGA feature selection method is analyzed based on iteration vs. fitness value and compared with existing techniques, such as lower pollination algorithm (FPA), cat swarm optimization algorithm (CSO), genetic algorithm (GA), and squirrel search algorithm (SSA). The evaluation of iteration vs. fitness for the proposed method is tabulated.

Table 1. Evaluation of proposed hybrid squirrel search genetic (HSSG) algorithm based on iteration vs. fitness.

Optimization Technique	FPA	CSO	GA	SSA	Proposed
5	35	39	41	53	63
10	50	54	57	65	73
15	59	63	68	70	86
20	67	71	75	85	96
25	79	84	89	92	102

illustrates the evaluation of the proposed HSSG optimization algorithm based on iteration vs. fitness value to select the important features in order to achieve good accuracy and low complexity time. To elaborate its efficiency, it was analyzed with existing techniques, such as FPA, CSO, GA and SSA [33]. Basically, iteration vs. fitness states that the method adheres to best fitness value and reduces the computational time within a minimal iteration. According to that, the analysis illustrated that the proposed HSSG algorithm tends to achieve a fitness value of 102 for the 25th iteration whereas the existing FPA, CSO, GA and SSA achieve fitness values of 79, 84, 89 and 92, respectively. From the analysis, it is known that the proposed HSSG algorithm tends to achieve the best fitness value compared to existing methods. The graphical analysis of the proposed algorithm with the existing method is represented in Figure 3.

From Figure 3 it can be graphically analyzed and illustrated that the proposed HSSG algorithm tends to achieve better fitness outcomes for the respective iteration than the existing FPA, CSO, GA and SSA algorithms. The better fitness values within a low iteration may help to decrease the time complexity and may also help achieve good accuracy without further iteration proceeding processes.

5.1.2. Performance Analysis of Proposed I-ANFIS for Selection of Cloud Server

The proposed I-ANFIS is analyzed based on various performance metrics, such as accuracy, precision, recall, training time, memory usage and F-measure with various existing methods, such as Support Vector Machine (SVM), K-Nearest Neighbor (KNN), Artificial Neural Network (ANN) and ANFIS. The evaluation of the performance metrics for the proposed I-ANFIS and the existing methods is tabulated.

Table 2. Evaluation of proposed I-ANFIS based on precision, accuracy, recall and F-measure.

Techniques/Performance Metrics	Existing SVM	Existing KNN	Existing ANN	Existing ANFIS	Proposed I-ANFIS
Precision	84.33	85.01	85.22	85.5	87.58
Recall	87.11	87.87	88.12	88.36	91.19
F-measure	87.02	87.33	88.57	89.91	90.51
Accuracy	88.33	89.66	91.55	92.55	94.24

illustrates the analysis of various performance metrics, such as accuracy, recall, F-measure and precision, for the proposed method and evaluated against the existing methods, such as SVM, KNN, ANN and ANFIS [34]. The analysis illustrates that the proposed I-ANFIS achieves precision, recall, F-measure and accuracy values of 87.58%, 91.19%, 90.51% and 94.24%, respectively, which ranges between 87.58 and 94.24%, whereas the existing methods tend to achieve metric values ranging between 84.33 and 92.55% which is relatively low compared to the proposed method. The metrics estimate the efficiency of the proposed I-ANFIS based on true positive (TP), false positive (FP), true negative (TN) and false negative (FN). Therefore, the proposed method tends to determine the best server that suits the corresponding application features. The graphical analysis of the proposed method along with the existing method is illustrated in Figure 4.

Figure 4 illustrates the graphical analysis of the metrics, such as accuracy, precision, recall and F-measure, for the proposed I-ANFIS [35] technique with the existing SVM, KNN, ANN and ANFIS. The analysis illustrates that the proposed techniques tend to detect the cloud server with better accuracy and tends to reduce the false negative and false positive rate by achieving a better recall and precision value. However, the existing techniques tend to achieve comparatively fewer metric values.

Training Time and Memory Usage analysis of Proposed I-ANFIS

Based on training time and memory usage, the proposed I-ANFIS is evaluated with existing SVM, KNN, ANN and ANFIS. From Figure 4 it can be stated that the proposed I-ANFIS tends to utilize less training time as well as CPU and memory usage in order to perform more efficiently. Figure 5a illustrates that the proposed technique achieves a training time of 23,457 ms to train a dataset, which is comparatively better compared to existing SVM, KNN, ANN and ANFIS methods, which achieve training times of 40,325 ms, 36,457 ms, 32,457 ms and 28,745 ms, respectively. Figure 5b illustrates that the proposed technique consumes 17,515 kb of memory, whereas the existing SVM, KNN, ANN, and ANFIS technique achieve memory usage of 26,354 kB, 24,568 kB, 21,457 kB and 19,634 kB respectively, which is comparatively higher than the proposed method.

Thus, the proposed I-ANFIS attempts to achieve a better selection of server based on the application and cloud server features by requiring low time as well as low usage of memory to avoid complexity.

5.1.3. Performance Analysis of Proposed Quick Sort for Sorting the Selection Features

The performance analysis of the quick-sort algorithm is done based on sorting time with the existing heap, bubble, insertion and merge sort algorithms in order to compare the time consumption between the algorithms and to state its efficiency. The graphical analysis of the sorting time for the proposed and existing algorithms is represented in Figure 6.

Figure 6 represents the graphical analysis of the sorting time taken by the proposed quick-sort algorithm and the existing heap, bubble, insertion and merge sort algorithms so as to compute the best algorithm. The sorting algorithm helps the I-ANFIS algorithm to select the cloud server with respect to the applications. There should be a low sorting time in order to reduce the computational time. According to that, the proposed methods tend to achieve a sorting time of 6322 ms, whereas, the existing heap, bubble, insertion and merge sort algorithms tend to achieve sorting times of 11,969 ms, 11,347 ms, 10,457 ms and 9478 ms, respectively, which is relatively high compared to the proposed algorithm.

Thus, the proposed framework for cloud interoperability achieves a unilateral provision of computing capabilities of a cloud server without the help of human interaction and allows utilization of applications and services across various domains.

6. Conclusions

The work introduces an efficient application cloud interoperability framework, which is used to manage various applications or data and to execute over the respective cloud server. The framework provides efficient solutions for the implementation of collaboration among services for better quality in providing services. In order to overcome the technological and non-technological challenges, the framework has developed a hybrid search optimization algorithm for selecting relevant features and the I-ANFIS technique to select the cloud server. It avoids most of the redundant data and utilizes less memory so as to avoid complexity or congestion. The efficiency of the proposed methods is evaluated using various performance metrics, and overall, the evaluation states that the framework achieved an accuracy rate of 94.24%, precision of 87.58%, recall of 91.19% and F-measure of 90.51%, which is highly efficient compared to existing works. Therefore, in future the proposed framework can be improvised by indulging load balancing techniques for handling multiple requests and deep learning techniques to increase the accuracy rate of selecting a cloud server.