Compile time data transfer analysis

—Compiler construction primarily comprises of some standard phases such as lexical analysis, syntax analysis, semantic analysis, intermediate code generation, code optimization and target code generation but due to the improvement in computer architectural designs, there is a need to improve on the code size, instruction execution speed, etc. Hence, today better and more efficient compiler analysis and optimization techniques such as advanced dataflow analysis, leaf function optimization, cross-linking optimizations, etc. are adopted to meet with the latest trend in hardware technology and generate better target codes for recent machines.

2019

Present day compilers have profusion of code modification. But all most all compiler follow same old method to optimize code and they apply predetermined sequence like scanning, lexing, analyzing syntax and analyzing semantics followed by generating intermediary code and finally generating target code. Thus optimizing functions without interpreting whether code is getting modified or not we can’t assure that after compilation it uses less resources and faster execution. In order to overcome this problem, techniques like Reverse-Inlining (Procedural Abstraction), Cross Linking optimization, trace inlining, Optimizing Leaf Function, Combined code motion and allocation of registers etc are used which are more efficient and generated better machine codes. As trace inlining technique helps in analyzing enforcement and size of low level code generated. Various inlining rules on the benchmark suites DaCapo 9.12 Bach, SPECjbb2005, and SPECjvm2008 are assessed, proved that compilers based on...

We describe two ongoing compiler projects for high performance architectures at the University of Maryland being developed us- ing the Stanford SUIF compiler infrastructure. First, we are in- vestigating the impact of compilation techniques for eliminat- ing synchronization overhead in compiler-parallelized programs running on software distributed-shared-memory (DSM) systems. Second, we are evaluating data layout transformations to im- prove cache performance on uniprocessors by eliminating conflict misses through inter- and intra-variable padding. Our optimiza- tions have been implemented in SUIF and tested on a number of programs. Preliminary results are encouraging.

2008 Eighth IEEE International Working Conference on Source Code Analysis and Manipulation, 2008

Static profiling is a technique that produces estimates of execution likelihoods or frequencies based on source code analysis only. It is frequently used in determining cost/benefit ratios for certain compiler optimizations. In previous work, we introduced a simple algorithm to compute execution likelihoods, based on a control flow graph and heuristic branch prediction.

Proceedings of the ACM on Programming Languages

Modern compiler optimization is a complex process that offers no guarantees to deliver the fastest, most efficient target code. For this reason, compilers struggle to produce a stable performance from versions of code that carry out the same computation and only differ in the order of operations. This instability makes compilers much less effective program optimization tools and often forces programmers to carry out a brute force search when tuning for performance. In this paper, we analyze the stability of the compilation process and the performance headroom of three widely used general purpose compilers: GCC, ICC, and Clang. For the study, we extracted over 1,000 for loop nests from well-known benchmarks, libraries, and real applications; then, we applied sequences of source-level loop transformations to these loop nests to create numerous semantically equivalent mutations ; finally, we analyzed the impact of transformations on code quality in terms of locality, dynamic instructio...

2006

Executing sequential code in parallel on a multithreaded machine has been an elusive goal for many years. It has recently become quite important due to the widespread introduction of multi-cores in PCs. Automatic multi-threading could not be achieved so far because classic compiler analysis was not powerful enough and program behavior was found to be in many cases input dependent. Run time, speculative thread level parallelization, introduced in 1995, was a welcome but somewhat different avenue for advancing parallelization coverage. In this paper we introduce a novel analysis technique, Hybrid Analysis (HA), which unifies static and dynamic memory reference techniques into a seamless compiler framework which extracts almost maximum available parallelism from scientific codes and generates minimum run time overhead. We will present how we can extract maximum information from the quantities that could not be sufficiently analyzed through static compiler methods and generate sufficien...

Sigplan Notices, 1998

aimed at reducing the impact of memory operations on execution speed have long concentrated on improving cache performance.

Lecture Notes in Computer Science, 2002

In recent years, static analysis has increasingly been applied to the problem of program verification. Systems for program verification typically use precise and expensive interprocedural dataflow algorithms that are difficult to scale to large programs. An attractive way to scale these analyses is to use a preprocessing step to reduce the number of dataflow facts propagated by the analysis and/or the number of statements to be processed, before the dataflow analysis is run. This paper describes an approach that achieves this effect. We first run a scalable, control-flow-insensitive pointer analysis to produce a conservative representation of value flow in the program. We query the value flow representation at the program points where a dataflow solution is required, in order to obtain a conservative over-approximation of the dataflow facts and the statements that must be processed by the analysis. We then run the dataflow analysis on this "slice" of the program. We present experimental evidence in support of our approach by considering two client dataflow analyses for program verification: typestate analysis, and software model checking. We show that in both cases, our approach leads to dramatic speedups.

Real-Time Systems, 2010

International Symposium on Code Generation and Optimization, 2004. CGO 2004., 2004

This paper describes LLVM (Low Level Virtual Machine), a compiler framework designed to support transparent, lifelong program analysis and transformation for arbitrary programs, by providing high-level information to compiler transformations at compile-time, link-time, run-time, and offline. LLVM defines a common, low-level code representation in Static Single Assignment (SSA) form, with several novel features: a simple, language-independent type-system that exposes the primitives commonly used to implement high-level language features; an instruction for typed address arithmetic; and a simple mechanism that can be used to implement the exception handling features of high-level languages (and setjmp/longjmp in C) uniformly and efficiently. The LLVM compiler framework and code representation together provide a combination of key capabilities that are important for practical, lifelong analysis and transformation of programs. To our knowledge, no existing compilation approach provides all these capabilities. We describe the design of the LLVM representation and compiler framework, and evaluate the design in three ways: (a) the size and effectiveness of the representation, including the type information it provides; (b) compiler performance for several interprocedural problems; and (c) illustrative examples of the benefits LLVM provides for several challenging compiler problems.