China
Africa
Explore chapters and articles related to this topic
Low-Power/Energy Compiler Optimizations
Published in Christian Piguet, Low-Power Processors and Systems on Chips, 2018
Optimizing compilers perform program analyses and transformations at different levels of program abstraction, ranging from source code and intermediate code, such as three-address code, to assembly and machine code. Analyses and transformations can have different scopes. They can be performed within a single basic block (local), across basic blocks but within a procedure (global), or across procedure boundaries (interprocedural). Traditionally, optimizing compilers try to reduce overall program execution time or resource usage such as memory. The actual compilation process can be done before program execution (static compilation) or during program execution (dynamic compilation). This large design space is the main challenge for compiler writers. Many trade-offs have to be considered to justify the development and implementation of a particular optimization pass or strategy; however, every compiler optimization needs to address the following three issues:
Parallel Architectures
Published in Pranabananda Chakraborty, Computer Organisation and Architecture, 2020
A user usually has an architecture-transparent view, and always intends to develop application programs and programming environments, essentially to be machine-independent so that those can be ported to many different computing environments straightaway, or may be with minimum conversion costs. The system programmers, on other hand, are more inclined to explore the different attributes provided by the hardware, and try to make use of them effectively. The operating system (OS) itself and its various functionalities, including communication mechanisms used by different processing resources, are different for different class of machines, and are mostly machine-dependent. High-level languages and associated compilers or communication models mostly depend on the architectural aspects, and options are utilized in their implementation. The use of optimizing compilers can facilitate the extraction of the best of the system facilities in favour of the languages being used, and thereby improve the system performance as well. However, the OS support and compilers should be designed in a befitting manner so that as many architectural constraints as possible faced by the users can be removed or, at least, can be reduced. Programming languages such as Linda, Ada, Lisp, Pascal, C, C++, Fortran, and others mostly offer an architecture-transparent communication model for parallel computers, and usually provide numerous features for ease and convenience of application program development. All these and similar other aspects are essentially involved in developing the computing environment, and a proficient architect, after all, should view the entire scenario as a whole, and not by individual parts (Zorpetta, G.,).
O
Published in Phillip A. Laplante, Dictionary of Computer Science, Engineering, and Technology, 2017
optimizing compiler a compiler which is able to perform optimizations during the compilation process to minimize the resulting code along one or more metrics such as code size, execution speed, data size, or other metrics established by the writer of the compiler. Since many of the computations are either NP-hard or involve undecidable problems, there is no guarantee that the resulting code is actually optimum.
Arbogast : Higher order automatic differentiation for special functions with Modular C
Published in Optimization Methods and Software, 2018
Isabelle Charpentier, Jens Gustedt
In our opinion, the lack of performance of ADOL-C is due to an unfortunate combination of two strategies that makes the code optimization by the compiler very difficult. First, the trace code uses a lot of indirections that are inherent to the operator overloading technique. They are quite challenging to any optimizing compiler, because of their side effects and their aliasing and because they interrupt the ‘natural’ control flow of the application. But second, during the forward phase the sequence of operations is not directly visible to the compiler, but interpreted dynamically at runtime from the trace. Thus, optimization opportunities that could profit from compile time knowledge about a whole sequence of operations may be missed.
Efficient ray-tracing procedure for radio wave propagation modeling using homogeneous geometric algebra
Published in Electromagnetics, 2020
Ahmad H. Eid, Heba Y. Soliman, Sherif M. Abuelenin
In this article we discuss the utilization of GA in the development of an electromagnetic RT propagation modeling algorithm. GA is used in representing the main geometric-processing steps of the algorithm, which are the main computational bottleneck in ray-tracing. The algorithm is implemented using generative programming (Czarnecki and Eisenecker 2000). An optimizing compiler called GMac is utilized for code generation. The GA-based development leads to an efficient and robust implementation, and the unifying nature of GA allows the evaluation of both 2D and 3D RT scenarios using the same algorithm.
Divide-and-conquer checkpointing for arbitrary programs with no user annotation
Published in Optimization Methods and Software, 2018
Jeffrey Mark Siskind, Barak A. Pearlmutter
We have exhibited a very aggressive compiler (Stalin∇) for vlad that ameliorates some of these issues. It unboxes double precision numbers and implements AD via source-code transformation instead of operator overloading as is done by checkpointVLAD. This allows it to have numerical performance rivaling Fortran. While it does not support constant-time array access and update, methods that are well-known in the programming languages community (e.g. monads and uniqueness types) can be used for that. But it does not include support for divide-and-conquer checkpointing. However, there is no barrier, in principle, to supporting divide-and-conquer checkpointing, of the sort described above, in an aggressive optimizing compiler that implements AD via source-code transformation. One would simply need to reformulate the source-code transformations that implement AD, along with the aggressive compiler optimizations, in CPS instead of direct style. Moreover, the techniques presented here could be integrated into other compilers for other languages that generate target code in CPS by instrumenting the CPS conversion with step counting, step limits, and limit-check interruptions.11 A driver can be wrapped around such code to implement . For example, existing compilers, like sml/nj [4], for functional languages like sml, already generate target code in CPS, so it seems feasible to adapt their techniques to the purpose of AD with divide-and-conquer checkpointing. In fact, the overhead of the requisite instrumentation for step counting, step limits, and limit-check interruptions need not be onerous because the step counting, step limits, and limit-check interruptions for basic blocks can be factored, and those for loops can be hoisted, much as is done for the instrumentation needed to support storage allocation and garbage collection in implementations like MLton [27], for languages like sml, that achieve very low overhead for automatic storage management.