Statistical Performance Prediction for Multicore Applications Based on Scalability Characteristics

Parallel programs have traditionally been implemented on distributed systems using conventional programming languages, such as Fortran or C, plus a library with support for communication, such as, for instance, PVM [11]. Also, some effort has been put into developing parallel programming languages [13]. Usually, the different development platforms are compared as to application execution time or parallel efficiency. However, as pointed out in [4], when measuring the performance of a parallel application or programming tool, different metrics may need to be taken into consideration. The ease of construction of an application and the time a programmer spends to implement it may in some cases be more important than the final execution time. Working under this assumption, this work argues that the use of interpreted languages as a basis for parallel programming tools should be further investigated. As support for our argument, we show an example of use of an interpreted language in a classical application in parallel distributed programming, namely, that of detecting program termination. Two different algorithms for termination detection are implemented in Lua, an extension language developed at PUC-Rio [5].

A multitenant SaaS is a single codebase and run-time customizable application supporting multiple tenants and users. There is a huge demand for multitenant applications as it reduces total cost of ownership for both, service provider as well as consumers. However, Multitenant SaaS applications face fluctuating load problem due to variable tenants and users. Thus, managing resources becomes difficult. Traditionally, to overcome this issue, resources are managed and scaled using monolithic architecture which may lead to underutilization and over utilization of resources in cases of low load and high load respectively. Microservices architecture is a new exemplar for developing cloud SaaS applications as it has several advantages over monolithic. The paper aims to analyze the performance and scalability analysis of multitenant SaaS application using both microservices and monolithic architecture. Utility Booking application is developed for a case study. Scalability analysis is performed, and the performance of application using both approaches is compared using average response time and throughput. Results show that multitenant applications using microservices with large number of concurrent users outperforms monolithic approach and are resource efficient as microservice application scales dynamically based on varying load.

Chip Multithreading (CMT) processors promise to deliver higher performance by running more than one stream of instructions in parallel. To exploit CMT's capabilities, programmers have to parallelize their applications, which is not a trivial task. Transactional Memory (TM) is one of parallel programming models that aims at simplifying synchronization by raising the level of abstraction between semantic atomicity and the means by which that atomicity is achieved. TM is a promising programming model but there are still important challenges that must be addressed to make it more practical and efficient in mainstream parallel programming. The first challenge addressed in this dissertation is that of making the evaluation of TM proposals more solid with realistic TM benchmarks and being able to run the same benchmarks on different STM systems. We first introduce a benchmark suite, RMS-TM, a comprehensive benchmark suite to evaluate HTMs and STMs. RMS-TM consists of seven applications from the Recognition, Mining and Synthesis (RMS) domain that are representative of future workloads. RMS-TM features current TM research issues such as nesting and I/O inside transactions, while also providing various TM characteristics. Most STM systems are implemented as user-level libraries: the programmer is expected to manually instrument not only transaction boundaries, but also individual loads and stores within transactions. This library-based approach is increasingly tedious and error prone and also makes it difficult to make reliable performance comparisons. To enable an "apples-to-apples" performance comparison, we then develop a software layer that allows researchers to test the same applications with interchangeable STM back ends. The second challenge addressed is that of enhancing performance and scalability of TM applications running on aggressive multi-core/multi-threaded processors. Performance and scalability of current TM designs, in particular STM desings, do not always meet the programmer's expectation, especially at scale. To overcome this limitation, we propose a new STM design, STM2, based on an assisted execution model in which time-consuming TM operations are offloaded to auxiliary threads while application threads optimistically perform computation. Surprisingly, our results show that STM2 provides, on average, speedups between 1.8x and 5.2x over state-of-the-art STM systems. On the other hand, we notice that assisted-execution systems may show low processor utilization. To alleviate this problem and to increase the efficiency of STM2, we enriched STM2 with a runtime mechanism that automatically and adaptively detects application and auxiliary threads' computing demands and dynamically partition hardware resources between the pair through the hardware thread prioritization mechanism implemented in POWER machines. The third challenge is to define a notion of what it means for a TM program to be correctly synchronized. The current definition of transactional data race requires all transactions to be totally ordered "as if'' serialized by a global lock, which limits the scalability of TM designs. To remove this constraint, we first propose to relax the current definition of transactional data race to allow a higher level of concurrency. Based on this definition we propose the first practical race detection algorithm for C/C++ applications (TRADE) and implement the corresponding race detection tool. Then, we introduce a new definition of transactional data race that is more intuitive, transparent to the underlying TM implementation, can be used for a broad set of C/C++ TM programs. Based on this new definition, we proposed T-Rex, an efficient and scalable race detection tool for C/C++ TM applications. Using TRADE and T-Rex, we have discovered subtle transactional data races in widely-used STAMP applications which have not been reported in the past.

