The Experts below are selected from a list of 6837 Experts worldwide ranked by ideXlab platform

Dawn Song - One of the best experts on this subject based on the ideXlab platform.

  • the correctness security gap in Compiler Optimization
    IEEE Symposium on Security and Privacy, 2015
    Co-Authors: Vijay Dsilva, Mathias Payer, Dawn Song
    Abstract:

    There is a significant body of work devoted to testing, verifying, and certifying the correctness of optimizing Compilers. The focus of such work is to determine if source code and optimized code have the same functional semantics. In this paper, we introduce the correctness-security gap, which arises when a Compiler Optimization preserves the functionality of but violates a security guarantee made by source code. We show with concrete code examples that several standard Optimizations, which have been formally proved correct, in-habit this correctness-security gap. We analyze this gap and conclude that it arises due to techniques that model the state of the program but not the state of the underlying machine. We propose a broad research programme whose goal is to identify, understand, and mitigate the impact of security errors introduced by Compiler Optimizations. Our proposal includes research in testing, program analysis, theorem proving, and the development of new, accurate machine models for reasoning about the impact of Compiler Optimizations on security.

  • IEEE Symposium on Security and Privacy Workshops - The Correctness-Security Gap in Compiler Optimization
    2015 IEEE Security and Privacy Workshops, 2015
    Co-Authors: Vijay D'silva, Mathias Payer, Dawn Song
    Abstract:

    There is a significant body of work devoted to testing, verifying, and certifying the correctness of optimizing Compilers. The focus of such work is to determine if source code and optimized code have the same functional semantics. In this paper, we introduce the correctness-security gap, which arises when a Compiler Optimization preserves the functionality of but violates a security guarantee made by source code. We show with concrete code examples that several standard Optimizations, which have been formally proved correct, in-habit this correctness-security gap. We analyze this gap and conclude that it arises due to techniques that model the state of the program but not the state of the underlying machine. We propose a broad research programme whose goal is to identify, understand, and mitigate the impact of security errors introduced by Compiler Optimizations. Our proposal includes research in testing, program analysis, theorem proving, and the development of new, accurate machine models for reasoning about the impact of Compiler Optimizations on security.

Lieven Eeckhout - One of the best experts on this subject based on the ideXlab platform.

  • cole Compiler Optimization level exploration
    Symposium on Code Generation and Optimization, 2008
    Co-Authors: Kenneth Hoste, Lieven Eeckhout
    Abstract:

    Modern Compilers implement a large number of Optimizations which all interact in complex ways, and which all have a different impact on code quality, compilation time, code size, energy consumption, etc. For this reason, Compilers typically provide a limited number of standard Optimization levels, such as -O1, -O2, -O3 and -Os, that combine various Optimizations providing a number of trade-offs between multiple objective functions (such as code quality, compilation time and code size). The construction of these Optimization levels, i.e., choosing which Optimizations to activate at each level, is a manual process typically done using high-level heuristics based on the Compiler developer's experience. This paper proposes COLE, Compiler Optimization Level Exploration, a framework for automatically finding Pareto optimal Optimization levels through multi-objective evolutionary searching. Our experimental results using GCC and the SPEC CPU benchmarks show that the automatic construction of Optimization levels is feasible in practice, and in addition, yields better Optimization levels than GCC's manually derived (-Os, -O1, -O2 and -O3) Optimization levels, as well as the Optimization levels obtained through random sampling. We also demonstrate that COLE can be used to gain insight into the effectiveness of Compiler Optimizations as well as to better understand a benchmark's sensitivity to Compiler Optimizations.

  • CGO - Cole: Compiler Optimization level exploration
    Proceedings of the sixth annual IEEE ACM international symposium on Code generation and optimization - CGO '08, 2008
    Co-Authors: Kenneth Hoste, Lieven Eeckhout
    Abstract:

    Modern Compilers implement a large number of Optimizations which all interact in complex ways, and which all have a different impact on code quality, compilation time, code size, energy consumption, etc. For this reason, Compilers typically provide a limited number of standard Optimization levels, such as -O1, -O2, -O3 and -Os, that combine various Optimizations providing a number of trade-offs between multiple objective functions (such as code quality, compilation time and code size). The construction of these Optimization levels, i.e., choosing which Optimizations to activate at each level, is a manual process typically done using high-level heuristics based on the Compiler developer's experience. This paper proposes COLE, Compiler Optimization Level Exploration, a framework for automatically finding Pareto optimal Optimization levels through multi-objective evolutionary searching. Our experimental results using GCC and the SPEC CPU benchmarks show that the automatic construction of Optimization levels is feasible in practice, and in addition, yields better Optimization levels than GCC's manually derived (-Os, -O1, -O2 and -O3) Optimization levels, as well as the Optimization levels obtained through random sampling. We also demonstrate that COLE can be used to gain insight into the effectiveness of Compiler Optimizations as well as to better understand a benchmark's sensitivity to Compiler Optimizations.

