Log in

Relevant bibliographies by topics / Compiler / Journal articles

To see the other types of publications on this topic, follow the link: Compiler.

Journal articles on the topic 'Compiler'

Author: Grafiati

Published: 4 June 2021

Last updated: 25 July 2025

Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles

Select a source type:

Consult the top 50 journal articles for your research on the topic 'Compiler.'

Next to every source in the list of references, there is an 'Add to bibliography' button. Press on it, and we will generate automatically the bibliographic reference to the chosen work in the citation style you need: APA, MLA, Harvard, Chicago, Vancouver, etc.

You can also download the full text of the academic publication as pdf and read online its abstract whenever available in the metadata.

Browse journal articles on a wide variety of disciplines and organise your bibliography correctly.

1

Liu, Changlan, Yingsong Zhang, Peng Zuo, and Peng Wang. "Compiler Identification with Divisive Analysis and Support Vector Machine." Symmetry 17, no. 6 (2025): 867. https://doi.org/10.3390/sym17060867.

Full text

Abstract:

Compilers play a crucial role in software development, as most software must be compiled into binaries before release. Analyzing the compiler version from binary files is of great importance in software reverse engineering, maintenance, traceability, and information security. In this work, we propose a novel framework for compiler version identification. Firstly, we generated 1000 C language source codes using CSmith and subsequently compiled them into 16,000 binary files using 16 distinct versions of compilers. The symmetric distribution of the dataset among different compiler versions may en

APA, Harvard, Vancouver, ISO, and other styles

2

Chowdhary, K. R., Rajendra Purohit, and Sunil Dutt Purohit. "Source-to-source translation for code-optimization." Journal of Information and Optimization Sciences 44, no. 3 (2023): 407–16. http://dx.doi.org/10.47974/jios-1350.

Full text

Abstract:

Multi-core design intends to serve a large market with user-oriented and highproductivity management as opposed to any other parallel system. Small numbers of processors, a frequent feature of current multi-core systems, are ideal for future generation of CPUs, where automated parallelization succeeds on shared space architectures. The multi-core compiler optimization platform CETUS (high-level to high-level compiler) offers initiates automatic parallelization in compiled programmes. This compiler’s infrastructure is built with C programmes in mind and is user-friendly and simple to use. It of

APA, Harvard, Vancouver, ISO, and other styles

3

Ren, Xiao Guang. "Optimize OpenFOAM from the Compiler Perspective." Applied Mechanics and Materials 687-691 (November 2014): 3183–86. http://dx.doi.org/10.4028/www.scientific.net/amm.687-691.3183.

Full text

Abstract:

OpenFOAM is a widely used open source computational fluid dynamics (CFD) , and the performance of its application is critical for the CFD user, and many researchers try to optimize it from various perspectives. In this paper, we try to optimization OpenFOAM application from the compiler perspective, which is the simplest way to get the optimization affect. We compare two mainstream compilers: Intel compiler icc and an open source compiler, as well as a serious of optimization option flags. Through the experiment, we find that Intel compiler has a much better performance than gcc, which is up t

APA, Harvard, Vancouver, ISO, and other styles

4

Alfonseca, Enrique. "Writing a compilers compiler in APL." ACM SIGAPL APL Quote Quad 29, no. 3 (1999): 69–75. http://dx.doi.org/10.1145/327600.327620.

Full text

APA, Harvard, Vancouver, ISO, and other styles

5

Baldwin, Doug. "A compiler for teaching about compilers." ACM SIGCSE Bulletin 35, no. 1 (2003): 220–23. http://dx.doi.org/10.1145/792548.611974.

Full text

APA, Harvard, Vancouver, ISO, and other styles

6

KHARIN, I. A., and M. V. RASKATOVA. "ANALYSIS OF THE ALGORITHMS OF THE CONSTITUENT PARTS OF THE COMPILER AND ITS OPTIMIZATION." Computational Nanotechnology 10, no. 2 (2023): 26–35. http://dx.doi.org/10.33693/2313-223x-2023-10-2-26-35.

Full text

Abstract:

