In scenarios where users need to extract specific information from large video datasets, an efficient system is essential to filter the relevant segments. This helps in enhancing the overall search and retrieval experience. This paper presents a technique designed to manage large volumes of video data by efficiently identifying and extracting user-preferred content based on user defined criteria. The proposed system uses Natural Language Processing (NLP) to filter audio content and machine learning-based object detection to filter video content. This enables precise extraction based on both spoken dialogue and visual elements. The proposed system also addresses the challenge of time delays associated with analyzing large video datasets by employing advanced filtering methods that utilize parallel processing. This approach reduces the data volume thereby shortening the time required for users to locate specific information. The performance of the technique was assessed through a series of experiments conducted on a large video dataset. The experimental results demonstrate the effectiveness of the system in improving search efficiency within huge volumes of video data.

Boolean AND queries (BAQ) are one of the most important types of queries used in text searching. In this paper, a graph-based indexing technique is proposed to improve the search latency of BAQ. It shows how a graph structure represented using a hash table can reduce the number of intersections needed for the execution of BAQ. The performance of the proposed technique is compared with one of the most widely used index structures for textual documents called Inverted Index. A detailed performance analysis is performed through prototyping and measurement on a system subjected to a synthetic workload. To get further performance insights, the proposed graph-based indexing technique is also compared with an enterprise-level search engine called Elasticsearch which uses Inverted Index at its core. The analysis shows that the graph-based indexing technique can reduce the latency for executing BAQ significantly in comparison to the other techniques.

This paper introduces a new graph-based indexing (GBI) technique for big data systems. It uses a directed graph structure that effectively captures the simultaneous occurrence of multiple keywords in the same document. The objective is to use the relationship between the search keywords captured in the graph structure to effectively retrieve all results of Boolean AND queries at once. The performance of the proposed technique is compared with the conventional inverted index-based technique. This paper highlights that, irrespective of the intersection algorithm used to evaluate Boolean AND queries, GBI always returns Boolean AND search results faster than the inverted index. This is due to the fact that GBI always performs a smaller number of intersection operations and avoids intersection if search keywords do not have a common document. A preliminary performance analysis is performed through prototyping and measurement on a system subjected to a synthetic workload. The analysis shows that GBI improves search latency when executing Boolean AND queries by an average of 69% to 99.9% in comparison to the inverted index.

Big data has become essential for businesses as it enables companies and organizations to gather insights from their data and use it to determine marketing opportunities, assist decision-making or even to find new business opportunities. Companies spend a great deal of effort collecting large amounts of data, which in some cases must be processed in real-time in order to capitalize on business opportunities. Predicting the expected input load at a given point in time can be very difficult and sometimes impossible. As a result, a great deal of effort is put into creating techniques to address varying input loads. A widely used approach is dynamic resource provisioning, but resource provisioners may not react in time to address the resource shortage which can result in increased processing latencies. This paper presents a priority scheduling technique that can be used in conjunction with dynamic and static resource provisioning. This approach allows users to assign a priority to input data items. The scheduler ensures that higher priority data items are given precedence over lower priority data items. This means that when resources become constrained the higher priority data items receive a greater share of resources and experience lower queueing delays in comparison to low priority items. A prototype for the data driven priority scheduler is implemented on the Spark Streaming system.

The Internet of Things (IoT) technology presents a complex and challenging paradigm where a huge amount of noisy raw sensor data is collected in order to observe and detect critical events occurring on the system, and generate alarms when required. The biggest challenge of the IoT systems is that the systems collect a massive amount of uncertain data from diverse IoT devices connected through the network. In addition, some events are inferred from other events and uncertainty is propagated from parent events to the inferred events, which additionally contributes to overall system uncertainty. The observed complex events are a complex relationship of primitive events that are produced by IoT devices and collected in IoT systems. A survey performed on existing prior arts on quantifying uncertainty for complex events concluded that proposed existing solutions are unable to scale under heavy loads of incoming data. This paper presents a micro-service based notification methodology that uses complex event recognition (both complex event processing and probabilistic programming) to handle IoT systems uncertainty. In addition, the paper analyzes and recommends existing big data platforms for processing complex events in IoT systems. The current focus of our work includes research and development of the optimized deadline-based and cost-effective resource allocation algorithm in Apache Spark for Uncertain IoT Notification systems.