Web 2.0 applications have become ubiquitous over the past few years because they provide useful features such as a rich, responsive graphical user interface that supports interactive and dynamic content. Social networking websites, blogs, auctions, online banking, online shopping and video sharing websites are noteworthy examples of Web 2.0 applications. The market for public cloud service providers is growing rapidly, and cloud providers offer an ever-growing list of services. As a result, developers and researchers find it challenging when deciding which public cloud service to use for deploying, experimenting or testing Web 2.0 applications. This study compares the scalability and performance of a social-events calendar application on two Infrastructure as a Service (IaaS) cloud services – Amazon EC2 and HP Cloud. This study captures and compares metrics on three different instance configurations for each cloud service such as the number of concurrent users (load), as well as response time and throughput (performance). Additionally, the total price of the three different instance configurations for each cloud service is calculated and compared. This comparison of the scalability, performance and price metrics provides developers and researchers with an insight into the scalability and performance characteristics of the three instance configurations for each cloud service, which simplifies the process of determining which cloud service and instance configuration to use for deploying their Web 2.0 applications. This study uses CloudStone – an open-source, three-tier web application benchmarking tool that simulates Web 2.0 application activities – as a realistic workload generator and to capture the intended metrics. The comparison of the collected metrics indicates that all of the tested Amazon EC2 instance configurations provide better scalability and lower latency at a lower cost than the respective HP Cloud instance configurations; however, the tested HP Cloud instance configurations provide a greater storage capacity than the Amazon EC2 instance configurations, which is an important consideration for data-intensive Web 2.0 applications.

Many HPC and modern large graph processing applications belong to a class of scale-out applications, where the application dataset is partitioned and processed by a cluster of machines. Assessing the application scalability is one of the primary goals during such application implementation. Typically, in the design phase, programmers are limited by a small size cluster available for their experiments. Therefore, predictive modeling is required for the analysis of the application scalability and its performance in a larger cluster. While in an increased size cluster, each node will process a smaller portion of the original dataset, a higher communication volume between a larger number of nodes may cripple the application scalability and provide diminishing performance benefits. One of the main challenges is the analysis of bandwidth demands due to an increased communication volume in a larger size cluster. In this paper1, we introduce a novel regression-based approach to assess the scalability and performance of a distributed memory program for execution in a large-scale cluster. Our solution involves 1) a limited set of traditional experiments performed in a small size cluster and 2) an additional set of similar experiments performed with an “interconnect bandwidth throttling” tool, which exposes the bandwidth impact on the application performance. These measurements are used in creating an ensemble of analytical models for performance and scalability analysis. Using a linear regression approach, step by step, we incorporate into the model the following important parameters: i) the number of cluster nodes and application processes, ii) the dataset size, and iii) interconnect bandwidth. We demonstrate our solution, its power, and accuracy using a popular Graph500 benchmark, which implements a Breadth First Search algorithm on large, synthetically generated graphs. By utilizing measurements collected in a 32-node cluster, we are able to project the program performance in a large size cluster with hundreds of nodes. The proposed approach and derived models help to provide an early feedback to programmers on the scalability and efficiency of their solution.