Program optimization arose as a response to the emergence of high-level programming languages, and includes special techniques and methods used in building compilers to produce sufficiently efficient object code. A combination of these techniques constituted in the past and are now an integral part of so-called optimizing compilers, the purpose of which is to create object code, saving computer resources such as processor time and memory. For modern supercomputers, the requirement to make proper use of hardware features is also added. In this context, issues related to compiler optimization de

APA, Harvard, Vancouver, ISO, and other styles

7

Melnyk, Anatoliy, and Nazar Kozak. "Easy Universal Translator as an Alternative Compiler-Compiler." Advances in Cyber-Physical Systems 4, no. 2 (2019): 105–9. http://dx.doi.org/10.23939/acps2019.02.105.

Full text

APA, Harvard, Vancouver, ISO, and other styles

8

Paraskevopoulou, Zoe, John M. Li, and Andrew W. Appel. "Compositional optimizations for CertiCoq." Proceedings of the ACM on Programming Languages 5, ICFP (2021): 1–30. http://dx.doi.org/10.1145/3473591.

Full text

Abstract:

Compositional compiler verification is a difficult problem that focuses on separate compilation of program components with possibly different verified compilers. Logical relations are widely used in proving correctness of program transformations in higher-order languages; however, they do not scale to compositional verification of multi-pass compilers due to their lack of transitivity. The only known technique to apply to compositional verification of multi-pass compilers for higher-order languages is parametric inter-language simulations (PILS), which is however significantly more complicated

APA, Harvard, Vancouver, ISO, and other styles

9

Noor, Abdul Rafae, Dhruv Baronia, Akash Kothari, Muchen Xu, Charith Mendis, and Vikram S. Adve. "MISAAL: Synthesis-Based Automatic Generation of Efficient and Retargetable Semantics-Driven Optimizations." Proceedings of the ACM on Programming Languages 9, PLDI (2025): 1269–92. https://doi.org/10.1145/3729301.

Full text

Abstract:

Using program synthesis to select instructions for and optimize input programs is receiving increasing attention. However, existing synthesis-based compilers are faced by two major challenges that prohibit the deployment of program synthesis in production compilers: exorbitantly long synthesis times spanning several minutes and hours; and scalability issues that prevent synthesis of complex modern compute and data swizzle instructions, which have been found to maximize performance of modern tensor and stencil workloads. This paper proposes MISAAL, a synthesis-based compiler that employs a nove

APA, Harvard, Vancouver, ISO, and other styles

10

Baev, Roman Vyacheslavovich, Leonid Vladlenovich Skvortsov, Evgeny Alekseevich Kudryashov, Ruben Arturovich Buchatskiy, and Roman Aleksandrovich Zhuykov. "Prevention of vulnerabilities arising from optimization of code with Undefined Behavior." Proceedings of the Institute for System Programming of the RAS 33, no. 4 (2021): 195–210. http://dx.doi.org/10.15514/ispras-2021-33(4)-14.

Full text

Abstract:

Aggressive optimization in modern compilers may uncover vulnerabilities in program code that did not lead to bugs prior to optimization. The source of these vulnerabilities is in code with undefined behavior. Programmers use such constructs relying on some particular behavior these constructs showed before in their experience, but the compiler is not obliged to stick to that behavior and may change the behavior if it’s needed for optimization since the behavior is undefined by language standard. This article describes approaches to detection and elimination of vulnerabilities arising from opti

APA, Harvard, Vancouver, ISO, and other styles

11

JONES, ALEX K., SHUYI SHAO, YU ZHANG, and RAMI MELHEM. "SYMBOLIC EXPRESSION ANALYSIS FOR COMPILED COMMUNICATION." Parallel Processing Letters 18, no. 04 (2008): 567–87. http://dx.doi.org/10.1142/s0129626408003570.

Full text

Abstract:

Compiled communication can benefit the parallel application design and performance in several ways such as analyzing the communication pattern to optimize a configurable network for performance improvement or to visualize the communication requirements to study and improve the application design. In this article we present symbolic expression analysis techniques in a MPI parallel compiler. Symbolic expression analysis allows the identification and representation of the communication pattern and also assists in the determination of communication phases in MPI parallel applications at compile-ti

APA, Harvard, Vancouver, ISO, and other styles

12