This paper focuses on priority based processing of streaming data. One of the greatest challenges in big data analytics is responding to a bursty input load. The common solutions are to use dynamic resource provisioning techniques, however, these techniques may not respond quickly enough to the change in the load. Another option is to overprovision, but this results in wasted computing resources. This paper describes a technique that can be used in cases where resources are statically provisioned. This technique enables users to prioritize certain input data items so that in cases where the load suddenly increases, the high priority items are given precedence over low priority items. This technique is implemented on the Spark Streaming engine.

A multitenant Storm cluster runs multiple stream processing applications and uses the default Isolation Scheduler to schedule them. Isolation Scheduler assigns resources to topologies based on static resource configuration and does not provide any means for prioritizing topologies based on their varying business requirements. Thus, performance degradation, even complete starvation of topologies with high priority is possible when the cluster is resource constrained and comprises an inadequate number of resources. Two priority based resource scheduling techniques are proposed to overcome these problems. A performance analysis based on prototyping and measurements demonstrates the effectiveness of the proposed techniques.

In our previous work, we described a resource allocation and scheduling technique for processing an open stream of MapReduce jobs with SLAs (characterized by an earliest start time, an execution time, and a deadline) called the Hadoop Constraint Programming based Resource Management technique (HCP-RM). Since the user-estimated job execution times are used to perform resource allocation and scheduling, error/inaccuracies in the execution times can hinder the ability of HCP-RM from making effective scheduling decisions, leading to a degradation in system performance. This paper focuses on improving the robustness of HCP-RM by introducing a mechanism to handle errors/inaccuracies in user estimates of job execution times that are submitted as part of the job's SLA. A Prescheduling Error Handling technique (PSEH) is devised to adjust the user-estimated execution times of the jobs to make them more accurate before they are used by the resource management algorithm. Results of experiments conducted on a Hadoop cluster deployed on Amazon EC2 demonstrate the effectiveness of the PSEH technique in improving system performance.

Resource allocation and scheduling on clouds are required to harness the power of the underlying resource pool such that the service provider can meet the quality of service requirements of users, which are often captured in service level agreements (SLAs). This paper focuses on resource allocation and scheduling on clouds and clusters that process MapReduce jobs with SLAs. The resource allocation and scheduling problem is modelled as an optimization problem using constraint programming, and a novel MapReduce Constraint Programming based Resource Management algorithm (MRCP-RM) is devised that can effectively process an open stream of MapReduce jobs where each job is characterized by an SLA comprising an earliest start time, a required execution time, and an end-to-end deadline. A detailed performance evaluation of MRCP-RM is conducted for an open system subjected to a stream of job arrivals using both simulation and experimentation on a real system. The experiments on a real system are performed on a Hadoop cluster (deployed on Amazon EC2) that runs our new Hadoop Constraint Programming based Resource Management algorithm (HCP-RM) that incorporates a technique for handling data locality. The results of the performance evaluation demonstrate the effectiveness of MRCP-RM/HCP-RM in generating a schedule that leads to a low proportion of jobs missing their deadlines (P) and also provide insights into system behaviour and performance. In the simulation experiments, it is observed that MRCP-RM achieves on average an 82 percent lower P compared to a technique from the existing literature when processing a synthetic workload from Facebook. Furthermore, in the experiments performed on a Hadoop cluster deployed on Amazon EC2, it is observed that HCP-RM achieved on average a 63 percent lower P compared to an EDF-Scheduler for a wide variety of workload and system parameters experimented with.

