OpenMP is a defacto standard API for shared memory programming with widespread vendor support and a large user base. The OpenMP Architecture Review Board has sanctioned an interface specification known as the ”OpenMP Runtime API for Profiling” to enable tools to collect performance data for OpenMP programs. This paper describes the interface and our experiences implementing it in OpenUH, an open source OpenMP compiler.

Performance experiments can involve multiple iterative runs where parameters such as the execution platform, measurement tools, methods of measurement, application parameters, and analysis techniques can vary. In order to manage the layers of complexity involved in setting up and running experiments, data management, and post analysis, a degree of abstraction and automation is necessary for each phase. We present an integrated component-based environment that leverages existing performance measurement and analysis technologies and automates the process of running multiple performance experiments and parameter selection of parallel scientific applications. Our component toolkit will enable application scientists to easily modify the experimental parameters over multiple execution runs and to selectively retrieve the data for analysis and generation of performance models.

Parallel programming languages/libraries including OpenMP, MPI, and UPC are either in the process of defining or have already established standard performance profiling interfaces. The OpenMP Architecture Review Board (ARB) recently sanctioned an interface specification for profiling/tracing tools that defines a protocol for two-way communications and control between the OpenMP runtime library and performance tools, known as the collector API. Reference implementations of the collector are sparse and are primarily closed-source. We provide a description of our efforts towards a full implementation of an open-source performance monitoring tool for OpenMP based on the collector API. This effort(a) evaluates the collector's approach to performance measurement, assesses what is necessary to implement a performance tool based on the collector interface, and also provides information Useful to performance tool developers interested in interfacing with the collector for performance measurements.

Automating the process of parallel performance experimentation, analysis, and problem diagnosis can enhance environments for performance-directed application development, compilation, and execution. This is especially true when parametric studies, modeling, and optimization strategies require large amounts of data to be collected and processed for knowledge synthesis and reuse. This paper describes the integration of the PerfExplorer performance data mining framework with the OpenUH compiler infrastructure. OpenUH provides auto-instrumentation of source code for performance experimentation and PerfExplorer provides automated and reusable analysis of the performance data through a scripting interface. More importantly, PerfExplorer inference rules have been developed to recognize and diagnose performance characteristics important for optimization strategies and modeling. Three case studies are presented which show our success with automation in OpenMP and MPI code tuning, parametric characterization, Pand power modeling. The paper discusses how the integration supports performance knowledge engineering across applications and feedback-based compiler optimization in general.

Characterizing the performance of scientific applications is essential for effective code optimization, both by compilers and by high-level adaptive numerical algorithms. While maximizing power efficiency is becoming increasingly important in current high-performance architectures, little or no hardware or software support exists for detailed power measurements. Hardware counter-based power models are a promising method for guiding software-based techniques for reducing power. We present a component-based infrastructure for performance and power modeling of parallel scientific applications. The power model leverages on-chip performance hardware counters and is designed to model power consumption for modern multiprocessor and multicore systems. Our tool infrastructure includes application components as well as performance and power measurement and analysis components. We collect performance data using the TAU performance component and apply the power model in the performance and power analysis of a PETSc-based parallel fluid dynamics application by using the PerfExplorer component.

Reconfigurable computing (RC), such as computing using field programmable gate array (FPGA) technology has been shown as the field to accelerate a large variety of applications. RC fills the gap bet we n hardware and software, achieving high performance on the hardware than t e software and at the same time maintaining a remarkable amount of flexibility . Though there are bottlenecks associated with using the FPGA accelerators wi th legacy application code, it is becoming difficult to decide which parts of the cod e should be implemented in hardware (versus software), to provide an effic i nt mapping from code to the highly parallel FPGA fabric and to evaluate the co sts associated with running in a hybrid (hardware/software) mode. In this paper w present a methodology to tune an application with the help of a tool environme t consisting of an open source parallelizing compiler, and static and perform ance analysis tools. This serves as a high performance tuning strategy for identi fyi g the bottlenecks in the application code, followed by preprocessing, before mapping the algorithm to the FPGA in order to take advantage of the intrinsic speed. Using this performance toolset and our tuning methodology, we were able to par allelize and tune a bioinformatics application to produce better load balanc es and higher performance, yielding almost linear speedup, of up to 80% on dynami c scheduling with 128 threads on a 1000 sequence data set.

Most OpenMP performance analysis tools are usually stand-alone and provide data to the user after an application completes running. Considerable time and effort can be spent learning to use different tools and waiting for results to become available post-execution. It is beneficial to develop a runtime system that exploits the synergistic effects between compilers and performance tools to alleviate this overhead. An added advantage for such a system is that the instrumentation points do not interefere with static compiler optimizations because they reside in the runtime environment. But as with most run-time systems, the problem of runtime overheads must be addressed. In this project, we address these issues and build a prototype implementation of a run-time performance environment that applies a light-weight sampling based technique to extract low level performance metrics and map these metrics to higher levels of abstraction. Experiments are run on our environment using a kernel application and we display preliminary data.

Negotiation typically involves a number of parties with different criteria, constraints and preferences that determine the individual areas of interest, i.e. the range and order of the preferred solutions of each party. The parties usually have a limited common knowledge of each other's areas of interest. Therefore a range of possible agreements, i.e. the common area of interest is typically not known to the parties a priori. In order to find a mutual agreement the parties explore possible agreements by the process of exchanging information in the form of offers. During the negotiation process the range of possible offers of each party changes according to the current information available. As negotiation progresses and more information become available the ranges reduce until an agreement can be found or the parties withdraw from negotiation. This interpretation allows one to consider the negotiation problem as a constraint satisfaction problem and the negotiation process as constraintbased reasoning. This paper presents some aspects of that interpretation. In particular it outlines the constraint-based representation and constraint propagation mechanisms used in an experimental system of e-Negotiation Agents (eNAs). The eNAs can autonomously negotiate the multi-issue terms of transactions in an e-commerce environment tested with the used car trading problem.

This paper overviews an experimental fuzzy e-negotiation agents system, FeNAs, that can support automated negotiation in the presence of imprecise information. The system uses the principles of fuzzy constraint-based reasoning involving fuzzy constraint modeling, satisfaction and propagation. It is demonstrated with a prototype for the used car-trading problem. The system supports multi-issue negotiations where offers consist of a number of issues that can include the price of the car and other value-added services such as warranty and the value of the trade-in car. The agents exchange offers on the basis of the information available and negotiation strategies used by each party. Information available to both the buyer and the seller can include the make, model, color, transmission, age and mileage of the car. Each agent has also some private information including preferences, priorities and financial constraints that are not available to other agents. This information can be imprecise where constraints, preferences and priorities are defined as fuzzy constraints describing the level of satisfaction of an agent (and its user) with different potential solutions. The overall objective of an agent is to find a solution that maximizes the agent's utility at the highest possible level of constraint satisfaction subject to its acceptability by other agents. During negotiation the agents follow a common protocol of negotiation and individual negotiation strategies.