Performance Comparisons of Basic OpenMP Constructs

Jackal is a fine-grained distributed shared memory implementation of the Java programming language. Jackal implements Java's memory model and allows multithreaded Java programs to run unmodified on distributed-memory systems.This paper focuses on Jackal's runtime system, which implements a multiple-writer, home-based consistency protocol. Protocol actions are triggered by software access checks that Jackal's compiler inserts before object and array references. We describe optimizations for Jackal's runtime system, which mainly consist of discovering opportunities to dispense with flushing of cached data. We give performance results for different runtime optimizations, and compare their impact with the impact of one compiler optimization. We find that our runtime optimizations are necessary for good Jackal performance, but only in conjunction with the Jackal compiler optimizations described in [24]. As a yardstick, we compare the performance of Java applications run on Jackal with the performance of equivalent applications that use a fast implementation of Java's Remote Method Invocation (RMI) instead of shared memory.

On a distributed memory machine, hand-coded message passing leads to the most efficient execution, but it is difficult to use. Parallelizing compilers can approach the performance of hand-coded message passing by translating data-parallel programs into message passing programs, but efficient execution is limited to those programs for which precise analysis can be carried out. Shared memory is easier to program than message passing and its domain is not constrained by the limitations of parallelizing compilers, but it lags in performance. Our goal is to close that performance gap while retaining the benefits of shared memory. In other words, our goal is (1) to make shared memory as efficient as message passing, whether hand-coded or compiler-generated, (2) to retain its ease of programming, and (3) to retain the broader class of applications it supports.To this end we have designed and implemented an integrated compile-time and run-time software DSM system. The programming model remains identical to the original pure run-time DSM system. No user intervention is required to obtain the benefits of our system. The compiler computes data access patterns for the individual processors. It then performs a source-to-source transformation, inserting in the program calls to inform the run-time system of the computed data access patterns. The run-time system uses this information to aggregate communication, to aggregate data and synchronization into a single message, to eliminate consistency overhead, and to replace global synchronization with point-to-point synchronization wherever possible.We extended the Parascope programming environment to perform the required analysis, and we augmented the TreadMarks run-time DSM library to take advantage of the analysis. We used six Fortran programs to assess the performance benefits: Jacobi, 3D-FFT, Integer Sort, Shallow, Gauss, and Modified Gramm-Schmidt, each with two different data set sizes. The experiments were run on an 8-node IBM SP/2 using user-space communication. Compiler optimization in conjunction with the augmented run-time system achieves substantial execution time improvements in comparison to the base TreadMarks, ranging from 4% to 59% on 8 processors. Relative to message passing implementations of the same applications, the compile-time run-time system is 0-29% slower than message passing, while the base run-time system is 5-212% slower. For the five programs that XHPF could parallelize (all except IS), the execution times achieved by the compiler optimized shared memory programs are within 9% of XHPF.

Transmeta's Efficeon microprocessor is a full, system-level implementation of the x86 architecture, comprising a native VLIW microprocessor with a software layer, the Code Morphing Software (CMS), that combines an interpreter, dynamic binary translator, optimizer, and run-time system. This software layer provides unique opportunities for studying the tradeoffs between interpretation and dynamic translation with various levels of optimization, while running arbitrary PC workloads. This talk presents some results from such a study, and provides insight into what mix of these emulation modes is most desirable over the range of tested workloads.

Opening Platforms: How, When and Why?

Compiler optimization techniques allow developers to achieve peak performance with low-cost hardware and are of prime importance in the field of efficient computing strategies. The realm of compiler suites that possess and apply efficient optimization methods provide a wide array of beneficial attributes that help programs execute efficiently with low execution time and minimal memory utilization. Different compilers provide a certain degree of optimization possibilities and applying the appropriate optimization strategies to complex programs can have a significant impact on the overall performance of the system. This paper discusses methods of compiler optimization and covers significant advances in compiler optimization techniques that have been established over the years. This article aims to provide an overall survey of the cache optimization methods, multi memory allocation features and explore the scope of machine learning in compiler optimization to attain a sustainable computing experience for the developer and user.

