Sanjeev K. Aggarwal

A Fault Tolerance Scheme for Hierarchical Dynamic Schedulers in Grids

In dynamic grid environment failures (e.g. link down, resource failures) are frequent. We present a fault tolerance scheme for hierarchical dynamic scheduler (HDS) for grid workflow applications. In HDS all resources are arranged in a hierarchy tree and each resource acts as a scheduler. The fault tolerance scheme is fully distributed and is responsible for maintaining the hierarchy tree in the presence of failures. Our fault tolerance scheme handles root failures specially, which avoids root becoming single point of failure. The resources detecting failures are responsible for taking appropriate actions. Our fault tolerance scheme uses randomization to get rid of multiple simultaneous failures. Our simulation results show that the recovery process is fast and the failures affect minimally to the scheduling process.

Inferring grammar rules of programming language dialects

In this paper we address the problem of grammatical inference in the programming language domain. The grammar of a programming language is an important asset because it is used in developing many software engineering tools. Sometimes, grammars of languages are not available and have to be inferred from the source code; especially in the case of programming language dialects. We propose an approach for inferring the grammar of a programming language when an incomplete grammar along with a set of correct programs is given as input. The approach infers a set of grammar rules such that the addition of these rules makes the initial grammar complete. A grammar is complete if it parses all the input programs successfully. We also proposes a rule evaluation order, i.e. an order in which the rules are evaluated for correctness. A set of rules are correct if their addition makes the grammar complete. Experiments show that the proposed rule evaluation order improves the process of grammar inference.

Technique for extracting keyword based rules from a set of programs

We present a novel technique for extracting a grammar from a set of programs. A grammar is important for generating software analysis and modification tools. Most legacy applications are written in languages, which are minor variations (dialects) of the standard language. Normally, we have a grammar of the standard language, but the grammars of dialects are unavailable. In this paper we propose an iterative technique with backtracking for grammar extraction. Our technique extracts keyword based rules. This uses the CYK parsing algorithm and the LR error recovery technique for finding out new production rules. In each iteration a set of possible rules is built and one rule from them is selected. Finally, we get a grammar, which parses all programs in the set.

Modeling and Verifying Non-DAG Workflows for Computational Grids

The advent of grid technology has provided a promising methodology for usage of distributed resources for complex scientific workflow applications. Grid workflow management systems (GWMS) enable even a non-expert grid user to compose workflows and further provide functionality to coordinate execution of the complete workflow thereby masking the grid-specific details from the user. We have designed a non- DAG workflow specification model for workflow composition. Our model allows a user to compose a workflow using directed graphs, thereby allowing modeling of sequence, parallel, choice and iteration patterns in the workflow. We have also provided for structural verification of workflows using Petri net based analysis techniques. A workflow is said to be structurally correct if it does not have errors like deadlock and lack of synchronization. A workflow found correct by structural verification techniques can be executed correctly for all possible workflow instances. We have incorporated our workflow model into a previously existing workflow management system for Sun grid engine [1]. Experiments show that the model allows for composition of wider range of workflow applications. Also the verification procedure provides appropriate error messages to user, indicating the nature and cause of error, when a structural error is detected. We have composed and executed the workflow of EMAN [2], a real-world bio-informatics application. The experimentation results show the efficient utilization of compute power of the grid by the inherent parallel tasks in the EMAN workflow.

A deterministic technique for extracting keyword based grammar rules from programs

This paper presents a technique for extracting grammar rules, given a set of programs and an approximate grammar. Grammar is an important artifact used in the generation of tools for program analysis, modification, etc. Current grammar extraction techniques are heuristic in nature. This work proposes a deterministic technique for extracting keyword based grammar rules. The technique uses CYK-parser and LR-parser to build a set of possible rules. For each rule it checks whether the grammar after including that rule is able to parse all the programs or not. As this results in a large set of possible rules, a set of optimizations are proposed to reduce the search space of possible rules. The proposed optimizations utilize the knowledge from multiple programs and exploit the abundance of unit productions in the grammar of programming languages. The proposed approach and optimizations are experimentally checked on a set of input programs.

A workflow editor and scheduler for composing applications on computational grids