This tutorial addresses how both the Object Management Group (OMG) specifications and the implementation choices made by middleware providers and application developers affect Common Object Request Broker Architecture (CORBA) application scalability. We will cover a range of scalability issues, starting with Object Request Broker (ORB) internals and working outward to full-scale applications, addressing issues such as connection management, Portable Object Adapter (POA) scalability features, multithreading, object lifecycle issues, object location, system configuration, maintenance, and management, and common application architectures. This tutorial is not language-centric and is useful to developers using Java, C++, or any other language to develop CORBA-based applications.

This tutorial addresses how both the Object Management Group (OMG) specifications and the implementation choices made by middleware providers and application developers affect Common Object Request Broker Architecture (CORBA) application scalability. We will cover a range of scalability issues, starting with Object Request Broker (ORB) internals and working outward to full-scale applications, addressing issues such as connection management, Portable Object Adapter (POA) scalability features, multithreading, object lifecycle issues, object location, system configuration, maintenance, and management, and common application architectures. This tutorial is not language-centric and is useful to developers using Java, C++, or any other language to develop CORBA-based applications.

While large-scale parallel/distributed simulations are rapidly becoming critical research modalities in academia and industry, their efficient and scalable implementations continue to present many challenges. A key challenge is that the dynamic and complex communication/coordination required by these applications (dependent on the state of the phenomenon being modeled) are determined by the specific numerical formulation, the domain decomposition and/or sub-domain refinement algorithms used, etc. and are known only at runtime. This paper presents Seine, a dynamic geometry-based shared-space interaction framework for scientific applications. The framework provides the flexibility of shared-space-based models and supports extremely dynamic communication/coordination patterns, while still enabling scalable implementations. The design and prototype implementation of Seine are presented. Seine complements and can be used in conjunction with existing parallel programming systems such as MPI and OpenMP. An experimental evaluation using an adaptive multi-block oil-reservoir simulation is used to demonstrate the performance and scalability of applications using Seine. Copyright © 2006 John Wiley & Sons, Ltd.

For an IaaS cloud, the primary task is to satisfy users' demands for resources. Besides, administrators also have to deal with problems such as how to optimize allocation and utilization of resources at the data center level, how to guarantee the application's performance and scalability and how to cut the costs of maintenance and management. This paper focuses on the runtime optimization of IaaS private clouds. In such an environment, administrators usually have more autonomy and control over cloud resources and applications, which brings more space for optimization. In order to achieve appropriate resource allocation for virtual machines and improve utilization, this paper first proposes WarMops: a workload-aware method to optimize the resource configuration of virtual machines and an allocation scheme based on resource reservation and sharing, in an effort to arrive at the proper size of resources to meet the real needs of virtual machines. Integrating the methods mentioned above, this paper puts forward a systematic framework and modules for the runtime optimization of cloud resource management. This paper uses a mainstream benchmark application in this field - RUBiS to test the framework which, in turn, verifies the correctness and validity of the schemes.

Currently, there are two approaches to implementing large-scale ice sheet simulations. One approach, which is based on the use of an evenly-spaced structured grid, is to simulate the entire ice sheet at the highest resolution required. The other approach is to model the ice sheet at different levels of resolution using unstructured meshes. Structured grids lend themselves quite well to partitioning on multi-core, distributed memory parallel computers, leading to good computational efficiency, load-balancing and reduced communication costs. The disadvantage is the significant computational resources required to model a system of this size at a high enough resolution to correctly model regions of the ice sheet undergoing rapid change. Unstructured meshes can reduce such costs by allocating more computational resources to areas of the ice sheet whose dynamics are evolving quickly and fewer resources to areas evolving more slowly. However, unstructured meshes do not easily lend themselves to effective decomposition on distributed memory parallel computers, and can experience poor cache utilization, significant load imbalance, high communication costs, and increased synchronization times. In this paper, we describe our alternative approach based on embedded simulation, which provides a degree of multi-resolution capabilities to structured grids while maintaining many of the computational efficiencies that come with the structured approach. We provide experimental results focusing on the scalability characteristics and cache efficiency of each approach as a function of increasing problem size and core counts. We show that the embedded approach scales very well across all problem sizes and core counts, and that the unstructured approach scales well at smaller problem sizes and core counts but degrades significantly as the problem size becomes large.