This paper describes a just-in-time (JIT) Java1 compiler for the Intel® Itanium® processor. The Itanium processor is an example of an Explicitly Parallel Instruction Computing (EPIC) architecture and thus relies on aggressive and expensive compiler optimizations for performance. Static compilers for Itanium use aggressive global scheduling algorithms to extract instruction-level parallelism. In a JIT compiler, however, the additional overhead of such expensive optimizations may offset any gains from the improved code.In this paper, we describe lightweight code generation techniques for generating efficient Itanium code. Our compiler relies on two basic methods to generate efficient code. First, the compiler uses inexpensive scheduling heuristics to model the Itanium microarchitecture. Second, the compiler uses the semantics of the Java virtual machine to extract instruction-level parallelism.

This paper describes our trace-based JIT compiler (trace-JIT) for Java developed from a production-quality method-based JIT compiler (method-JIT). We first describe the design and implementation of our trace-JIT with emphasis on how we retrofitted a method-JIT as a trace-based compiler. Then we show that the trace-JIT often produces better quality code than the method-JIT by extending the compilation scope. Forming longer traces that span multiple methods turns out to be more powerful than method inlining in extending the compilation scope. It reduces method-invocation overhead and also offers more compiler optimization opportunities. However, the trace-JIT incurs additional runtime overhead compared to the method-JIT that may be offset by gains from the improved code quality. Overall, our trace-JIT achieved performance roughly comparable to the baseline method-JIT. We also discuss the issues in trace-based compilation from the viewpoint of compiler optimizations. Our results show the potentials of trace-based compilation as an alternative or complementary approach to compiling languages with mature method-based compilers.

Ad-hoc networks of mobile devices such as smart phones and PDAs represent a new and exciting distributed system architecture. Building distributed applications on such an architecture poses new design challenges in programming models, languages, compilers, and runtime systems. This paper discusses SpatialViews, a high-level language designed for programming mobile devices connected through a wireless ad-hoc network. SpatialViews allows specification of virtual networks with nodes providing desired services and residing in interesting spaces. These nodes are discovered dynamically with user-specified time constraints and quality of result (QoR). The programming model supports "best-effort" semantics, i.e., different executions of the same program may result in "correct" answers of different quality. It is the responsibility of the compiler and runtime system to produce a high-quality answer for the particular network and resource conditions encountered during program execution. Four applications, which exercise different features of the SpatialViews language, are presented to demonstrate the expressiveness of the language and the efficiency of the compiler generated code. The applications are an application that collects and aggregates sensor data in network, an application that performs dynamic service installation, a mobile camera application that supports computation offloading for image understanding, and an augmented-reality (AR) Pacman game. The efficiency of the compiler generated code is verified through simulation and physical measurements. The reported results show that SpatialViews is an expressive and effective language for ad-hoc networks. In addition, compiler optimizations can significantly improve response times and energy consumption.

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.

Code optimization involves the application of rules and algorithms to program code, with the goal of making it faster, smaller, more efficient, and so on. Applying the right compiler optimizations to a particular program can have a significant impact on program performance. The effectiveness of compiler optimizations is determined by the combination of target architectures, target application, and the compilation environment, which is defined by the setting of the compiler optimizations and compiler heuristics. Finding a compiler setting which is optimal requires a delicate tradeoff between these factors. Due to the non-linear interaction of compiler optimizations, however, determining the best setting is nontrivial. The trivial solution of trying all combinations of techniques would be infeasible, as it is of complexity O (2 <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">n</sup> ) even for "n" on-off optimizations. There have been several proposed techniques that search the space of compiler options to find good solutions; however such approaches can be expensive. In current compilers, through command line arguments, the user must decide which optimizations are to be applied in a given compilation run. Clearly, this is not a long-term solution. As compiler optimizations get increasingly numerous and complex, this problem must find an automated solution. In this paper, a new technique is suggested, which prunes the large search space using branch and bound technique, so that only the area in search space which is most beneficial is given higher priority for further exploration whereas the least promising regions are straightaway pruned off, thus saving time by not exploring those regions which give a handful or negligible benefits. Also further probes of the search space tree are halted, once it is determined that the relative improvement in the time is not considerable as compared to the cost incurred for further probes. The time complexity of proposed method under worst case is found to be of O (n <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">2</sup> ) and under best case it can be even O (n).

