Dheeraj Chahal

DESiDE: Discrete Event Simulation Developers Environment

Performance prediction of an application early in its Systems Development Life Cycle (SDLC) is essential due to stringent application performance Service Level Agreements (SLAs). Accurate sizing during requirement analysis phase helps in meeting application SLAs and also in reducing expensive performance tuning efforts, hardware upgrades and redesign after the application has been developed and migrated to production environment. There is growing need to use scientific and accurate application performance prediction techniques to reduce cost and increase profitability. We present our tool called DESiDE that uses systematic profiling of components of previously developed applications to accurately size infrastructure for new application during requirement or design phase using discrete event simulation.

PROWL: Towards Predicting the Runtime of Batch Workloads

Many applications in the enterprise domain require batch processing to perform business critical operations. Batch jobs perform automated, complex processing of large volumes of data without human intervention. Parallel processing allows multiple batch jobs to run concurrently to minimize the total completion time. However, this may result in one or more jobs exceeding their individual completion deadline due to resource sharing. The objective of this work is to predict the completion time of a batch job when it is running in conjunction with other batch jobs. Batch jobs may be multi-threaded and threads can have distinct CPU requirements. Our predictions are based on a simulation model using the service demand (total CPU time required) of each thread in the job. Moreover, for multi-threaded jobs, we simulate the server with instantaneous CPU utilization of each job in the small intervals instead of aggregate value while predicting the completion time. In this paper, a simulation based method is presented to predict the completion time of each batch job in a concurrent run of multiple jobs. A validation study with synthetic benchmark FIO shows that the job completion time prediction error is less than 15% in the worst case.

Performance Extrapolation of IO Intensive Workloads: Work in Progress

Performance prediction of an application before migrating from a source system and deploying on the target system is a challenging but important task. In this paper, we present a method for predicting the performance of an IO intensive multithreaded enterprise application workload on target systems connected to advanced storage devices. Our approach is an extension of well-known trace and replay method. We extract traces of IO intensive enterprise workloads representing temporal and spatial characteristics (e.g. read and write requests) on the source system where application is currently deployed. These traces are replayed on the system of interest called target system. The experimental results presented demonstrate the effectiveness and accuracy of this method.

Predicting the Runtime of Memory Intensive Batch Workloads

Data centers use their non-peak business hours to run batch jobs in order to maximize the resource utilization. Large data centers may run thousands of batch jobs every day. These jobs typically process large volumes of data and can either be compute or memory intensive. Batch jobs may perform data reconciliation, risk analysis, and carry out analytics that are critical for the business. Hence, it is imperative that these jobs complete within the available time frame. New servers with large number of core and Non-Uniform Memory Access (NUMA) architecture provide very large compute capacity. This means that many batch jobs can be run concurrently to minimize their collective completion time. However, excessive parallelism may create memory access bottleneck and adversely affect the completion time. The objective of this work is to predict the completion time of concurrently running batch jobs. We assume each job to be multithreaded and memory intensive. A prediction model based on memory and CPU contention is proposed. Our predictions are based on server simulation that uses individual batch job data to predict the completion time of concurrently running jobs. The efficacy of our approach is validated using STREAM, a well-known open source synthetic benchmark. We also study the effect of hyper-threading and memory binding on prediction accuracy of our model.

PerfExt++: Performance Extrapolation of IO Intensive Workloads

We present a tool, PerfExt++, for cross platform performance extrapolation of IO intensive workloads. The tool is based on trace and replay mechanism and has the capability to record and replay the temporal and spatial characteristics of IO workloads. We show the design and implementation of PerfExt++, which requires minimal intervention from the user to predict and extrapolate performance metrics across platforms.

Cloning IO Intensive Workloads Using Synthetic Benchmark

Performance evaluation of an enterprise application on multiple storage systems of interest called target systems, is a time consuming and costly process. Moreover, it is increasingly challenging to predict the performance at higher concurrencies (no. of users) on target systems when the application is migrated from the low performance source system where the application is currently deployed. In this paper, we present a methodology to generate equivalent synthetic benchmark workloads for IO intensive applications. These synthetic benchmarks are easy to deploy and recreate the application behavior faithfully. We essentially extract the temporal and spatial characteristics of the application workload traces on the source system and replay those characteristics using synthetic benchmark on the target system. Also, we extrapolate these characteristics to predict the performance at higher concurrencies using synthetic benchmark without generating traces for those concurrencies. To verify the efficacy of our methodology, we have tested our approach successfully using two different types of workloads namely TPCC and JPetStore. We present our extrapolation results on the target storage system with an error bound of less than 20% for concurrencies up to an order of the magnitude of the source system.

PABS 2015: 1st Workshop on Performance Analysis of Big Data Systems

The first ACM international workshop on performance analysis of big data system is held in Austin, Texas, USA on February 1, 2015 and co-located with the ACM fifth International Conference on Performance Engineering (ICPE). The main objective of the workshop is to discuss the performance challenges imposed by big data systems and the different state-of-the-art solutions proposed to overcome these challenges. The workshop aims at providing a platform for scientific researchers, academicians and practitioners to discuss techniques, models, benchmarks, tools and experiences while dealing with performance issues in big data systems. We have constructed an exciting program of one big data expert keynote talk, one invited talk and two refereed papers that will give participants a full dose of emerging research.