The paper describes an efficient communication support for the global address space programming model on the IBM SP, a commercial example of the SMP (symmetric multi-processor) clusters. Our approach integrates shared memory with active messages, threads and remote memory copy between nodes. The shared memory operations offer substantial performance improvement over LAPI, IBM one-sided communication library, within an SMP node. Based on the experiments with the SPLASH-2 LU benchmark and a molecular dynamics simulation, our multiprotocol support for the global address space is found to improve performance and scalability of applications. This approach could also be used in optimizing the MPI-2 one-sided communication on the SMP clusters.KeywordsShared MemoryRemote MemoryActive MessageGlobal ArrayMemory CopyThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

This work improves the performance of MPI collective communication operations in the presence of imbalanced process arrival times. High performance collective communications are crucial for the performance and scalability of applications, and imbalanced process arrival times are common in these applications. A micro-benchmark is used to investigate the nature of process imbalance with perfectly balanced workloads, and understand the nature of inter- versus intra-node imbalance. These insights are then used to develop imbalance-tolerant reduction, broadcast, and all-to-all algorithms, which minimize the synchronization delay observed by early arriving processes.

Future wireless sensor networks (WSNs) will transport high‐bandwidth, low‐latency streaming data, and will host sophisticated processing, such as image fusion and object tracking, in‐network on sensor network nodes. Recent middleware proposals provide capabilities for in‐network processing, reducing energy drain based on communication costs alone. However, hosting complex processing on WSN nodes incurs additional processing energy and latency costs that impact network lifetime and application performance. There is a need for a WSN planning framework to explore energy saving and application performance trade‐offs for models of future sensor networks that account for processing costs in addition to communication costs. In this work, we present a simulation framework to analyze the interplay between resource requirements for compute‐ and communication‐intensive in‐network processing for streaming applications. We simulate a surveillance application workload with middleware capabilities for data fusion, adaptive policy‐driven migration of data fusion computation across network nodes, and prefetching of streaming data inputs for fusion processing. Our study sheds light on application figures of merit such as latency, throughput, and lifetime with respect to migration policy and node CPU and radio characteristics. Copyright © 2005 John Wiley & Sons, Ltd.

Heterogeneity in secondary characteristics of different HPC target platforms is the focus of this paper. Clusters, grids, and (IaaS) clouds may appear straightforward to configure to be interchangeable - but our experiences with mainstream parallel codes for CFD demonstrate that secondary attributes - support software, interconnect type, availability, access, and cost - expose heterogeneous aspects that impact overall effectiveness of application execution. The emergence of clouds as alternatives to grids and local resources for parallel HPC codes portends computing as a in science and engineering domains. Our experiences provide preliminary insights into characterizing these different types of platforms to which users typically have access - and show where the tradeoffs can be, in terms of deployment effort, actual and nominal costs, application performance, and availability (both in terms of resource size and time to gain access). For our test application, we report that each of the platforms to which we had access had its particular benefits and drawbacks in terms of the above attributes. More generally, our experiences may provide an example preview into what developers and users can expect when selecting a utility provider and specific instance thereof for a particular run of their application.

In this paper, we propose a two-step fault-tolerant approach to address the faults occurred in cores. In the first stage, a Particle Swarm Optimization (PSO) based approach has been proposed for the fault-tolerant mapping of multiple applications on to the mesh based reconfigurable architecture by introducing spare cores and a heuristic has been proposed for the reconfiguration in the second stage. The proposed approach has been experimented by taking several benchmark applications into consideration. Communication cost comparisons have been carried out by taking the failed cores as user input and the experimental results show that our approach could get improvements in terms of communication cost after reconfiguration compared to before reconfiguration by providing fault-tolerance to the design.