This paper focuses on devising a configurable resource management technique for use in clouds for processing batches of MapReduce jobs associated with Service Level Agreements (SLAs). The proposed technique permits cloud service providers to make resource management decisions which consider client quality of service requirements, system performance, and energy consumption which directly affects data center operation costs. This research models the resource management problem as an optimization problem using Constraint Programming (CP). A simulation-based performance analysis that demonstrates the effectiveness of the approach is provided.

This paper describes a cloud-based platform, called RP-SMARF, for supporting research collaboration in the area of smart facilities management. More precisely, the proposed system delivers sophisticated domain-specific services to users by linking together disparate privately-owned elements such as data repositories, specialized hardware resources and specialized software applications into a unified framework. This allows research collaborators within a knowledge domain to easily run complex applications developed by researchers within the domain on complex datasets. Both batch-type processing as well as interactive application access are supported by the platform. The processing of live data streams generated in one site by an application residing in another site can also be performed. An authorization framework allows element owners to precisely control which users can access various elements. RP-SMARF unifies geographically dispersed heterogeneous resources for research collaborators. This simplifies making software created by researchers more usable by other researchers thereby making many researchers more productive.

This paper presents a novel technique for auto-scaling cloud resources provided by an intermediary enterprise which services requests from a client enterprise. The intermediary enterprise acquires resources on demand from a public cloud. A broker is deployed by the intermediary enterprise to handle client requests with service level agreements (SLAs). A reactive auto-scaling algorithm is activated on request arrival and achieves auto-scaling by acquiring new resources for serving the recently arrived request. The technique ensures that a grade of service specified by the client enterprise is satisfied and is based on a profit analysis for the intermediary enterprise. A resources is released after the last request allocated on the resource has completed execution. The paper demonstrates that the proposed reactive auto-scaling technique can effectively lead to a profit for the intermediary enterprise as well as a reduction of cost for the client enterprise.

A significant proportion of the operational cost for datacenters is attributed to their energy consumption. Using advanced virtualization techniques in datacenters is enabling the control of electricity use in servers. However, as servers are becoming more energy-proportional, datacenter networks are starting to consume a greater portion of overall power although networks devices often remain under-utilized. This paper proposes an energy aware management technique for reducing the consumption of energy by the network for a Spine-Leaf topology-based datacenter. The main idea of the system is to keep track of the dynamic workload and enable only switches that are necessary for handling the current network traffic. We have developed an energy aware management system for dynamically controlling the number of Spine switches in Spine-Leaf datacenter networks and performed simulation using CloudSim for a number of scenarios. The simulation results show that the system can work effectively to save energy by as much as 63% of the energy consumed by a datacenter comprising a fixed static set of Spine switches.

This paper focuses research focuses on automatic provisioning of cloud resources performed by an intermediary enterprise that provides a virtual private cloud for a single client enterprise by using resources from a public cloud. This paper concerns auto-scaling techniques for dynamically controlling the number of resources used by the client enterprise. We focus on proactive auto-scaling that is based on predictions of future workload based on the past workload. The primary goal of the auto-scaling techniques is to achieve a profit for the intermediary enterprise while maintaining a desired grade of service for the client enterprise. The technique supports both on demand requests and requests with service level agreements (SLAs). This paper presents an auto-scaling algorithm and includes a discussion of system design and implementation experience for a prototype system that implements the technique. A detailed performance analysis based on measurements made on the prototype is presented.

A novel MapReduce constraint programming based matchmaking and scheduling algorithm (MRCP) that can handle MapReduce jobs with deadlines and achieve high system performance is devised. The MRCP algorithm is incorporated into Hadoop, which is a widely used open source implementation of the MapReduce programming model, as a new scheduler called the CP-Scheduler. This paper originates from the collaborative research with our industrial partner concerning the engineering of resource management middleware for high performance. It describes our experiences and the challenges that we encountered in designing and implementing the prototype CP-based Hadoop scheduler. A detailed performance evaluation of the CP-Scheduler is conducted on Amazon EC2 to determine the CP-Scheduler's effectiveness as well as to obtain insights into system behaviour and performance. In addition, the CP-Scheduler's performance is also compared with an earliest deadline first (EDF) Hadoop scheduler, which is implemented by extending Hadoop's default FIFO scheduler. The experimental results demonstrate the effectiveness of the CP-Scheduler's ability to handle an open stream of MapReduce jobs with deadlines in a Hadoop cluster.

