Operation Invocations Research Articles

Modelling cloud service latency and availability using a deep learning strategy

Low latency and high availability in cloud services give users satisfactory response time and guarantee stability to request they make to services that are hosted in the cloud, thus increasing the usability and reliability of cloud services. On the other hand, high latencies and poor availability will cost businesses their customers due customers dissatisfaction, thus losing customers to competitors. This situation noticeable in e-commerce businesses where real-time response and decision making within seconds are critical for business service delivery. Therefore, latency and availability are important parameters in the Service Level Agreement for cloud users when choosing Cloud Services Providers (CSPs). But the challenge for businesses is that they do not have their in–house mechanism that can accurately predict the required latency and availability for their requirements. Companies only rely on the CSPs tools for estimating resource requirements, which is biased towards the CSPs business model. In this paper, we developed a deep learning algorithm that predicts the latency and availability of cloud services using real-time live data from three CSPs. We designed and implemented experiments on Amazon Web Services, Alibaba Cloud and Tencent Cloud in Beijing University of Posts and Telecommunications to run compute instances across the United States, Europe and Asia Pacific regions. In each cloud platform, five servers were used that resulted in 30,815,100 invocations of http and ping operations for 6 weeks. The algorithm used the data on hourly, daily and weekly basis as historical network data to predict latency and availability. We used MATLABs deep learning toolbox for the implementation of our algorithm and the results showed that the prediction is usually above 90% accurate as compared with the data obtained. The results also revealed that latency performance depends on the locations of users and the availability depends on number of availability zones used.

Testing self-healing cyber-physical systems under uncertainty with reinforcement learning: an empirical study

Self-healing is becoming an essential feature of Cyber-Physical Systems (CPSs). CPSs with this feature are named Self-Healing CPSs (SH-CPSs). SH-CPSs detect and recover from errors caused by hardware or software faults at runtime and handle uncertainties arising from their interactions with environments. Therefore, it is critical to test if SH-CPSs can still behave as expected under uncertainties. By testing an SH-CPS in various conditions and learning from testing results, reinforcement learning algorithms can gradually optimize their testing policies and apply the policies to detect failures, i.e., cases that the SH-CPS fails to behave as expected. However, there is insufficient evidence to know which reinforcement learning algorithms perform the best in terms of testing SH-CPSs behaviors including their self-healing behaviors under uncertainties. To this end, we conducted an empirical study to evaluate the performance of 14 combinations of reinforcement learning algorithms, with two value function learning based methods for operation invocations and seven policy optimization based algorithms for introducing uncertainties. Experimental results reveal that the 14 combinations of the algorithms achieved similar coverage of system states and transitions, and the combination of Q-learning and Uncertainty Policy Optimization (UPO) detected the most failures among the 14 combinations. On average, the Q-Learning and UPO combination managed to discover two times more failures than the others. Meanwhile, the combination took 52% less time to find a failure. Regarding scalability, the time and space costs of the value function learning based methods grow, as the number of states and transitions of the system under test increases. In contrast, increasing the system’s complexity has little impact on policy optimization based algorithms.

Improving generalized inverted index lock wait times

Concurrent operations on tree like data structures is a cornerstone of any database system. Concurrent operations intended for improving read\\write performance and usually implemented via some way of locking. Deadlock-free methods of concurrency control are known as tree locking protocols. These protocols provide basic operations(verbs) and algorithm (ways of operation invocations) for applying it to any tree-like data structure. These algorithms operate on data, managed by storage engine which are very different among RDBMS implementations. In this paper, we discuss tree locking protocol implementation for General inverted index (Gin) applied to multiversion concurrency control (MVCC) storage engine inside PostgreSQL RDBMS. After that we introduce improvements to locking protocol and provide usage statistics about evaluation of our improvement in very high load environment in one of the world’s largest IT company.

Towards Behavioral Web Service Discovery Approach: State of the Art

The literature on web service (WS) discovery recognizes a major problem in the requirements of service consumption. Current works on WS discovery focuses on WS discovery scenario and neglect the analysis of the intervention of service consumer. Therefore, the problem of service consumer needs must be solved to guarantee the pertinence of WS selection and the consumer satisfaction.In this paper, we defined a comparative study between the WS discovery approaches. Based on the comparison framework, analyzes lead us to propose a specific approach to SOA named B-WSD approach based on behavioral aspect. The behavioral description of a WS consists in describing the order of invocation of WS operations more precisely the execution manner of composed WS.

Event Based Approach for Web Services Composition

