Aniruddha S. Gokhale

Efficient Autoscaling in the Cloud Using Predictive Models for Workload Forecasting

Large-scale component-based enterprise applications that leverage Cloud resources expect Quality of Service(QoS) guarantees in accordance with service level agreements between the customer and service providers. In the context of Cloud computing, auto scaling mechanisms hold the promise of assuring QoS properties to the applications while simultaneously making efficient use of resources and keeping operational costs low for the service providers. Despite the perceived advantages of auto scaling, realizing the full potential of auto scaling is hard due to multiple challenges stemming from the need to precisely estimate resource usage in the face of significant variability in client workload patterns. This paper makes three contributions to overcome the general lack of effective techniques for workload forecasting and optimal resource allocation. First, it discusses the challenges involved in auto scaling in the cloud. Second, it develops a model-predictive algorithm for workload forecasting that is used for resource auto scaling. Finally, empirical results are provided that demonstrate that resources can be allocated and deal located by our algorithm in a way that satisfies both the application QoS while keeping operational costs low.

A high-performance end system architecture for real-time CORBA

Many application domains (e.g., avionics, telecommunications, and multimedia) require real-time guarantees from the underlying networks, operating systems, and middleware components to achieve their quality of service (QoS) requirements. In addition to providing end-to-end QoS guarantees, applications in these domains must be flexible and reusable. Requirements for flexibility and reusability motivate the use of object-oriented middleware like the Common Object Request Broker Architecture (CORBA). However, the performance of current CORBA implementations is not yet suited for hard real-time systems (e.g., avionics) and constrained latency systems (e.g., teleconferencing). This article describes the architectural features and optimizations required to develop real-time ORB end systems that can deliver end-to-end QoS guarantees to applications. While some operating systems, networks, and protocols now support real-time scheduling, they do not provide integrated solutions. The main thrust of this article is that advances in real-time distributed object computing can be achieved only by systematically pinpointing performance bottlenecks; optimizing the performance of networks, ORB end systems, common services, and applications; and simultaneously integrating techniques and tools that simplify application development.

Developing applications using model-driven design environments

Historically, software development methodologies have focused more on improving tools for system development than on developing tools that assist with system composition and integration. Component-based middleware like Enterprise Java-Beans (EJB), Microsoft .NET, and the CORBA Component Model (CCM) have helped improve software reusability through component abstraction. However, as developers have adopted these commercial off-the-shelf technologies, a wide gap has emerged between the availability and sophistication of standard software development tools like compilers and debuggers, and the tools that developers use to compose, analyze, and test a complete system or system of systems. As a result, developers continue to accomplish system integration using ad hoc methods without the support of automated tools. Model-driven development is an emerging paradigm that solves numerous problems associated with the composition and integration of large-scale systems while leveraging advances in software development technologies such as component-based middleware. MDD elevates software development to a higher level of abstraction than is possible with third-generation programming languages.

Measuring the performance of communication middleware on high-speed networks

Conventional implementations of communication middleware (such as CORBA and traditional RPC toolkits) incur considerable over-head when used for performance-sensitive applications over high-speed networks. As gigabit networks become pervasive, inefficient middleware will force programmers to use lower-level mechanisms to achieve the necessary transfer rates. This is a serious problem for mission/life-critical applications (such as satellite surveillance and medical imaging).This paper compares the performance of several widely used communication middleware mechanisms on a high-speed ATM network. The middleware ranged from lower-level mechanisms (such as socket-based C interfaces and C++ wrappers for sockets) to higher-level mechanisms (such as RPC, hand-optimized RPC and two implementations of CORBA - Orbix and ORBeline). These measurements reveal that the lower-level C and C++ implementations outperform the CORBA implementations significantly (the best CORBA throughput for remote transfer was roughly 75 to 80 percent of the best C/C++ throughput for sending scalar data types and only around 33 percent for sending structs containing binary fields), and the hand-optimized RPC code performs slightly better than the CORBA implementations. Our goal in precisely pinpointing the sources of overhead for communication middleware is to develop scalable and flexible CORBA implementations that can deliver gigabit data rates to applications.

Applying model-integrated computing to component middleware and enterprise applications