This paper concerns dynamic provisioning of cloud resources performed by an intermediary enterprise that provides a private cloud (also referred to as a virtual private cloud) for a single client enterprise using resources acquired on demand from a public cloud. A new proactive technique for auto-scaling of resources that changes the number of resources for the private cloud dynamically based on system load is proposed. The technique that supports both on-demand and advance reservation requests uses machine learning to predict future workload based on past workload. Experimental results demonstrate that the proposed technique can effectively lead to a profit for the intermediary enterprise as well as a reduction of cost for the client enterprise.

Clouds that are rapidly gaining in popularity require an effective resource manager that can harness the power of the underlying resource pool, and provide resources on demand to its users. This paper focuses on resource management on clouds for workflow requests characterized by Service Level Agreements (SLAs). Specifically, we devise a novel MapReduce constraint programming based resource manager (MRCP-RM) that can effectively perform matchmaking and scheduling of MapReduce jobs, each characterized by an SLA comprising an earliest start time, execution time, and an end-to-end deadline. Using discrete event simulation a performance evaluation of MRCP-RM is conducted for an open system subjected to a stream of job arrivals. The simulation results demonstrate the effectiveness of the resource manager and provide insights into system behaviour and performance.

This paper focuses on devising efficient resource management techniques used by the resource management middleware in clouds that handle MapReduce jobs with end-to-end service level agreements (SLAs) comprising an earliest start time, execution time, and a deadline. This research and development work, performed in collaboration with our industrial partner, presents the formulation of the matchmaking and scheduling problem for MapReduce jobs as an optimization problem using: Mixed Integer Linear Programming (MILP) and Constraint Programming (CP) techniques. In addition to the formulations devised, our experience in implementing the MILP and CP models using various open source as well as commercial software packages is described. Furthermore, a performance evaluation of the different approaches used to implement the formulations is conducted using a variety of different workloads.

A private cloud is maintained by an enterprise forits internal use. In such a scenario instead of buying the resources the enterprise can acquire the resources from a public cloud such as the ones provided by Amazon and Microsoft. On conventional systems rigorous analysis of the system and its workload is performed for determining the appropriate number of resources to be deployed on the private cloud. This paper presents a middleware framework that avoids this step of a priori capacity analysis and allows such private cloud owners to provision resources automatically such that a specified grade of service is maintained. The proposed framework performs dynamic resource provisioning that also leads to a reduction of operational cost. Additional resources are acquired during high traffic periods and released during low traffic periods such that the desired grade of service is always maintained. The paper describes the architecture of the framework and the experience gained from a prototype implementation including a preliminary analysis of its performance.

This paper proposed a Distributed Address Resolution Protocol (DARP) for large layer 2 networks used in a data center. As data centers continue to grow in size, there is an increased amount of overhead required to resolve network addresses using the traditional Address Resolution Protocol (ARP). The DARP attempts to reduce this overhead for large data centers with thousands of nodes and allow for the resolution of network address with minimal strain on the underlying network infrastructure. By using Distributed Hash Tables (DHTs) as the core data structure technology to maintain address records, we attempt to create a decentralized and reliable service that trades the sporadic overhead associated with current approaches with a consistent and predictable overhead. To determine the viability of the protocol, a series of simulations were developed and run via the OPNET Modeler software package. The simulation results demonstrate that DARP outperforms ARP by reducing the number of messages. Data centersaddress resolution protocoldistributed hash tables.

