Shikharesh Majumdar

The stochastic rendezvous network model for performance of synchronous client-server-like distributed software

Distributed or parallel software with synchronous communication via rendezvous is found in client-server systems and in proposed open distributed systems, in implementation environments such as Ada, V, remote procedure call systems, in transputer systems, and in specification techniques such as CSP, CCS and LOTOS. The delays induced by rendezvous can cause serious performance problems, which are not easy to estimate using conventional models which focus on hardware contention, or on a restricted view of the parallelism which ignores implementation constraints. Stochastic rendezvous networks are queueing networks of a new type which have been proposed as a modelling framework for these systems. They incorporate the two key phenomena of included service and a second phase of service. This paper extends the model to also incorporate different services or entries associated with each task. Approximations to arrival-instant probabilities are employed with a mean-value analysis framework, to give approximate performance estimates. The method has been applied to moderately large industrial software systems. >

Scheduling in multiprogrammed parallel systems

Processor scheduling on multiprocessor systems that simultaneously run concurrent applications is currently not well-understood. This paper reports a preliminary investigation of a number of fundamental issues which are important in the context of scheduling concurrent jobs on multiprogrammed parallel systems. The major motivation for this research is to gain insight into system behaviour and understand the basic principles underlying the performance of scheduling strategies in such parallel systems. Based on abstract models of systems and scheduling disciplines, several high level issues that are important in this context have been analysed.

A toolset for performance engineering and software design of client-server systems

Abstract TimeBench/SRVN is a prototype toolset for computer-aided design and performance analysis of software, with an emphasis on distributed client-server systems. The performance behaviour of such systems may defy intuition because it involves factors in the software design (such as the partitioning of the functionality and the frequency with which requests will be made to each server) and in the configuration of the distributed system (including replication of services, the distribution of data, and the speed of network access). The novelty of the tool consists in providing support both for developing design specifications and also for performance analysis. The integrated approach avoids the semantic gap between a designers domain and the performance modeling domain, and assists the designer to explore factors that impact the performance of a design. The performance models are based on the Stochastic Rendezvous Network (SRVN) formalism for client-server systems with synchronous service requests. The distinctive features of SRVNs are nested services (since servers can also act as clients to other servers) and the existence of two or more phases of service (the first executed while the client is blocked, and the others executed in parallel with the client). TimeBench/SRVN is intended as a demonstration of the concept of an integrated designer/performance interface, and as a research environment for fast analytic solvers for the models. Besides a simulation solver, it offers three approximate analytic solvers based on recent research, a Markovian solver, a technique for finding bounds on the throughput without too many assumptions, and a tool for rapidly exploring the space of possible parameter values.

A Synthetic Workload Generation Technique for Stress Testing Session-Based Systems

Enterprise applications are often business critical but lack effective synthetic workload generation techniques to evaluate performance. These workloads are characterized by sessions of interdependent requests that often cause and exploit dynamically generated responses. Interrequest dependencies must be reflected in synthetic workloads for these systems to exercise application functions correctly. This poses significant challenges for automating the construction of representative synthetic workloads and manipulating workload characteristics for sensitivity analyses. This paper presents a technique to overcome these problems. Given request logs for a system under study, the technique automatically creates a synthetic workload that has specified characteristics and maintains the correct interrequest dependencies. The technique is demonstrated through a case study involving a TPC-W e-commerce system. Results show that incorrect performance results can be obtained by neglecting interrequest dependencies, thereby highlighting the value of our technique. The study also exploits our technique to investigate the impact of several workload characteristics on system performance. Results establish that high variability in the distributions of session length, session idle times, and request service times can cause increased contention among sessions, leading to poor system responsiveness. To the best of our knowledge, these are the first results of this kind for a session-based system. We believe our technique is of value for studies where fine control over workload is essential

Characterisation of programs for scheduling in multiprogrammed parallel systems

Abstract The demand for the effective use of medium-scale shared memory parallel computing systems will soon lead to a desire to multiprogram them. Scheduling in multiprogrammed parallel systems is not currently well-understood. Based on models of systems and scheduling strategies this article focuses on the fundamental principles that underly the scheduling of concurrent jobs on multiprocessor systems. Characterization of parallelism in these jobs is important not only in the context of resource management but also for understanding system behaviour. A number of job characteristics which appropriately represent job parallelism and their relationship to processor scheduling are analysed.