A grid allows dynamic integration of disparate resources. A number of grid platforms like CONDOR, Net-Solve, ISS Cornell are available to harness computing power. However, for grid to be pervasive and usable by a novice user, integration at application level is required. We have designed and developed a scalable infrastructure to support workflow composition. The entire workflow can be saved and reused as a compound application. Our workflow engine has been designed to be independent of the underlying grid infrastructure. It has only a small layer which interfaces with the grid infrastructure. We have implemented and integrated our infrastructure with Sun Grid Engine Enterprise Edition 5.3. Applications like document search and matrix multiplication were composed. We observe increase in performance with increase in number of compute servers during experiments

Exploring program phases for statistical bug localization

Statistical bug isolation techniques attempt to capture a correlation of various program features (like predicates and profiled paths) for debugging. These techniques collect profile data for multiple executions, both with successful and faulty runs, and propose using various statistical tests to capture this correlation. In this paper, we explore the utility of program phases, a concept which is primarily used by computer architects to speed up architectural simulations, for statistical bug isolation. Program phases represent sets of execution intervals in a programs execution where the rates of architectural statistics like branch mispredictions, CPU/Memory usage and cache misses remain almost the same. We found multiple scenarios where coupling program phases with predicates achieves higher accuracy to bug localization than when predicates are used alone. We demonstrate the use of program phases for bug isolation by presenting experimental results and concrete case studies on medium-size programs, showing an improved ranking of the program points that are critical to debugging over when program phases are not used.

Multi-objective Evolution Based Dynamic Job Scheduler in Grid

Grid computing is a high performance computing environment to fulfill large-scale computational demands. It can integrate computational as well as storage resources from different networks and geographically dispersed organizations into a high performance computational & storage platform. It is used to solve complex computational-intensive problems, and also provide solution to storage-intensive applications with connected storage resources. Scheduling of user jobs properly on the heterogeneous resources is an important task in a grid computing environment. The main goal of scheduling is to maximize resource utilization, minimize waiting time of jobs, reduce energy consumption, minimize cost to the user after satisfying constraints of jobs and resources. We can trade off between the required level of quality of service, the deadline and the budget of user. In this paper, we propose a Multi-objective Evolution-based Dynamic Scheduler in Grid. Our scheduler have used Multi-objective optimization technique using Genetic algorithm with pareto front approach to find efficient schedules. It explores the search space vividly to avoid stagnation and generate near optimal solution. We propose that our scheduler provides a better grip on most features of grid from perspective of grid owner as well as user. Dynamic grid environment has forced us to make it a real time dynamic scheduler. A job grouping technique is proposed for grouping fine-grained jobs and for ease of computation. Experimentation on different data sets and on various parameters revealed effectiveness of multi-objective scheduling criteria and extraction of performance from grid resource.

Constantine: configurable static analysis tool in Eclipse

Static code analysers help in exposing internal code quality problems. For higher effectiveness, they must be pressed into use early during the development of code. They must support the formulation of new coding constraints with relative ease to better cope with variations in coding standards. We present the design of a static analyser that addresses these twin objectives. Our system provides interactive feedback to programmers on the non‐conformances that occur in response to the changes made to the code. Its rule construction framework empowers programmers to define new conformance rules, which can come into effect immediately after creation. The tool has been realized as an Eclipse plug‐in for the analysis of C, C++ and Java sources. Central to its design is the concept of reusing a set of primitive checks by composing them to form new rules. This renders rule construction accessible to programmers, lowers dependence on tool smiths and accelerates the enforcement of custom checks. We also present our experience in defining rules drawn from an industry standard rule set based on this approach. Copyright

Partool: a feedback-directed parallelizer

We present a tool which gives detailed feedback to application developers on how their programs can be made amenable to parallelization. Also, the tool automatically parallelizes the code for a large number of constructs. Since the tool outputs a parallelized code with OpenMP pragmas, the feedback cycle can be run any number of times till the desired performance is achieved. ParTool also acts as a good learning tool to understand the usage of these parallel constructs and thus enables the developer to write better quality code in the future. Our results show that the use of compiler generated feedback can greatly improve the performance of not only benchmarked code but also real life applications.