D.i. August - One of the best experts on this subject based on the ideXlab platform.

  • Compiler Optimization-space exploration
    International Symposium on Code Generation and Optimization 2003. CGO 2003., 2003
    Co-Authors: S. Triantafyllis, M. Vachharajani, N. Vachharajani, D.i. August
    Abstract:

    To meet the demands of modern architectures, optimizing Compilers must incorporate an ever larger number of increasingly complex transformation algorithms. Since code transformations may often degrade performance or interfere with subsequent transformations, Compilers employ predictive heuristics to guide Optimizations by predicting their effects a priori. Unfortunately, the unpredictability of Optimization interaction and the irregularity of today's wide-issue machines severely limit the accuracy of these heuristics. As a result, Compiler writers may temper high variance Optimizations with overly conservative heuristics or may exclude these Optimizations entirely. While this process results in a Compiler capable of generating good average code quality across the target benchmark set, it is at the cost of missed Optimization opportunities in individual code segments. To replace predictive heuristics, researchers have proposed Compilers which explore many Optimization options, selecting the best one a posteriori. Unfortunately, these existing iterative compilation techniques are not practical for reasons of compile time and applicability. We present the Optimization-Space Exploration (OSE) Compiler organization, the first practical iterative compilation strategy applicable to Optimizations in general-purpose Compilers. Instead of replacing predictive heuristics, OSE uses the Compiler writer's knowledge encoded in the heuristics to select a small number of promising Optimization alternatives for a given code segment. Compile time is limited by evaluating only these alternatives for hot code segments using a general compile-time performance estimator An OSE-enhanced version of Intel's highly-tuned, aggressively optimizing production Compiler for IA-64 yields a significant performance improvement, more than 20% in some cases, on Itanium for SPEC codes.

  • Compiler Optimization space exploration
    Symposium on Code Generation and Optimization, 2003
    Co-Authors: S. Triantafyllis, M. Vachharajani, N. Vachharajani, D.i. August
    Abstract:

    To meet the demands of modern architectures, optimizing Compilers must incorporate an ever larger number of increasingly complex transformation algorithms. Since code transformations may often degrade performance or interfere with subsequent transformations, Compilers employ predictive heuristics to guide Optimizations by predicting their effects a priori. Unfortunately, the unpredictability of Optimization interaction and the irregularity of today's wide-issue machines severely limit the accuracy of these heuristics. As a result, Compiler writers may temper high variance Optimization with overly conservative heuristics or may exclude these Optimizations entirely. While this process results in a Compiler capable of generating good average code quality across the target benchmark set, it is at the cost of missed Optimization opportunities in individual code segments.To replace predictive heuristics, researchers have proposed Compilers which explore many Optimization options, selecting the best one a posteriori. Unfortunately, these existing iterative compilation techniques are not practical for reasons of compile time and applicability. In this paper, we present the Optimization-Space Exploration (OSE) Compiler organization, the first practical iterative compilation strategy applicable to Optimizations in general-purpose Compilers. Instead of replacing predictive heuristics, OSE uses the Compiler writer's knowledge encoded in the heuristics to select a small number of promising Optimization alternatives for a given code segment. Compile time is limited by evaluating only these alternatives for hot code segments using a general compiletime performance estimator. An OSE-enhanced version of lntel's highly-tuned, aggressively optimizing production Compiler for IA-64 yields a significant performance improvement, more than 20% in some cases, on Itanium for SPEC codes.

  • CGO - Compiler Optimization-space exploration
    International Symposium on Code Generation and Optimization 2003. CGO 2003., 2003
    Co-Authors: S. Triantafyllis, M. Vachharajani, N. Vachharajani, D.i. August
    Abstract:

    To meet the demands of modern architectures, optimizing Compilers must incorporate an ever larger number of increasingly complex transformation algorithms. Since code transformations may often degrade performance or interfere with subsequent transformations, Compilers employ predictive heuristics to guide Optimizations by predicting their effects a priori. Unfortunately, the unpredictability of Optimization interaction and the irregularity of today's wide-issue machines severely limit the accuracy of these heuristics. As a result, Compiler writers may temper high variance Optimization with overly conservative heuristics or may exclude these Optimizations entirely. While this process results in a Compiler capable of generating good average code quality across the target benchmark set, it is at the cost of missed Optimization opportunities in individual code segments.To replace predictive heuristics, researchers have proposed Compilers which explore many Optimization options, selecting the best one a posteriori. Unfortunately, these existing iterative compilation techniques are not practical for reasons of compile time and applicability. In this paper, we present the Optimization-Space Exploration (OSE) Compiler organization, the first practical iterative compilation strategy applicable to Optimizations in general-purpose Compilers. Instead of replacing predictive heuristics, OSE uses the Compiler writer's knowledge encoded in the heuristics to select a small number of promising Optimization alternatives for a given code segment. Compile time is limited by evaluating only these alternatives for hot code segments using a general compiletime performance estimator. An OSE-enhanced version of lntel's highly-tuned, aggressively optimizing production Compiler for IA-64 yields a significant performance improvement, more than 20% in some cases, on Itanium for SPEC codes.