The paper concerns a wireless sensor network (WSN) hosting multiple applications. The applications vary in terms of their resource requirements such as the number of sensors required by the applications and the location of the required sensors relative to a sink node. The requests for the various applications need to be scheduled in a manner so as to reduce the overall mean response time to the users of the applications. In this research, simulation experiments demonstrate that system performance is greatly improved by using knowledge of system and application characteristics in scheduling multiple applications in a WSN as compared to scheduling based on knowledge free First Come First Served algorithm.

A sensor grid is an integration of two technologies: wireless sensor networks and the grid. The sensors deployed in a WSN monitor a phenomenon of interest. The information gained from the WSN is processed in the grid and is used by the users of applications. Multipurpose WSNs have become very popular where the deployed WSNs support more than one application. The research in this extended abstract focuses on WSNs supporting multiple applications. In this work, we focus on allocation, which is a process of determining the sensor nodes that will be selected for executing the requests corresponding to an application. Scheduling, which determines the order in which the application requests submitted to the WSN are executed is performed to improve the mean response time to the users of the applications. Our previous works propose various scheduling algorithms for WSNs hosting multiple applications. In this research, various static and dynamic allocation algorithms are proposed with an attempt to balance the energy consumption amongst the sensor nodes and hence improve the network lifetime of the WSN. Network lifetime is the time when the energy of any sensor node in the WSN falls below a predefined threshold. The proposed algorithms use varying degree of information about the energy consumption at the major energy consuming components of the sensor nodes: the CPU component and the radio component. Simulation experiments are performed to evaluate the performance of the proposed algorithms. This extended abstract presents the preliminary results obtained from the experimentation done so far. The simulation experiments demonstrate that by performing dynamic allocation and by using information about the total energy consumption at the sensor nodes, the lifetime of the WSN can be significantly improved.

Sending documents containing sensitive information is commonly performed on distributed systems. To protect the sensitive data in the documents, these documents need to be transmitted over a secure channel. However, secure communications can often increase the data transmission time due to the CPU-intensive operations (e.g. encryption/decryption) that need to be applied to the data before the data transfer. This paper focuses on a performance optimization technique called security sieve, which aims to enhance the performance of SSL/TLS-based data transmission. Security sieve reduces the transmission time of transferring classified documents, which may also contain non-sensitive data, by minimizing the time spent performing the CPU-intensive security-related operations. This paper focuses on highlighting the performance optimization principles/performance patterns that were used and includes a discussion of a prototype implementation. In addition, experimental results are presented to demonstrate the performance enhancement provided by security sieve.

Clouds and grids are distributed resource infrastructures that are subjected to both On Demand (OD) as well as Advance reservation (AR) requests. This paper focuses on the revenue that can be earned on cloud and grid systems using different matchmaking strategies that map requests to resources. Existing research on matchmaking uses a priori knowledge of the local scheduling policy used at the resources. However, in these dynamic and heterogeneous systems having detailed a priori knowledge about all the resources is not always feasible. Thus, traditional matchmaking strategies cannot use the resources for which the local scheduling policies are unknown. This paper discusses how a novel matchmaking strategy that does not use knowledge of the local scheduling policies used at the resources may be deployed in order to utilize these un-used resources and improve the revenue earned by the service providing enterprise. Based on analytic bounds and simulation, insights gained into system behaviour and revenue earned are presented.

Wireless Sensor Networks (WSN) consist of sensors that may serve a single application or multiple applications. Effective resource management is important when multiple applications share a WSN. In this research, a number of scheduling algorithms that use varying degrees of knowledge about system and application characteristics are proposed. Simulation results show how scheduling can be made more effective by making use of knowledge about the characteristics of an application, and the network topology. Results of simulation experiments demonstrate that deployment of scheduling algorithms at a proxy that leads to energy savings at the sensors can still give rise to a performance comparable to a system on which scheduling is performed at the individual sensors.

