The LR(k)-parsing algorithm is derived, i.e., presented and proved as an interplay between program development and parsing theory. The program development uses invariants and the new concept of weakest angelic precond...
详细信息
The LR(k)-parsing algorithm is derived, i.e., presented and proved as an interplay between program development and parsing theory. The program development uses invariants and the new concept of weakest angelic precondition. The parsing theory involved relates rightmost derivability to three other transitive relations on strings. The usual stack of item sets and the finite automaton appear in an optimisation of the abstract algorithm.
We have developed a research compiler for Java class files. The compiler, which we call Briki, is designed to test new compilation techniques, We focus on optimizations which are only possible or much easier to perfor...
详细信息
We have developed a research compiler for Java class files. The compiler, which we call Briki, is designed to test new compilation techniques, We focus on optimizations which are only possible or much easier to perform on a high-level intermediate representation, We have designed such a representation, JavaIR, and have written a front-end which recovers the high-level structure from the information from the class file, Some of the high-level optimizations can be performed by the Java compiler which produces the class file, There is;however, a set of machine-dependent optimizations which have to be customized for the specific architecture and so can only be performed when the machine code is generated from the bytecodes, e.g. in a just-in-time (JIT) compiler, We choose memory hierarchy optimizations as an example of machine-dependent techniques. We show that there is an intersection of the set of machine-dependent optimizations and the set of high-level optimizations, One such example is array remapping, which requires multi-dimensional array references which are not present in the bytecodes and at the same time requires information about memory organization and the mapping of bytecodes to machine instructions. We develop a set of optimizations for accessing array elements and object fields and show their impact on a set of benchmarks which we run on two machines with a JIT compiler The execution times are reduced by as much as 50% and we argue that the improvement could be even higher with a more mature JIT technology. (C) 1997 by John Wiley & Sons, Ltd.
Sophisticated optimization in modern compilers can sometimes create vulnerabilities in program code as a result of optimization. The source of these vulnerabilities is in code with undefined behavior. programmers use ...
详细信息
Sophisticated optimization in modern compilers can sometimes create vulnerabilities in program code as a result of optimization. The source of these vulnerabilities is in code with undefined behavior. programmers use constructs with undefined behavior while relying on a particular behavior these constructs exhibited before in their practice. However, the compiler does not have to stick to that behavior and may change it if there is a need for code optimization because this behavior is not defined by language standards. This paper describes some approaches to the discovery and elimination of vulnerabilities caused by optimization in the case where the source code is available, but its modification is undesirable or impossible. We propose the concept of a safe compiler (i.e., a compiler that guarantees that no vulnerability is brought into a program in the process of optimization). We describe the implementation of this compiler on top of GCC. The functionality of the safe compiler is implemented at three security levels, the applicability of which is discussed in this paper. The use of the safe compiler is illustrated on real-world codebases with the estimation of possible performance losses.
Distributed-memory systems are potentially scalable to a very large number of processors and promise to be powerful tools for solving large-scale scientific and engineering problems. However, these machines are curren...
详细信息
Distributed-memory systems are potentially scalable to a very large number of processors and promise to be powerful tools for solving large-scale scientific and engineering problems. However, these machines are currently difficult to program, since the user has to distribute the data across the processors and explicitly formulate the communication required by the program under the selected distribution. During the past years, language extensions of standard programming languages such as Fortran were developed that allow a concise formulation of data distribution, and new compilation methods were designed and implemented that allow the programming of such machines at this relatively high level. In this paper, we describe the current state of the art in compiling procedural languages (in particular, Fortran) for distributed-memory machines, analyze the limitations of these approaches, and outline future research.
To attract more technical programmers to high-performance computing platforms, vendors have developed programming language extensions designed to exploit parallel processors. This article provides an overview of langu...
详细信息
To attract more technical programmers to high-performance computing platforms, vendors have developed programming language extensions designed to exploit parallel processors. This article provides an overview of language support for parallel technical computing. It describes the rationale for multithreaded languages, in which the programmer explicitly specifies what work is to be carried out by multiple processors and how their activities should be coordinated. Discussion begins with an introduction to the general models for manipulating multiple threads and how they are incorporated into programming languages. This is followed by sections describing the wide variety of features for creating multiple threads, scheduling their execution, synchronizing their activities, and sharing data among them. Examples in a simplified, Fortran-like notation accompany the text. A separate section summarizes how the language features are currently distributed among commercial compiler implementations. Some less traditional approaches to multithreaded language support are then presented to provide a glimpse at what might be expected in future languages and compilers.
This paper presents a new approach to solving the DSP address code generation problem. A minimum cost circulation approach is used to efficiently generate high-performance addressing code in polynomial time. Results s...
详细信息
This paper presents a new approach to solving the DSP address code generation problem. A minimum cost circulation approach is used to efficiently generate high-performance addressing code in polynomial time. Results show that addressing code size improvements of up to 6x are obtained, accounting for up to 1.6x improvement in code size and performance of compiler-generated DSP code. This research is important for industry since this value-added technique can improve code size, energy dissipation, and performance, without increasing cost.
The paper describes the implementation of an 'intelligent' silicon compiler that provides the ability to optimise a design, given as a behavioural description, with respect to multiple objectives. The user sub...
详细信息
The paper describes the implementation of an 'intelligent' silicon compiler that provides the ability to optimise a design, given as a behavioural description, with respect to multiple objectives. The user submits goals or objectives to the system, named MOODS, which automatically finds an optimal solution in the context of the user-specified constraints. The MOODS system provides a sound basis for multiple objective optimisation and allows the user to characterise and explore the design space. An accurate representation of the implementations in the design space is ensured by feeding up technology-dependent information from a cell library. This data is used in a global cost function which guides the application of transformations on a multilevel representation of the design. The results obtained show that designs can be produced which meet users' objectives and that a varied set of implementations can be synthesised from a single behavioural specification. The resulting characteristics of the set of implementations enable the design space to be characterised.
This article presents approaches for performance improvements into two large and well-known open source projects, Git and GNU Compiler Collection, using parallel programming. We share the difficulties faced and the st...
详细信息
This article presents approaches for performance improvements into two large and well-known open source projects, Git and GNU Compiler Collection, using parallel programming. We share the difficulties faced and the strategies used, concluding with a set of lessons learned that are useful to similar parallelization processes.
The ability to predict the directions of branches, especially conditional branches, is an important problem in modern computer architecture and advanced compilers. Many static and dynamic techniques have been proposed...
详细信息
The ability to predict the directions of branches, especially conditional branches, is an important problem in modern computer architecture and advanced compilers. Many static and dynamic techniques have been proposed, Today, all state-of-the-art microprocessors have some form of hardware support for dynamic branch prediction. Static techniques, on the other hand, have not been widely studied because of the belief that they give poorer results. However, good static branch predictions are invaluable information for (static) compiler optimization or performance estimation. In this paper, we propose performing static branch prediction at the source code level. The assumption is that the source code contains information unavailable at the assembly or machine code level that may be used for branch prediction, Empirical studies on 14 integer Spec benchmarks indicate that the simple heuristics proposed can be effective ire practice.
Ada was developed to become the standard high-order programming language for all U.S. Department of Defense embedded applications. Because of its general purpose nature and the fact that it is based on sound software ...
详细信息
Ada was developed to become the standard high-order programming language for all U.S. Department of Defense embedded applications. Because of its general purpose nature and the fact that it is based on sound software engineering principles, various commercial organizations are interested in adopting it as their standard high-order language. To date, relatively few commercial practitioners have embraced this language. The two main reasons cited have been: 1) lack of efficent compilers, and 2) high initial cost of using Ada. This paper summarizes the results of our efforts in attempting to address these basic concerns. We have benchmarked several Ada compliers targeted to different commercial microprocessors. This benchmarking activity included obtaining the execution time as well as the memory requirements of Ada compilers and comparing them with compilers for traditional languages like Pascal. In order to determine the cost impact of using Ada, we have developed a model from first principles. The model predicts the cost of using Ada compared to other high-order languages and encompasses the developmental phase as well as the maintenance phase. The model is further refined to include the impact of reusing software. Based on these data, we have concluded that Ada technology has matured enough to be used in the embedded environment and can represent a potential cost savings compared to other languages over the entire life cycle.
暂无评论