Goos, Gerhard. "Compiler Verification and Compiler Architecture." Electronic Notes in Theoretical Computer Science 65, no. 2 (2002): 1. http://dx.doi.org/10.1016/s1571-0661(04)80392-x.

Full text

APA, Harvard, Vancouver, ISO, and other styles

13

Wang, Qian, and Ralf Jung. "Rustlantis: Randomized Differential Testing of the Rust Compiler." Proceedings of the ACM on Programming Languages 8, OOPSLA2 (2024): 1955–81. http://dx.doi.org/10.1145/3689780.

Full text

Abstract:

Compilers are at the core of all computer architecture. Their middle-end and back-end are full of subtle code that is easy to get wrong. At the same time, the consequences of compiler bugs can be severe. Therefore, it is important that we develop techniques to increase our confidence in compiler correctness, and to help find the bugs that inevitably happen. One promising such technique that has successfully found many compiler bugs in the past is randomized differential testing , a fuzzing approach whereby the same program is executed with different compilers or different compiler settings to

APA, Harvard, Vancouver, ISO, and other styles

14

Schmitz, Lothar. "The visual compiler-compiler SIC (abstract)." ACM SIGPLAN OOPS Messenger 4, no. 2 (1993): 236. http://dx.doi.org/10.1145/157710.157814.

Full text

APA, Harvard, Vancouver, ISO, and other styles

15

Grigorenko, Pavel, Ando Saabas, and Enn Tyugu. "COCOVILA – Compiler-Compiler for Visual Languages." Electronic Notes in Theoretical Computer Science 141, no. 4 (2005): 137–42. http://dx.doi.org/10.1016/j.entcs.2005.05.009.

Full text

APA, Harvard, Vancouver, ISO, and other styles

16

Solé, Marc, and Leonidas Kosmidis. "Compiler Support for an AI-oriented SIMD Extension of a Space Processor." ACM SIGAda Ada Letters 42, no. 1 (2022): 95–99. http://dx.doi.org/10.1145/3577949.3577968.

Full text

Abstract:

In this on going research paper, we present our work on the compiler support for an AI-oriented SIMD Extension, called SPARROW. The SPARROW hardware design has been developed during a recently defended, awardwinning Master Thesis and is targeting Cobham Gaisler's space processors Leon3 and NOEL-V. We present the compiler support we have included in two compiler toolchains, gcc and llvm as well as a SIMD intrinsics library for easy programmability. Compiler modifications are kept to minimum in order to enable incremental qualification of the toolchains. We present our experience working with th

APA, Harvard, Vancouver, ISO, and other styles

17

Yang, Chenyuan, Yinlin Deng, Runyu Lu, et al. "WhiteFox: White-Box Compiler Fuzzing Empowered by Large Language Models." Proceedings of the ACM on Programming Languages 8, OOPSLA2 (2024): 709–35. http://dx.doi.org/10.1145/3689736.

Full text

Abstract:

Compiler correctness is crucial, as miscompilation can falsify program behaviors, leading to serious consequences over the software supply chain. In the literature, fuzzing has been extensively studied to uncover compiler defects. However, compiler fuzzing remains challenging: Existing arts focus on black- and grey-box fuzzing, which generates test programs without sufficient understanding of internal compiler behaviors. As such, they often fail to construct test programs to exercise intricate optimizations. Meanwhile, traditional white-box techniques, such as symbolic execution, are computati

APA, Harvard, Vancouver, ISO, and other styles

18

Kovács, András. "Closure-Free Functional Programming in a Two-Level Type Theory." Proceedings of the ACM on Programming Languages 8, ICFP (2024): 659–92. http://dx.doi.org/10.1145/3674648.

Full text

Abstract:

Many abstraction tools in functional programming rely heavily on general-purpose compiler optimization to achieve adequate performance. For example, monadic binding is a higher-order function which yields runtime closures in the absence of sufficient compile-time inlining and beta-reductions, thereby significantly degrading performance. In current systems such as the Glasgow Haskell Compiler, there is no strong guarantee that general-purpose optimization can eliminate abstraction overheads, and users only have indirect and fragile control over code generation through inlining directives and co

APA, Harvard, Vancouver, ISO, and other styles

19