Vijay Dsilva - One of the best experts on this subject based on the ideXlab platform.

  • the correctness security gap in Compiler Optimization
    IEEE Symposium on Security and Privacy, 2015
    Co-Authors: Vijay Dsilva, Mathias Payer, Dawn Song
    Abstract:

    There is a significant body of work devoted to testing, verifying, and certifying the correctness of optimizing Compilers. The focus of such work is to determine if source code and optimized code have the same functional semantics. In this paper, we introduce the correctness-security gap, which arises when a Compiler Optimization preserves the functionality of but violates a security guarantee made by source code. We show with concrete code examples that several standard Optimizations, which have been formally proved correct, in-habit this correctness-security gap. We analyze this gap and conclude that it arises due to techniques that model the state of the program but not the state of the underlying machine. We propose a broad research programme whose goal is to identify, understand, and mitigate the impact of security errors introduced by Compiler Optimizations. Our proposal includes research in testing, program analysis, theorem proving, and the development of new, accurate machine models for reasoning about the impact of Compiler Optimizations on security.

Michael Oboyle - One of the best experts on this subject based on the ideXlab platform.

  • machine learning in Compiler Optimization
    Proceedings of the IEEE, 2018
    Co-Authors: Zheng Wang, Michael Oboyle
    Abstract:

    In the last decade, machine-learning-based compilation has moved from an obscure research niche to a mainstream activity. In this paper, we describe the relationship between machine learning and Compiler Optimization and introduce the main concepts of features, models, training, and deployment. We then provide a comprehensive survey and provide a road map for the wide variety of different research areas. We conclude with a discussion on open issues in the area and potential research directions. This paper provides both an accessible introduction to the fast moving area of machine-learning-based compilation and a detailed bibliography of its main achievements.

  • a cross platform evaluation of graphics shader Compiler Optimization
    International Symposium on Performance Analysis of Systems and Software, 2018
    Co-Authors: Lewis Crawford, Michael Oboyle
    Abstract:

    For real-time graphics applications such as games and virtual reality, performance is crucial to provide a smooth user experience. Central to this is the performance of shader programs which render images on the GPU. The rise of low-level graphics APIs such as Vulkan means compilation tools play an increasingly important role in the graphics ecosystem. However, despite the importance of graphics, there is little published work on the impact of Compiler Optimization. This paper explores common features of graphics shaders, and examines the impact and applicability of common Optimizations such as loop unrolling, and arithmetic reassociation. Combinations of Optimizations are evaluated via exhaustive search across a wide set of shaders from the GFXBench 4.0 benchmark suite. Their impact is assessed across three desktop and two mobile GPUs from different vendors. We show that Compiler Optimization can have significant positive and negative impacts which vary across optimisations, benchmarks and platforms.

  • exploiting gpu hardware saturation for fast Compiler Optimization
    Architectural Support for Programming Languages and Operating Systems, 2014
    Co-Authors: Alberto Magni, Christophe Dubach, Michael Oboyle
    Abstract:

    Graphics Processing Units (GPUs) are efficient devices capable of delivering high performance for general purpose computation. Realizing their full performance potential often requires extensive Compiler tuning. This process is particularly expensive since it has to be repeated for each target program and platform. In this paper we study the utilization of GPU hardware resources across multiple input sizes and Compiler options. In this context we introduce the notion of hardware saturation. Saturation is reached when an application is executed with a number of threads large enough to fully utilize the available hardware resources. We give experimental evidence of hardware saturation and describe its properties using 16 OpenCL kernels on 3 GPUs from Nvidia and AMD. We show that input sizes that saturates the GPU show performance stability across Compiler transformations. Using the thread-coarsening transformation as an example, we show that Compiler settings maintain their relative performance across input sizes within the saturation region. Leveraging these hardware and software properties we propose a technique to identify the input size at the lower bound of the saturation zone, we call it Minimum Saturation Point (MSP). By performing iterative compilation on the MSP input size we obtain results effectively applicable for much large input problems reducing the overhead of tuning by an order of magnitude on average.