Security in a distributed system often comes at the cost of a performance penalty. Due to the CPU time consuming security algorithms used, transferring data using SSL is known to be significantly slow. This paper presents an initial set of research results of a university-industry collaborative research focusing on a performance enhancement technique called security sieve that separates the classified and non-classified components in a document and sends these on a secure and a (faster) non-secure channel respectively. Experimental results presented in the paper demonstrate the effectiveness of the technique.

In publish/subscribe systems, XML message filtering performed at application layer is an important operation for XML message multicast. As a specific case of content-based multicast in application layer, XML message multicast depends on the data filtering and matching processes and the forwarding and routing schemes. As the XML data emerges in transition, XML message filtering and matching becomes more and more desirable. BFilter, proposed in this paper, conducts the XML message filtering and matching by leveraging branch points in both the XML document and user query. It evaluates user queries that use backward matching branch points to delay further matching processes until branch points match in the XML document and user query. In this way, XML message filtering can be performed more efficiently as the probability of mismatching is reduced. A number of experiments have been conducted and the results demonstrate that BFilter has better performance than the well-known YFilter for complex queries.

Exact knowledge of the scheduling policy used at every resource on a dynamic heterogeneous environment such as a cloud and a grid deploying a variety of different resources is unlikely to be available. This paper describes techniques for determining whether or not a set of advance reservation requests can meet their deadlines when the details of the scheduling policy deployed at the resource is unknown. A discussion of the techniques including a simulation-based performance analysis is presented.

An XML publish/subscribe system is based on filtering XML message streams for a large number of subscriptions expressed in XPath. A major issue on an XML-based publish/subscribe system is its performance. As the number of XML documents and XPath-based subscriptions increases in the system, to provide XML filtering efficiently becomes a challenging problem. Hence, there is an urgent need for optimization techniques to meet this challenge. There are many existing approaches on designing efficient XML filtering engine. Most existing research efforts focus on efficient filtering algorithms for achieving a high system performance or supporting more complex XPath syntax. Each proposed scheme has its advantages and limitations. Not much research, however, has considered using caching in the context of XML filtering. In this paper, we propose two caching schemes to be used in conjunction with an XML filtering engine. First, we present a complete message caching algorithm that is a strict caching policy to reduce the computation cost that accrues from multiple filtering of the same messages, by reusing results of previously processed messages. Second, we investigate a structure-based caching method that is an approximate caching policy for messages sharing the same structure. Performance evaluation for synthetic data and real data both show that complete message caching and structure-based caching schemes are able to achieve significantly better filtering performance (up to 80% for both caching schemes for the message streams experimented with).

Web services are getting popular in the domain of business to business electronic commerce and in automating information exchange between business processes because of the interoperability they provide in a distributed heterogeneous environment. Most existing systems use web services that are hosted in fixed infrastructures. Hosting web services on wireless mobile devices is challenging because of their limited resources. The few efforts made by researchers in the past are effective only for hosting of simple web service (WS) applications. However, the existing techniques are not adequate for hosting of WS applications that involve large and complex business processes or invoked by multiple concurrent WS clients. This research proposes to use an application partitioning approach so that the execution of some parts (partitions) of a WS application can be offloaded to a powerful computing node. A critical analysis of existing partitioning approaches for traditional and mobile applications is presented and a graph theory based algorithm for WS application partitioning is proposed. A performance analysis of the algorithm is made through prototyping and measurements.

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.

Providing QoS guarantees to the applications in a multi-institutional grid is a challenging task. Although advance reservations (ARs) can provide QoS guarantees for the applications, they often seriously degrade system performance for resource owners. In this paper, we present a framework for AR based resource sharing that not only provides QoS guarantees for the applications but also ensures high utilization of the resources. This paper focuses on the application-to-resource mapping component of the framework as our results show that traditional mapping algorithms used with best effort jobs do not perform well for ARs. The paper proposes a set of algorithms for mapping ARs and investigates their performance in detail. The paper then presents a novel algorithm that outperforms a number of other algorithms in almost every respect for a wide range of workload parameters. Rigorous experimentation proves the efficacy of our algorithm and brings important insights into the dynamics of the system

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

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.