Chaliasos, Stefanos, Thodoris Sotiropoulos, Georgios-Petros Drosos, Charalambos Mitropoulos, Dimitris Mitropoulos, and Diomidis Spinellis. "Well-typed programs can go wrong: a study of typing-related bugs in JVM compilers." Proceedings of the ACM on Programming Languages 5, OOPSLA (2021): 1–30. http://dx.doi.org/10.1145/3485500.

Full text

Abstract:

Despite the substantial progress in compiler testing, research endeavors have mainly focused on detecting compiler crashes and subtle miscompilations caused by bugs in the implementation of compiler optimizations. Surprisingly, this growing body of work neglects other compiler components, most notably the front-end. In statically-typed programming languages with rich and expressive type systems and modern features, such as type inference or a mix of object-oriented with functional programming features, the process of static typing in compiler front-ends is complicated by a high-density of bugs

APA, Harvard, Vancouver, ISO, and other styles

20

Zimmermann, Wolf, and Thilo Gaul. "On the Construction of Correct Compiler Back-Ends: An ASM-Approach." JUCS - Journal of Universal Computer Science 3, no. (5) (1997): 504–67. https://doi.org/10.3217/jucs-003-05-0504.

Full text

Abstract:

Existing works on the construction of correct compilers have at least one of the following drawbacks: (i) correct compilers do not compile into machine code of existing processors. Instead they compile into programs of an abstract machine which ignores limitations and properties of real-life processors. (ii) the code generated by correct compilers is orders of magnitudes slower than the code generated by unverified compilers. (iii) the considered source language is much less complex than real-life programming languages. This paper focuses on the construction of correct compiler backends which

APA, Harvard, Vancouver, ISO, and other styles

21

Traver, V. Javier. "On Compiler Error Messages: What TheySayand What TheyMean." Advances in Human-Computer Interaction 2010 (2010): 1–26. http://dx.doi.org/10.1155/2010/602570.

Full text

Abstract:

Programmers often encounter cryptic compiler error messages that are difficult to understand and thus difficult to resolve. Unfortunately, most related disciplines, including compiler technology, have not paid much attention to this important aspect that affects programmers significantly, apparently because it is felt that programmers should adapt to compilers. In this article, however, this problem is studied from the perspective of the discipline of human-computer interaction to gain insight into why compiler errors messages make the work of programmers more difficult, and how this situation

APA, Harvard, Vancouver, ISO, and other styles

22

Krastev, Aleksandar, Nikola Samardzic, Simon Langowski, Srinivas Devadas, and Daniel Sanchez. "A Tensor Compiler with Automatic Data Packing for Simple and Efficient Fully Homomorphic Encryption." Proceedings of the ACM on Programming Languages 8, PLDI (2024): 126–50. http://dx.doi.org/10.1145/3656382.

Full text

Abstract:

Fully Homomorphic Encryption (FHE) enables computing on encrypted data, letting clients securely offload computation to untrusted servers. While enticing, FHE has two key challenges that limit its applicability: it has high performance overheads (10,000× over unencrypted computation) and it is extremely hard to program. Recent hardware accelerators and algorithmic improvements have reduced FHE’s overheads and enabled large applications to run under FHE. These large applications exacerbate FHE’s programmability challenges. Writing FHE programs directly is hard because FHE schemes expose a restr

APA, Harvard, Vancouver, ISO, and other styles

23

Ebresafe, Oghenevwogaga, Ian Zhao, Ende Jin, Arthur Bright, Charles Jian, and Yizhou Zhang. "Certified Compilers à la Carte." Proceedings of the ACM on Programming Languages 9, PLDI (2025): 372–95. https://doi.org/10.1145/3729261.

Full text

Abstract:

Certified compilers are complex software systems. Like other large systems, they demand modular, extensible designs. While there has been progress in extensible metatheory mechanization, scaling extensibility and reuse to meet the demands of full compiler verification remains a major challenge. We respond to this challenge by introducing novel expressive power to a proof language. Our language design equips the Rocq prover with an extensibility mechanism inspired by the object-oriented ideas of late binding, mixin composition, and family polymorphism. We implement our design as a plugin for Ro

APA, Harvard, Vancouver, ISO, and other styles