The success of the Internet and the ongoing globalization led to a demand for new solutions to meet the requirements for ITsystems. The paradigm of service-oriented and event-driven architecture with fine grained and loosely coupled services tries to cope with those needs. Service Oriented Architecture (SOA) and Event Driven Architecture (EDA) are two acknowledged architectures for the development of business applications and information systems, which have evolved separately over the years. Today both architectures are acknowledged, but their synergy is not. There are numerous benefits of having an architecture that supports coexistence between operations and events, and composition of services based on operation invocation and event triggering. As part of our ongoing research work, we have tried to analyze in this paper, the basic design of Event based systems, issues that have to be addressed when event based approach is used for composing and coordinating web services. Then we have specified the techniques available that handle these issues, and gave a comparative study on these techniques. Finally we have attempted to sort out the unhandled/ partially handled issues that could be addressed as part of our research.

Behaviour Protocols for Interacting Stateful Components

We propose a formal foundation for behaviour protocols of interacting, concurrent components with data states. Formally, behaviour protocols are given by labelled transition systems which specify the order of operation invocations as well as the allowed changes of data states of components in terms of pre- and postconditions. We study the compatibility of protocols and we consider their composition which yields a behaviour protocol for a component assembly. Behaviour protocols are equipped with a model-theoretic semantics which describes the class of all correct component or assembly implementations. Implementation models are again formalised in terms of labelled transition systems and the correctness notion is based on an alternating simulation relation between protocol and implementation which takes into account concrete control and data states. As a major result we show that our approach is compositional, i.e. that locally correct implementation models of compatible protocols compose to a globally correct implementation, thus ensuring independent implementability.

Invocation of operations from script-based Grid applications

In this paper we address the complexity of building and running modern scientific applications on various Grid systems with heterogeneous middleware. As a solution we have proposed the Grid Operation Invoker (GOI) which offers an object-oriented method invocation semantics for interacting with diverse computational services. GOI forms the core of the ViroLab virtual laboratory and it is used to invoke operations from within in-silico experiments described using a scripting notation. We describe the details of GOI (including architecture, technology adapters and asynchronous invocations) focusing on a mechanism which allows adding high-level support for batch job processing middleware, e.g. EGEE LCG/gLite. As an example, we present the NAMD molecular dynamics program, deployed on EGEE infrastructure. The main achievement is the creation of the Grid Object abstraction, which can be used to represent and access such diverse technologies as Web Services, distributed components and job processing systems. Such an application model, based on high-level scripting, is an interesting alternative to graphical workflow-based tools.

Combining data sharing with the master–worker paradigm in the common component architecture

Software component technologies are being accepted as an adequate solution for handling the complexity of applications. However, existing software component models tend to be specialized to some types of resource architectures (e.g. in-process, distributed environments, etc.) and/or do not provide a very high level of abstraction. This paper focuses on handling data sharing on operation invocations between components as a solution allowing applications to be efficiently executed on all kinds of resources. In particular, the data sharing pattern appears in master---worker applications, when workers need to access only a part of a large piece of data, either in read or write mode. This approach is applied to the Common Component Architecture model. Its benefits are discussed using an image rendering application.

Efficient access to web services

For Web services to expand across the Internet, users need to be able to efficiently access and share Web services. The authors present a query infrastructure that treats Web services as first-class objects. It evaluates queries through the invocations of different Web service operations. Because efficiency plays a central role in such evaluations, the authors propose a query optimization model based on aggregating the quality of Web service (QoWS) parameters of different Web services. The model adjusts QoWS through a dynamic rating scheme and multilevel matching in which the rating provides an assessment of Web services' behavior. Multilevel matching allows the expansion of the solution space by enabling similar and partial answers.

Distributed Query Processing on the Grid

Distributed query processing (DQP) has been widely used in data intensive applications where data of relevance to users are stored at multiple locations. This paper argues: (i) that DQP can be important in the Grid, as a means of providing high-level, declarative languages for integrating data access and analysis; and (ii) that the Grid provides resource management facilities that are useful to developers of DQP systems. As well as discussing and illustrating how DQP technologies can be deployed within the Grid, the paper describes Polar*, a prototype implementation of a DQP system running over Globus. Polar* can handle complex data by adopting the ODMG object model and its query language OQL, which supports the invocation of user-defined operations. The Globus components are accessed through the MPICH-G interface rather than in a lower level way. A case study from bioinformatics is used throughout the paper, to show the benefits of the approach.

A retrospective on the design of the GOPI middleware platform

This paper offers a high-level retrospective overview of the GOPI middleware platform which is the outcome of a three-year project aimed at the development of generic, configurable and extensible middleware. GOPI has a clearly defined modular structure, is widely extensible with plug-ins at all levels of the architecture, and natively supports stream interactions as well as standard operation invocation. It offers a generic framework for quality of service (QoS) specification and management, and supports a high-level, multimedia-oriented programming environment that is backwardly compatible with the OMG's CORBA. At its lower levels it supports QoS-driven resource management and features an optimised IIOP stack. Despite its enhanced functionality, GOPI's IIOP performance equals or exceeds that of state-of-the-art CORBA platforms.