Inter-operability in heterogeneous distributed systems is often provided with the help of CORBA compliant middleware. Many distributed object computing systems, however, are characterized by limited heterogeneity. Such systems often contain a subset of components that are written in the same programming language and run on top of the same p-Worm. We present engineering techniques that exploit such limited heterogeneity in systems for achieving high system performance. With these techniques components implemented using diverse programming languages and/or platform use a CORBA compliant middleware, whereas the similar components can use a "flyover" that employs a separate path between the client and its server and avoids a number of CORBA overheads. Insights into system behavior and performance gained from results of experiments with synthetic workload running on a network of PCs are presented.

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.

Techniques for scheduling parallel I/O for both uniprogrammed systems that run single jobs in isolation and multiprogrammed environments that execute multiple parallel jobs simultaneously are presented. The performance of the scheduling algorithms is evaluated on a network of workstations. A new scheduling algorithm proposed in this paper is observed to perform very well for systems running single jobs in isolation. The algorithms that use knowledge of job characteristics are observed to produce a superior performance in multiprogrammed parallel environments.

Requirements for interoperability and reusability motivate the use of object oriented middleware like the Common Object Request Broker Architecture (CORBA). However, unless CORBA can be implemented efficiently, it will not be widely used in real time and other latency-sensitive distributed applications. The paper presents three performance enhancement techniques for CORBA based middleware. Two of these exploit limited heterogeneity in systems. In such a system a standard CORBA protocol is used when clients and servers interacting with one another are implemented by using different programming languages and/or operating systems. However, when a similar client-server pair built using the same technology communicates, a number of CORBA operations are bypassed, thus reducing the communication overhead. Based on a commercial middleware product and measurements made on a performance prototype running on a network of workstations, this research demonstrates that there is a strong potential for achieving a significant performance improvement by incorporating these techniques into the middleware.

With increasing bandwidth available to the client and the number of users growing at an exponential rate the Web server can become a performance bottleneck. This paper considers the parallelization of requests to Web pages each of which is composed of a number of embedded objects. The performance of systems in which the embedded objects are distributed across multiple backend servers are analyzed. Parallelization of Web requests gives rise to a significant improvement in performance. Replication of servers is observed to be beneficial especially when the embedded objects in a Web page are not evenly distributed across servers. Load balancing policies used by the dispatcher of Web page requests are investigated. A simple round robin policy for backend server selection gives a better performance compared to the default random policy used by the Apache server.

Multiple processes may contend for shared resources such as variables stored in the shared memory of a multiprocessor system. Mechanisms required to preserve data consistency on such systems often lead do a decrease in system performance. This research focuses on controlling shared resource contention for achieving high capacity and scalability in multiprocessor based applications that include telephone switches and real time databases. Both reengineering of existing code as well as appropriate scheduling of the processes are two viable methods for controlling memory contention. Emphasis is placed on the second approach. Based on analytic models, three different scheduling approaches are compared. The numerical results obtained from the model provide insights into system behavior and highlight the important attributes of each strategy. A hybrid approach that combines the good attributes of a number of these strategies is proposed and analyzed. The results of this research are useful mainly to designers of software for multiprocessor based telecommunication and other embedded systems.

Middleware provides inter-operability and transparent location of servers in a heterogeneous distributed environment. A careful design of the middleware software is required however for achieving high performance. This research proposes an adaptive middleware architecture for CORBA-based systems. The adaptive middleware agent that maps an object name to the object reference has two modes of operations. In the handle-driven mode it returns a reference for the requested object to the client that uses this reference to re-send the request for the desired operation to the server whereas in the forwarding mode it forwards the entire client request to the server. The server upon invocation performs the desired operation and returns the results to the client. An adaptive ORB dynamically switches between these two modes depending on the current system load. Using a commercial middleware product called Orbix-MT we have implemented a skeletal performance prototype for the adaptive ORB. Based on measurements made on a network of workstations and a synthetic workload we observe that the adaptive ORB can produce a substantial benefit in performance in comparison to a pure handle-driven or a pure forwarding ORB. Our measurements provide valuable insights into system behavior and performance.