Combining the best elements of these two technologies can address the key challenges associated with developing enterprise applications.

Software Architectures for Reducing Priority Inversionand Non-determinism in Real-time Object Request Brokers

There is increasing demand to extend Object RequestBroker (ORB) middleware to support distributed applications withstringent real-time requirements. However, conventional ORB implementations,such as CORBA ORBs, exhibit substantial priority inversion andnon-determinism, which makes them unsuitable for applicationswith deterministic real-time requirements. This paper providestwo contributions to the study and design of real-time ORB middleware.First, it illustrates empirically why conventional ORBs do notyet support real-time quality of service. Second, it evaluatesconnection and concurrency software architectures to identifystrategies that reduce priority inversion and non-determinismin real-time CORBA ORBs. The results presented in this paperdemonstrate the feasibility of using standard OO middleware likeCORBA to support certain types of real-time applications overthe Internet.

Software-Defined Networking

Currently many aspects of the classical architecture of the Internet are etched in stone - a so called ossification of the Internet - which has led to major obstacles in IPv6 deployment and difficulty in using IP multicast services. Yet, there exist many reasons to extend the Internet, e.g., for improving intra-domain and inter-domain routing for high availability of the network, providing end-to-end connectivity for users, and allowing dynamic QoS management of network resources for new applications, such as data center, cloud computing, and network virtualization. To address these requirements, the next-generation architecture for the Future Internet has introduced the concept of Software-Defined Networking (SDN). At the core of this emerging paradigm is the separation and centralization of the control plane from the forwarding elements in the network as opposed to the distributed control plane of existing networks. This decoupling allows deployment of control plane software components (e.g., OpenFlow controller) on computer platforms that are much more powerful than traditional network equipment (e.g., switches/routers) while protecting the data and intellectual property of the vendors of such equipment.A critical understanding of this emerging paradigm is necessary to address the multiple challenges in realizing the Future Internet and to resolve the ossification problem of the existing Internet. To address these requirements, this paper surveys existing technologies and the wide range of recent and state-of-the-art projects on SDN followed by an in-depth discussion of the major challenges in this area.

A platform-independent component modeling language for distributed real-time and embedded systems

This paper provides two contributions to the study of developing and applying domain-specific modeling languages (DSMLS) to distributed real-time and embedded (DRE) systems - particularly those systems using standards-based QoS-enabled component middleware. First, it describes the platform-independent component modeling language (PICML), which is a DSML that enables developers to define component interfaces, QoS parameters and software building rules, and also generates descriptor files that facilitate system deployment. Second, it applies PICML to an unmanned air vehicle (UAV) application portion of an emergency response system to show how PICML resolves key component-based DRE system development challenges. Our results show that the capabilities provided by PICML - combined with its design and deployment-time validation capabilities - eliminates many common errors associated with conventional techniques, thereby increasing the effectiveness of applying QoS-enabled component middleware technologies to the DRE system domain.

The performance of the CORBA dynamic invocation interface and dynamic skeleton interface over high-speed ATM networks

The common object request broker architecture (CORBA) is intended to simplify the task of developing distributed applications. Although it is well-suited for conventional remote procedure call style applications, several limitations become evident when CORBA is used for a broader range of performance-sensitive applications running in heterogeneous environments over high-speed networks. This paper illustrates the performance limitations of existing CORBA implementations in terms of their support for the dynamic invocation interface (DII) and the dynamic skeleton interface (DSI). The results indicate that object request broker implementers must optimize both the DII and DSI significantly before CORBA will be suitable for performance-sensitive applications on high-speed networks. In addition, the CORBA 2.0 DII specification must be clarified in order to ensure application portability and optimal performance.

DAnCE: a qos-enabled component deployment and configuration engine

This paper presents two contributions to the study of component deployment for distributed real-time and embedded (DRE) systems. First, it uses an inventory tracking systems (ITS) as a case study to elicit challenges involved in deploying DRE systems to account for their quality of service requirements. Second, it describes how we designed and implemented the Deployment And Configuration Engine (DAnCE), which is QoS-enabled middleware that addresses the challenges that arose in the context of our ITS case study. Our experience shows that DAnCE provides an effective platform for deploying DRE system components using a standard runtime environment and metadata.