Youngsung Kim

KGEN: A Python tool for automated Fortran kernel generation and verification

Abstract Computational kernels, which are small pieces of software that selectively capture the characteristics of larger applications, have been used successfully for decades. Kernels allow for the testing of a compilers ability to optimize code, performance of future hardware and reproducing compiler bugs. Unfortunately they can be rather time consuming to create and do not always accurately represent the full complexity of large scientific applications. Furthermore, expert knowledge is often required to create such kernels. In this paper, we present a Python-based tool that greatly simplifies the generation of computational kernels from Fortran based applications. Our tool automatically extracts partial source code of a larger Fortran application into a stand-alone executable kernel. Additionally, our tool also generates state data necessary for proper execution and verification of the extracted kernel. We have utilized our tool to extract more than thirty computational kernels from a million-line climate simulation model. Our extracted kernels have been used for a variety of purposes including: code modernization, identification of limitations in compiler optimizations, numerical algorithm debugging, compiler bug reporting, and for procurement benchmarking.

Compiler technologies for understanding legacy scientific code: A case study on an ACME land module

Abstract The complexity of software systems have become a barrier for scientific model development and software modernization. In this study, we present a procedure to use compiler-based technologies to better understand complex scientific code. The approach requires no extra software installation and configuration and its software analysis can be transparent to developer and users. We designed a sample code to illustrate the data collection and analysis procedure from compiler technologies and showed a case study that used the information from interprocedure analysis to analyze a scientific function module extracted from an Earth System Model. We believe this study provides a new path to better understand legacy scientific code.

DG-kernel: A Climate Benchmark on Accelerated and Conventional Architectures

While the emergence of many-core technology from Intel and Vida has illustrated great potential, capitalizing on this potential presents considerable challenges for large scientific applications. In particular we focus on the domain of climate modeling. Climate models typically have very large code bases with over one million lines of code which makes support of multiple version of the code infeasible. Climate models are computationally very expensive which places a premium on model performance. Furthermore because of the large user base of these applications, there is a need to support a wide range of computational platforms. These three characteristics of climate modeling make it a particularly challenging application domain for which to apply accelerator technology. We describe the work to optimize and analyze a kernel benchmark developed at the National Center for Atmospheric Research on Intel Xeon Phi, Intel Sandy Bridge, and Vida GPU. The DG-kernel is a gradient calculation from the discontinuous Galerkin version of the High Order Methods Model Environment. We explored several different programming paradigms, including Fortran with both OpenACC and OpenMP, F2C-ACC, and Cuda C/Fortran. We analyze low-level hardware characteristics and their impact on the performance of the DG-kernel.

Assessing Representativeness of Kernels Using Descriptive Statistics

A kernel or mini-app is a self-contained small application that retains certain characteristics of the original application [7]. Working on a kernel or mini-app in the place of the original application can dramatically reduce the resources and effort required for performing software tasks such as performance optimization and porting to new platforms. However, using kernel as a proxy is based on the assumption that it represents the original application in the context of how it is being used. In this paper, we introduce an extension to the Fortran Kernel Generator (KGen) which is an automated kernel extraction tool [1]. The extension allows comparison of the execution characteristics between the original application and the generated kernel using descriptive statistics. From the comparison, the user is provided with statistics that provide information on the degree and context of representativeness of the kernel. KGen also utilizes the information generated to help it to automatically improve representativeness of the kernels whilst reducing the size of the workload generated. We applied this extension to three kernels. One is generated from a Fortran scientific library and the remaining two are generated from an earth system model. We have demonstrated that the descriptive statistics provided in the enhancement provide not only quantitative metrics and context of representativeness but also a way to improve the quality of representativeness of the kernels generated.

Performance search engine driven by prior knowledge of optimization

For scientific array-based programs, optimization for a particular target platform is a hard problem. There are many optimization techniques such as (semantics-preserving) source code transformations, compiler directives, environment variables, and compiler flags that influence performance. Moreover, the performance impact of (combinations of) these factors is unpredictable. This pa- per focuses on providing a platform for automatically searching through search space consisting of such optimization techniques. We provide (i) a search-space description language, which enables the user to describe optimization options to be used; (ii) search engine that enables testing the performance impact of optimization options by executing optimized programs and checking their results; and (iii) an interface for implementing various search algorithms. We evaluate our platform by using two simple search algorithms - a random search and a casetree search that heuristically learns from the already examined parts of the search space. We show that such algorithms are easily implementable in our plat- form, and we empirically find that the framework can be used to find useful optimized algorithms.