24

Krebs, Nico, and Lothar Schmitz. "Jaccie : A Java-based compiler–compiler for generating, visualizing and debugging compiler components." Science of Computer Programming 79 (January 2014): 101–15. http://dx.doi.org/10.1016/j.scico.2012.03.001.

Full text

APA, Harvard, Vancouver, ISO, and other styles

25

Chitra, A., and G. Sudha Sadasivam. "DESIGN AND IMPLEMENTATION OF A COMPONENTISED IDL COMPILER." Journal of Integrated Design and Process Science: Transactions of the SDPS, Official Journal of the Society for Design and Process Science 6, no. 3 (2002): 75–91. http://dx.doi.org/10.3233/jid-2002-6305.

Full text

Abstract:

An interface definition language (IDL) is a traditional language describing the interfaces between the components. IDL compilers generate stubs that provide communicating processes with the abstraction of local object invocation or procedure call. Typical IDL compilers are limited to a single IDL and target language, but the proposed IDL compiler is based on the insight that IDLs are true languages amenable to modern compilation techniques. Through the support of intermediate language representation called as Abstract Object Interface (AOI), our compiler can support multiple IDLs and target la

APA, Harvard, Vancouver, ISO, and other styles

26

Liu, Jiawei, Yuxiang Wei, Sen Yang, Yinlin Deng, and Lingming Zhang. "Coverage-guided tensor compiler fuzzing with joint IR-pass mutation." Proceedings of the ACM on Programming Languages 6, OOPSLA1 (2022): 1–26. http://dx.doi.org/10.1145/3527317.

Full text

Abstract:

In the past decade, Deep Learning (DL) systems have been widely deployed in various application domains to facilitate our daily life, e.g., natural language processing, healthcare, activity recognition, and autonomous driving. Meanwhile, it is extremely challenging to ensure the correctness of DL systems (e.g., due to their intrinsic nondeterminism), and bugs in DL systems can cause serious consequences and may even threaten human lives. In the literature, researchers have explored various techniques to test, analyze, and verify DL models, since their quality directly affects the corresponding

APA, Harvard, Vancouver, ISO, and other styles

27

Bondorf, Anders, and Jens Palsberg. "Generating action compilers by partial evaluation." Journal of Functional Programming 6, no. 2 (1996): 269–98. http://dx.doi.org/10.1017/s0956796800001684.

Full text

Abstract:

AbstractCompiler generation based on Mosses' action semantics has been studied by Brown, Moura, and Watt, and also by the second author. The core of each of their systems is a handwritten action compiler, producing either C or machine code. We have obtained an action compiler in a much simpler way: by partial evaluation of an action interpreter. Even though our compiler produces Scheme code, the code runs as fast as that produced by the previous action compilers.

APA, Harvard, Vancouver, ISO, and other styles

28

Zuck, Lenore, Amir Pnueli, Yi Fang, and Benjamin Goldberg. "VOC: A Methodology for the Translation Validation of OptimizingCompilers." JUCS - Journal of Universal Computer Science 9, no. (3) (2003): 223–47. https://doi.org/10.3217/jucs-009-03-0223.

Full text

Abstract:

There is a growing awareness, both in industry and academia, of the crucial role of formally verifying the translation from high-level source-code into low-level object code that is typically performed by an optimizing compiler. Formally verifying an optimizing compiler, as one would verify any other large program, is not feasible due to its size, ongoing evolution and modification, and, possibly, proprietary considerations. Translation validation is a novel approach that offers an alternative to the verification of translators in general and compilers in particular: Rather than verifying the

APA, Harvard, Vancouver, ISO, and other styles

29

Dunaev, Pavel Dmitrievich. "Developing a Clang-Based Safe Compiler." Proceedings of the Institute for System Programming of the RAS 36, no. 4 (2024): 27–40. http://dx.doi.org/10.15514/ispras-2024-36(4)-3.

Full text

Abstract:

Due to the use of aggressive optimizations by modern C/C++ compilers that exploit undefined behavior, there is a need for a safe compiler that does not perform such optimizations and prevents developers from using unsafe statements and expressions. Such a safe compiler based on GCC has been developed in ISP RAS, but some developers prefer Clang instead of GCC, which has mainly the same problems of exploiting undefined behavior. This paper examines the capabilities of Clang to perform safe compilation and describes the implementation of a safe compiler based on it. For the created safe compiler