No abstract available.

Middleware promotes interoperability as well as provides transparent location of servers in heterogeneous client-server environments. Although a number of benefits are provided by middleware, careful consideration of system architecture is required to achieve high performance. Based on implementation and measurements made on a network of workstations running a commercial CORBA compliant ORB called ORBeline the paper is concerned with the impact of client-agent-server interaction architecture on performance. The paper reports on the relative performances of three interaction architectures under different workload conditions. In particular the impact of inter-node delays, message size, and request service times on the latency and scalability attributes of these architectures is analyzed. A method called agent cloning and how it can be used for improving system performance are described.

Scheduling on client-server systems has not received much attention from researchers. Based on simulation this research presents a number of insights into system behavior and scheduling. Two phenomena, CPU monopolization by large service requests and software bottlenecking are observed to have a strong influence on system performance. Software bottlenecking is a new phenomenon, observed on distributed client server systems with multiple levels of servers and occurs when a higher level server is blocked waiting for a response to a service request from a lower level server. Policies based on request characteristics such as service times and path lengths are found to effectively control these effects and improve system performance.

No abstract available.

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.>

Software bottlenecks are performance constraints caused by slow execution of a software task, in typical client-server systems a client task must wait in a blocked state for the server task to respond to its requests, so a saturated server will slow down all its clients. A rendezvous network generalizes this relationship to multiple layers of servers with send-and-wait interactions (rendezvous), a two-phase model of task behavior, and to a unified model for hardware and software contention. Software bottlenecks have different symptoms, different behavior when the system is altered, and a different cure from the conventional bottlenecks seen in queueing network models of computer systems, caused by hardware limits. The differences are due to the "push-back" effect of the rendezvous, which spreads the saturation of a server to its clients. The paper describes software bottlenecks by examples, gives a definition, shows how they can be located and alleviated, and gives a method for estimating the performance benefit to be obtained. Ultimately, if all the software bottlenecks can be removed, the performance limit will be due to a conventional hardware bottleneck.>

To use queuing theory to analyze real systems such as computer communications networks, one makes assumptions that are, strictly speaking, untrue. The authors provide an exact analysis for cases with greatly relaxed assumptions. Service times can have general increasing failure rate distributions, different by class even at FIFO nodes. Routing can be arbitrary, including dependencies along the route, provided the number of visits to each node is a random variable. Only the mean service time and mean visit rates at nodes need be specified. A lower throughput bound is found which gives a minimum guaranteed throughput for each class; together with the familiar multiclass asymptotic upper bounds they give a convex feasible region in a multidimensional throughput space. A detailed analysis is given for systems with FIFO and infinite-server nodes, and the extension to processor-sharing nodes is described. The results can be reinterpreted as a set of bounds on the separate throughputs. This is equivalent to a circumscribed rectangular region called the robust box bounds.>

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.

Recent research has demonstrated the existence of locality in short-term file referencing behaviour. A detailed study of the dynamic characteristics of file referencing is presented in this paper. The concept of Bounded Locality Intervals from the field of program behaviour has been used to model the locality phases of file referencing behaviour. The model is found to be powerful both from a descriptive point of view and from the perspective of understanding the performance implications of locality properties of file referencing behaviour on file system management.

Although the phenomenon of locality has long been recognized as the single most important characteristic of program behaviour, relatively little work has been done in attempting to measure it. Recent work has led to the development of an intrinsic measure of program locality based on the Bradford-Zipf distribution. Potential applications for such a measure are many, and include the evaluation of program restructuring methods (manual and automatic), the prediction of system performance, the validation of program behaviour models, and the enhanced understanding of the phenomena that characterize program behaviour. A consideration of each of these areas is given in connection with the proposed measure, both to increase confidence in the validity of the measure and to illustrate a methodology for dealing with such problems.