ICALB: an integrated congestion avoidance and load balancing algorithm for distributed intelligent networks. Part II: Performance evaluation of ICALB

This paper evaluates the Integrated Congestion Avoidance and Load Balancing (ICALB) algorithm [ICALB: an integrated congestion avoidance and load balancing algorithm for distributed intelligent networks—Part I. Description of ICALB, 2002]. We test its performance by applying it in a simulated Distributed Intelligent Network (D-IN). We evaluate the algorithm ability to protect the service execution nodes from congestion, to maintain a high throughput, and to ensure a fair distribution of the resource's capacity among services taking into account service priorities and quality of service requirements. The algorithm's operation mainly exploits the advantages of Common Object Request Broker Architecture (CORBA) Object Request Broker (ORB) middleware that allow the invocation of operations on distributed objects without concern for object location, programming language, OS platform, communication protocols and interconnects, and hardware. Hence, all necessary operations of the algorithm are assumed to be executed over the CORBA ORB.

Exploiting distributed object technology to achieve networked inventory management

This paper reports on the development of Networked Inventory Management Information Systems (NIMISs). These are distributed and object-oriented information systems for integral inventory management across networked organisations. The desired functionality of the systems is networked inventory management, which is the combination of integral inventory management (according to Base Stock Control, Materials Requirements Planning and Line Requirements Planning) and networked organisation management (including configuration flexibility, timing flexibility and algorithm flexibility). The systems exploit distributed object technology, using both distributed systems (with principles as local computing, heterogeneous computing and transparent computing) and object-oriented technology (characterised by object classification, attribute encapsulation and operation invocation). The system design is created with the help of the Object Modeling Technique (OMT) and consists of an object model, a dynamic model and a functional model. For the system implementation the Common Object Request Broker Architecture (CORBA) is applied.

A service acquisition mechanism for server-based heterogeneous distributed systems

This paper presents a mechanism that facilitates and enhances the use of independently administered remote network servers in the presence of server interface heterogeneity. The mechanism is designed under the client-service model, which extends the client-server model with an abstraction of service to decouple abstract server capabilities from concrete server interface specifics such as server interface binding protocols and the interface operation invocation protocols. The mechanism selects servers, accommodates server interface heterogeneity, and handles server access failures as per the abstract server capabilities desired by the client. It could return the identity of the server used for each service access invocation to facilitate billing, refining service specifications, and reporting server-specific errors. This paper also illustrates a C library interface to this mechanism, and describes a language veneer over the C programming language demonstrating how a typed procedural language could be extended by a few language constructs to support the mechanism under the client-service model. In this language, server capabilities are referenced by abstract data type (ADT) objects, and are accessed by invoking the objects' interface operations using a call-by-value-result paradigm. >

The object-oriented structured design notation for software design representation

The development of a notation that supports key software structure concepts and design principles, is discussed. The notation should let designers represent modules, interfaces, hidden information, concurrency, message passing, invocation of operations and overall program structure in a comprehensive way. The authors examine three categories of approach to architectural design: object-oriented design, functional decomposition, and data structure design. They present their design notation, called object-oriented structured design (OOSD) which achieves the above-stated goal. They discuss classes in OOSD, its handling of asynchronous processes, and its design methods and rules. Automated support for OOSD is considered.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

An overview of the SR language and implementation

SR is a language for programming distributed systems ranging from operating systems to application programs. On the basis of our experience with the initial version, the language has evolved considerably. In this paper we describe the current version of SR and give an overview of its implementation. The main language constructs are still resources and operations. Resources encapsulate processes and variables that they share; operations provide the primary mechanism for process interaction. One way in which SR has changed is that both resources and processes are now created dynamically. Another change is that inheritance is supported. A third change is that the mechanisms for operation invocation—call and send—and operation implementation—proc and in—have been extended and integrated. Consequently, all of local and remote procedure call, rendezvous, dynamic process creation, asynchronous message passing, multicast, and semaphores are supported. We have found this flexibility to be very useful for distributed programming. Moreover, by basing SR on a small number of well-integrated concepts, the language has proved easy to learn and use, and it has a reasonably efficient implementation.

Synchronization and recovery of actions

We introduce an approach to robust computation in distributed systems. This approach is the foundation for reliability in the Clouds decentralized operating system. It is based on atomic actions operating on instances of abstract data types (objects). We present an event-based model of computation in which scheduling of responses to operation invocations is controlled by objects. We discuss an integrated strategy for synchronization and recovery which uses relationships between the abstract states of objects to track dependencies between actions. Serializability is defined in terms of the semantics of operations. This permits high concurrency to be obtained in non-serializable implementations without deviation from serializable abstract behavior. We define a class of schedulers that allows objects to make autonomous scheduling decisions. We present the use of non-serializable operation semantics. Finally, we discuss implementation of the model, including action synchronization, object operation ordering using action-based counting semaphores, and action recovery.