APA, Harvard, Vancouver, ISO, and other styles

30

Singla, Tapodhan, Varun Vashishtha, and Sumeet Singh. "Compiler Construction." Journal of Advance Research in Computer Science & Engineering (ISSN: 2456-3552) 2, no. 5 (2015): 07–14. http://dx.doi.org/10.53555/nncse.v2i5.447.

Full text

Abstract:

Compiler construction is a widely used software engineering exercise, but because most students will not be compiler writers, care must be taken to make it relevant in a core curriculum. The course is suitable for advanced undergraduate and beginning graduate students. Auxiliary tools, such as generators and interpreters, often hinder the learning: students have to fight tool idiosyncrasies, mysterious errors, and other poorly educative issues. It is intended both to provide a general knowledge about compiler design and implementation and to serve as a springboard to more advanced courses. Alt

APA, Harvard, Vancouver, ISO, and other styles

31

ISHIURA, Nagisa. "Compiler Fuzzing." IEICE ESS Fundamentals Review 9, no. 3 (2016): 188–96. http://dx.doi.org/10.1587/essfr.9.3_188.

Full text

APA, Harvard, Vancouver, ISO, and other styles

32

Quiñones, Carlos García, Carlos Madriles, Jesús Sánchez, Pedro Marcuello, Antonio González, and Dean M. Tullsen. "Mitosis compiler." ACM SIGPLAN Notices 40, no. 6 (2005): 269–79. http://dx.doi.org/10.1145/1064978.1065043.

Full text

APA, Harvard, Vancouver, ISO, and other styles

33

Masuda, Nobuyuki. "Intel Compiler." Journal of The Institute of Image Information and Television Engineers 65, no. 9 (2011): 1304–7. http://dx.doi.org/10.3169/itej.65.1304.

Full text

APA, Harvard, Vancouver, ISO, and other styles

34

Eigenmann, Rudi, and Sam Midkiff. "Compiler Infrastructure." International Journal of Parallel Programming 41, no. 6 (2013): 751–52. http://dx.doi.org/10.1007/s10766-013-0250-0.

Full text

APA, Harvard, Vancouver, ISO, and other styles

35

Hall, Mary, David Padua, and Keshav Pingali. "Compiler research." Communications of the ACM 52, no. 2 (2009): 60–67. http://dx.doi.org/10.1145/1461928.1461946.

Full text

APA, Harvard, Vancouver, ISO, and other styles

36

Wu, Chenming, Haisen Zhao, Chandrakana Nandi, Jeffrey I. Lipton, Zachary Tatlock, and Adriana Schulz. "Carpentry compiler." ACM Transactions on Graphics 38, no. 6 (2019): 1–14. http://dx.doi.org/10.1145/3355089.3356518.

Full text

APA, Harvard, Vancouver, ISO, and other styles

37

Dave, Maulik A. "Compiler verification." ACM SIGSOFT Software Engineering Notes 28, no. 6 (2003): 2. http://dx.doi.org/10.1145/966221.966235.

Full text

APA, Harvard, Vancouver, ISO, and other styles

38

Müller, Matthias S. "An OpenMP Compiler Benchmark." Scientific Programming 11, no. 2 (2003): 125–31. http://dx.doi.org/10.1155/2003/287461.

Full text

Abstract:

The purpose of this benchmark is to propose several optimization techniques and to test their existence in current OpenMP compilers. Examples are the removal of redundant synchronization constructs, effective constructs for alternative code and orphaned directives. The effectiveness of the compiler generated code is measured by comparing different OpenMP constructs and compilers. If possible, we also compare with the hand coded "equivalent" solution. Six out of seven proposed optimization techniques are already implemented in different compilers. However, most compilers implement only one or t

APA, Harvard, Vancouver, ISO, and other styles

39

Costagliola, Gennaro, Vincenzo Deufemia, and Giuseppe Polese. "Visual language implementation through standard compiler–compiler techniques." Journal of Visual Languages & Computing 18, no. 2 (2007): 165–226. http://dx.doi.org/10.1016/j.jvlc.2006.06.002.