Performance of CORBA-based client-server architectures

Middleware has been introduced to provide interoperability as well as transparent location of servers in heterogeneous client-server environments. Although such benefits accrue from the use of middleware, careful consideration of system architecture is required to achieve high performance. Based on implementation and measurements made on the system, this paper is concerned with the impact of client-server interaction architecture on the performance of CORBA Systems. CORBA or Common Object Request Broker Architecture, proposed by the Object Management Group, is one of the commonly used standards for middleware architectures. Using a commercially available CORBA compliant ORB software called ORBeline, four different architectures were designed and implemented for client-server interaction on a network of workstations. In the Handle-Driven ORB (H-ORB) architecture, the client gets the address of the server from the agent and communicates with the server directly. In the Forwarding ORB (F-ORB) architecture the client request is automatically forwarded by the agent to the appropriate server which then returns the results of the computations to the client directly. In the Process Planner (P-ORB) architecture, the agent combines request forwarding with concurrent invocation of multiple servers for complex requests that require the services of multiple servers. The Adaptive ORB (A-ORB) combines the functionalities of both the H-ORB and the F-ORB and can switch dynamically from an H-ORB mode to an F-ORB mode and vice versa, depending on the load condition. Our measurements show that the differences among the performances of these architectures change with a change in the workload. The paper will report on the relative performances of these four architectures under different workload conditions. The results provide insights into system behavior for designers as well as users of systems. In particular, the impact of internode delays, message size, and request service times on the latency and scalability attributes of these architectures is analyzed. A discussion of how agent cloning can improve system performance is also included.

Hosting Web Services on Resource Constrained Devices

Web services are getting popular in the domain of business to business electronic commerce and in automating information exchange between business processes. The use of handheld devices such as PDAs and smart phones is spreading rapidly in the business community. Accessing Web services from small devices is very common these days, but there is hardly any solution available to host Web services on such devices. There are a number of challenges to host a Web service on handheld device. These include limited resources and the lack of the execution environment to host Web services. Because of the resource constraints, it is not possible to use the existing Web service provider toolkits to host the Web service. In this paper, a light weight Web service provider toolkit is proposed that can be used for a variety of handheld devices. The insights gained into this Web service provider system are discussed in detail.

Impact of laxity on scheduling with advance reservations in grids

Advance reservations (ARs) were introduced for application level dynamic scheduling of resources in a grid infrastructure. Previous research shows that ARs can meet their objectives but at a significant performance cost. We argue that laxity in the reservation window of an AR can help improve the performance of AR scheduling. Scheduling ARs with laxities is an NP-hard problem and in this paper we briefly discuss our scalable algorithm for AR scheduling. Based on simulation, the paper investigates in detail the effect laxity on the system performance.

Using analytic models predicting middleware performance

client-server paradigm is very popular in building distributed computing applications. Heterogeneity is natural in client-server systems, where components implemented using different technologies must interact and collaborate with each other. Inter- operability is provided through middleware on such a heterogeneous system. Common Object Request Broker Architecture (CORBA) is a standard for middleware-based distributed object computing systems. This paper focuses on analytic modeling of middleware-based systems that can be used in the performance engineering of CORBA-based client server applications. The paper applies the Layered Queuing Network model to two types of middleware architectures: handle-driven and forwarding. The model outputs are compared with measured values to determine the accuracy of the modeling technique.

Performance of publish/subscribe middleware in mobile wireless networks

Publish/subscribe middlewares are becoming popular for distributed applications because of their flexible and scalable nature. Anonymous and loosely-coupled communication between publisher and subscriber, along with the inherently asynchronous nature of these systems, help them adapt quickly to changing environments, making them a good choice for mobile cellular networks. This paper studies publish/subscribe middleware performance in such networks in detail. As a first step, the paper characterizes a popular implementation of publish/subscribe system for the mobile domain, studying and analyzing the effect of different mobility parameters, which to the best of our knowledge is the first experimental research on the performance behavior of publish/subscribe systems in a mobile wireless domain. As a second step the paper presents the design, implementation and evaluation of middleware level handoffs, a well known solution to extend publish/subscribe systems to a mobile domain, and identifies the performance concerns of such extensions. The results show that such handoff protocols involving two brokers are impractical from a performance perspective under highly dynamic and unreliable mobile wireless settings. The paper identifies the basic reason for the limitations of middleware level handoffs.