Graeme Johnson

CViMe: viewing conditionally compiled C/C++ sources through Java

Todays large software systems and libraries are geared towards a broad range of platforms and environments, often relying on conditional compilation through preprocessor directives to generate specific builds for a given set of configuration flags. In spite of the well-documented benefits of using preprocessor directives for conditional compilation, heavy preprocessor presence can hinder code readability and affect maintenance and debugging. Although various existing preprocessor tools hide unwanted preprocessor conditionals, we present a more portable Eclipse-based solution called CViMe (Conditional-compilation Viewer and Miner) that relies on object-modeling to not only fold non-compiled code, but refactor conditionally compiled blocks into reusable units like macros, significantly reducing the presence of preprocessor directives at the editor level.

A Tool for Scalable Profiling and Tracing of Java and Native Code Interactions

Java workloads have two different execution spaces: one in JVM and the other in the native environment. Understanding workload activity in native and non-native (Java) spaces and its impact on the overall resource consumption of Java workloads can be very useful. For example, this knowledge can be exploited in code optimization and for efficient process level scheduling especially in emerging hybrid systems. Existing Java run time tracing tools are quite heavyweight and/or offer limited useful information for understanding Java and native space interactions. We developed an extremely lightweight tracing tool for enterprise Java workloads. The tool captures detailed per-thread statistics related to resource usage and activity in JVM and native spheres. Efficient design based on innovative thread and memory management principles enables us to achieve scalable monitoring with our tool on multi-core systems running enterprise workloads. The information captured by the tool is used to build workload profiles which can then be used for predictive performance of Java workloads in emerging systems and architectures.

Improving J9 virtual machine with LTTng for efficient and effective tracing

The ability to observe the internal operation of the J9 virtual machine is essential for effective performance tuning. To this end, tracing is an important method, which is the action of recording events from a running system with minimum performance overhead for online or off‐line analysis. In this paper, we propose the integration of LTTng, an effective open‐source tracing toolset, with J9 to improve its tracing functions. With this integration, the tracing component is not only decoupled from the virtual machine but also performed efficiently at both user and kernel levels to achieve a high‐throughput result. To validate the integration and its impact performance, some empirical study results based on SpecJBB2005 and SQLBenchmark (supported by instrumented MariaDB) are also presented. Copyright

Experiences in building and scaling an enterprise application on multicore systems

Even though Java is the de facto programming language for enterprise applications, there exist only a limited number of Java‐based benchmarks to understand the performance on emerging multicore systems. To bridge this gap, this paper presents a report generation benchmark that is developed on top of Open Source Apache Geronimos DayTrader benchmark. Report generation and rendering is at the heart of many enterprise business analytics and business intelligence software products, and it is used by many enterprise applications. We evaluate the performance scalability of this benchmark on a state‐of‐the‐art Power7 multicore system with 8 Power7 cores and 32 hardware threads. The benchmark throughput scales linearly up to eight hardware threads, but beyond that point, the throughput falls sharply. Significant locking in the Java class libraries for non‐shared objects results in this performance drop. Splitting the locks on these shared classes results in near linear scaling from eight to 32 threads and improved the throughput by 80%. We also show that the Linux operating system load balancing could result in a degraded application performance in hardware multithreaded systems and simultaneous‐multithreads‐aware task scheduling results in uniform core‐resource utilization as well as improved application performance. Copyright