Full text

APA, Harvard, Vancouver, ISO, and other styles

40

Crowe, Malcolm, Clark Nicol, Michael Hughes, and David Mackay. "On converting a compiler into an incremental compiler." ACM SIGPLAN Notices 20, no. 10 (1985): 14–22. http://dx.doi.org/10.1145/382286.382376.

Full text

APA, Harvard, Vancouver, ISO, and other styles

41

Moon, Sungdo, Byoungro So, and Mary W. Hall. "Combining Compile-Time and Run-Time Parallelization." Scientific Programming 7, no. 3-4 (1999): 247–60. http://dx.doi.org/10.1155/1999/490628.

Full text

Abstract:

This paper demonstrates that significant improvements to automatic parallelization technology require that existing systems be extended in two ways: (1) they must combine high‐quality compile‐time analysis with low‐cost run‐time testing; and (2) they must take control flow into account during analysis. We support this claim with the results of an experiment that measures the safety of parallelization at run time for loops left unparallelized by the Stanford SUIF compiler’s automatic parallelization system. We present results of measurements on programs from two benchmark suites – SPECFP95and N

APA, Harvard, Vancouver, ISO, and other styles

42

ARTIGAS, PEDRO V., MANISH GUPTA, SAMUEL P. MIKIFF, and JOSÉ E. MOREIRA. "AUTOMATIC LOOP TRANSFORMATIONS AND PARALLELIZATION FOR JAVA." Parallel Processing Letters 10, no. 02n03 (2000): 153–64. http://dx.doi.org/10.1142/s0129626400000160.

Full text

Abstract:

This paper describes a prototype Java compiler that achieves performance levels approaching those of current state-of-the-art Fortran compilers on numerical codes. We present a new transformation called alias versioning that takes advantage of the simplicity of pointers in Java. This transformation, combined with other techniques that we have developed, enables the compiler to perform high order loop transformations and parallelization completely automatically. We believe that our compiler is the first to have such capabilities of optimizing numerical Java codes. By exploiting synergies betwee

APA, Harvard, Vancouver, ISO, and other styles

43

Silva, Anderson Faustino da, and Vitor Costa. "An Experimental Evaluation of JAVA JIT Technology." JUCS - Journal of Universal Computer Science 11, no. (7) (2005): 1291–309. https://doi.org/10.3217/jucs-011-07-1291.

Full text

Abstract:

Interpreted languages are widely used due to ease to use, portability, and safety. On the other hand, interpretation imposes a significance overhead. Justin Time (JIT) compilation is a popular approach to improving the runtime performance of languages such as Java. We compare the performance of a JIT compiler with a traditional compiler and with an emulator. We show that the compilation overhead from using JIT is negligible, and that the JIT compiler achieves better overall performance, suggesting the case for aggresive compilation in JIT compilers.

APA, Harvard, Vancouver, ISO, and other styles

44

Yu, Chang, Yi Xu, Ye Kuang, Yuanming Hu, and Tiantian Liu. "MeshTaichi." ACM Transactions on Graphics 41, no. 6 (2022): 1–17. http://dx.doi.org/10.1145/3550454.3555430.

Full text

Abstract:

Meshes are an indispensable representation in many graphics applications because they provide conformal spatial discretizations. However, mesh-based operations are often slow due to unstructured memory access patterns. We propose MeshTaichi, a novel mesh compiler that provides an intuitive programming model for efficient mesh-based operations. Our programming model hides the complex indexing system from users and allows users to write mesh-based operations using reference-style neighborhood queries. Our compiler achieves its high performance by exploiting data locality. We partition input mesh

APA, Harvard, Vancouver, ISO, and other styles

45

Kremer, Ulrich. "Optimal and Near–Optimal Solutions for Hard Compilation Problems." Parallel Processing Letters 07, no. 04 (1997): 371–78. http://dx.doi.org/10.1142/s0129626497000371.

Full text

Abstract:

An optimizing compiler typically uses multiple program representations at different levels of program and performance abstractions in order to be able to perform transformations that – at least in the majority of cases – will lead to an overall improvement in program performance. The complexities of the program and performance abstractions used to formulate compiler optimization problems have to match the complexities of the high–level programming model and of the underlying target system. Scalable parallel systems typically have multi–level memory hierarchies and able to exploit coarse–grain