Purpose–This study wants to look at how organizational commitment and internal control systems affect the accountability of village fund allocation management, with value-for-money-based performance measures as a moderating variable.Design/methodology/approach– All ten villages in Sungai Lala District, Indragiri Hulu Regency, were included in this study. This study used a saturated sample technique, in which all populations were sampled, namely ten villages. Ten respondents were taken from each village, so the number of respondents in this study was 100 with 93 responses used for analysis. The relationship between variables was analyzed using SEM with Smart PLSFindings– Results indicate that organizational commitment and internal control mechanisms have a favorable and significant impact on village budget allocation management accountability. Value-for-money-based performance measures can moderate the influence of organizational commitment.Originality/values– This study uses performance measurement with value for money as moderation. Performance measurement is essential to increase commitment and strengthen internal control to realize accountability for village fund allocation management.Research limitations/implications– This research has the limitation that the village government only carried it out in the Sungai Lala sub-district, Indragiri Hulu Regency. This research contributes to the village government's need to strengthen commitment, internal control systems, and performance measurement with value for money.

PurposeThe purpose of this paper is to examine the mediating role performance measurement plays in the relationship between competitive strategies and firm performance.Design/methodology/approachThis study conducted a mail‐survey of Thai listed companies in 2009. A total of 101 Thai listed companies’ executives, each representing their company, participated in this study. The SPSS version 11.5, path‐analytical model is adopted to analyze the survey data obtained.FindingsThis study finds that generally, all competitive strategies positively and significantly enhance firm performance through performance measurement. Specifically, firms’ differentiation strategy not only has a direct and significant impact on firm performance but also it has indirect and significant impact on firm performance through financial measures. Cost leadership strategy that firms pursue does not directly affect firm performance. However, it does so indirectly and significantly through financial performance measures.Research limitations/implicationsFuture research could consider the use of longitudinal data to ascertain more clearly these causal relationships.Practical implicationsThe paper offers managerial implications that whether a firm chooses to pursue cost leadership or differentiation strategies, a strong emphasis on performance measurement will ensure the positive impact on firm performance in a fierce competitive environment.Originality/valueThis paper adds to the existing theoretical discussion and analyses the research and findings on the mediating role of performance measurement on the relationship between competitive strategy and firm performance.

15+ years of joint parallel application performance analysis/tools training with Scalasca/Score-P and Paraver/Extrae toolsets

A processor's memory hierarchy has a major impact on the performance of running code. However, computing platforms, where the actual hardware characteristics are hidden from both the end user and the tools that mediate execution, such as a compiler, a JIT and a runtime system, are used more and more, for example, performing large scale computation in cloud and cluster. Even worse, in such environments, a single computation may use a collection of processors with dissimilar characteristics. Ignorance of the performance-critical parameters of the underlying system makes it difficult to improve performance by optimizing the code or adjusting runtime-system behaviors; it also makes application performance harder to understand. To address this problem, we have developed a suite of portable tools that can efficiently derive many of the parameters of processor memory hierarchies, such as levels, effective capacity and latency of caches and TLBs, in a matter of seconds. The tools use a series of carefully considered experiments to produce and analyze cache response curves automatically. The tools are inexpensive enough to be used in a variety of contexts that may include install time, compile time or runtime adaption, or performance understanding tools.

In future generation networks and systems, innovation is enabled by introducing new open platforms where various developers may contribute with new and innovative services that will be provided to the end users as a service and at runtime. These open platforms have to secure high level of automation so that developers and users may contribute to or use the open platform via standard interfaces. Moreover, these new open platforms have to secure high quality standards that would be assured through autonomous mechanisms that are implemented within these open platforms. As one of the very important aspects for the majority of services and its users is the reliability that open platforms offer for its users. Here in this paper, we present a case study how to secure an open platform for reliable service delivery. The case study is based on the use of Scribble tool that implements session types as formalism for describing protocol interactions that secure reliable operation among Erlang applications.