APA, Harvard, Vancouver, ISO, and other styles

46

Shreyas Madhav, A. V., Siddarth Singaravel, and A. Karmel. "Memory Utilization and Machine Learning Techniques for Compiler Optimization." ITM Web of Conferences 37 (2021): 01021. http://dx.doi.org/10.1051/itmconf/20213701021.

Full text

Abstract:

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 perfor

APA, Harvard, Vancouver, ISO, and other styles

47

Vishakha, Agrawal. "Challenges and Complexities in Enabling Compilers to Automatically Optimize Code." International Journal of Innovative Research in Engineering & Multidisciplinary Physical Sciences 8, no. 1 (2020): 1–5. https://doi.org/10.5281/zenodo.14684736.

Full text

Abstract:

Enabling compilers to automatically optimize code poses significant scientific and engineering challenges. This pa- per provides a comprehensive examination of the fundamental limitations, practical constraints, and emerging solutions in compiler optimization. We delve into the intricate trade-offs between optimization efficacy, compilation time, and resource utilization, as well as the complexities introduced by modern programming paradigms, heterogeneous hardware architectures, and evolving computing paradigms. By exploring the frontiers of compiler optimization, this research aims to illumi

APA, Harvard, Vancouver, ISO, and other styles

48

Kwon, Jaeseong, Bongjun Jang, Juneyoung Lee, and Kihong Heo. "Optimization-Directed Compiler Fuzzing for Continuous Translation Validation." Proceedings of the ACM on Programming Languages 9, PLDI (2025): 627–50. https://doi.org/10.1145/3729275.

Full text

Abstract:

Incorrect compiler optimizations can lead to unintended program behavior and security vulnerabilities. However, the enormous size and complexity of modern compilers make it challenging to ensure the correctness of optimizations. The problem becomes more severe as compiler engineers continuously add new optimizations to improve performance and support new language features. In this paper, we propose Optimuzz, a framework to effectively detect incorrect optimization bugs in such continuously changing compilers. The key idea is to combine two complementary techniques: directed grey-box fuzzing an

APA, Harvard, Vancouver, ISO, and other styles

49

Livinskii, Vsevolod, Dmitry Babokin, and John Regehr. "Fuzzing Loop Optimizations in Compilers for C++ and Data-Parallel Languages." Proceedings of the ACM on Programming Languages 7, PLDI (2023): 1826–47. http://dx.doi.org/10.1145/3591295.

Full text

Abstract:

Compilers are part of the foundation upon which software systems are built; they need to be as correct as possible. This paper is about stress-testing loop optimizers; it presents a major reimplementation of Yet Another Random Program Generator (YARPGen), an open-source generative compiler fuzzer. This new version has found 122 bugs, both in compilers for data-parallel languages, such as the Intel® Implicit SPMD Program Compiler and the Intel® oneAPI DPC++ compiler, and in C++ compilers such as GCC and Clang/LLVM. The first main contribution of our work is a novel method for statically avoidin

APA, Harvard, Vancouver, ISO, and other styles

50

Watkins, George, Hoang Minh Nguyen, Keelan Watkins, Steven Pearce, Hoi-Kwan Lau, and Alexandru Paler. "A High Performance Compiler for Very Large Scale Surface Code Computations." Quantum 8 (May 22, 2024): 1354. http://dx.doi.org/10.22331/q-2024-05-22-1354.

Full text

Abstract:

We present the first high performance compiler for very large scale quantum error correction: it translates an arbitrary quantum circuit to surface code operations based on lattice surgery. Our compiler offers an end to end error correction workflow implemented by a pluggable architecture centered around an intermediate representation of lattice surgery instructions. Moreover, the compiler supports customizable circuit layouts, can be used for quantum benchmarking and includes a quantum resource estimator. The compiler can process millions of gates using a streaming pipeline at a speed geared

APA, Harvard, Vancouver, ISO, and other styles

We offer discounts on all premium plans for authors whose works are included in thematic literature selections. Contact us to get a unique promo code!