Program analysis for compiler validation

Microbenchmarking evaluates, in isolation, the execution time of small code segments that play a critical role in large applications. The accuracy of a microbenchmark depends on two critical tasks: wrap the code segment into a payload that faithfully recreates the execution conditions of the large application; build a scaffold that runs the payload a large number of times to get a statistical estimate of the execution time. While recent frameworks such as the Java Microbenchmark Harness (JMH) address the scaffold challenge, developers have very limited support to build a correct payload. This work focuses on the automatic generation of payloads, starting from a code segment selected in a large application. Our generative technique prevents two of the most common mistakes made in microbenchmarks: dead code elimination and constant folding. A microbenchmark is such a small program that can be “over-optimized” by the JIT and result in distorted time measures, if not designed carefully. Our technique automatically extracts the segment into a compilable payload and generates additional code to prevent the risks of “over-optimization”. The whole approach is embedded in a tool called AutoJMH, which generates payloads for JMH scaffolds. We validate the capabilities AutoJMH, showing that the tool is able to process a large percentage of segments in real programs. We also show that AutoJMH can match the quality of payloads handwritten by performance experts and outperform those written by professional Java developers without experience in microbenchmarking.

We introduce a new approach, Dynamic Common Sub-expression Elimination (CSE), that dynamically eliminates common sub- expressions based on new opportunities created during scheduling of control-intensive designs. Classical CSE techniques fail to eliminate several common sub-expressions in control-intensive designs due to the presence of a complex mix of control and data-flow. Aggressive speculative code motions employed to schedule control-intensive designs often re-order, speculate and duplicate operations, hence changing the control flow between the operations with common sub-expressions. This leads to new opportunities for applying CSE dynamically. We have implemented dynamic CSE in a high-level synthesis framework called Spark and present results for experiments performed using various combinations of CSE and dynamic CSE. The benchmarks used consist of four functional blocks derived from two moderately complex industrial-strength applications, namely, MPEG-1 and the GIMP image processing tool. Our dynamic CSE techniques result in improvements of up to 22% in the controller size and up to 31% in performance; easily surpassing the improvements obtained by the traditional CSE approach. We also observe an unexpected (and significant) reduction in the number of registers using our approach.

An analysis is given for optimizing run-time range checks in regions of high execution frequency. These optimizations are accomplished using strength reduction, code motion and common subexpression elimination. Test programs, using the above optimizations, are used to illustrate run-time improvements.

Translation validation is an alternative to the verification of translators (compilers, code generators). Rather than proving in advance that the compiler always produces a target code which correctly implements the source code (compiler verification), each individual translation (i.e. a run of the compiler) is followed by a validation phase which verifies that the target code produced on this run correctly implements the submitted source program. In order to be a practical alternative to compiler verification, a key feature of this validation is its full automation. Since the validation process attempts to unravel the transformation effected by the translators, its task becomes increasingly more difficult (and necessary) with the increase of sophistication and variety of the optimizations methods employed by the translator. In this paper we address the practicability of translation validation for highly optimizing, industrial code generators from Signal, a widely used synchronous language, to C. We introduce new abstraction techniques as part of the automation of our approach.

This paper demonstrates that interprocedural optimization yields significant performance benefits. A classification is presented that encapsulates a subprogram's side-effects into a single attribute. This classification is then used to extend the Common Subexpression Elimination, Dead Code Elimination, and Invariant Hoisting optimizations to include subprogram calls. These extensions reduce the number of subprogram calls thus improving execution speed. Quantitative results are given for both benchmarks and applications.

This paper presents a unified framework for program optimization which subsumes (i) Loop invariant code motion, (ii) Common subexpression elimination, and (iii) Strength reduction. Use of this framework is shown to eliminate the control flow analysis costs and to widen the scope of conventional strength reduction.

Source-to-source code translation automatically translates a program from one programming language to another. The existing research on code translation evaluates the effectiveness of their approaches by using either syntactic similarities (e.g., BLEU score), or test execution results. The former does not consider semantics, the latter considers semantics but falls short on the problem of insufficient data and tests. In this paper, we propose MBTA (Mutation-based Code Translation Analysis), a novel application of mutation analysis for code translation assessment. We also introduce MTS (Mutation-based Translation Score), a measure to compute the level of trustworthiness of a translator. If a mutant of an input program shows different test execution results from its translated version, the mutant is killed and a translation bug is revealed. Fewer killed mutants indicate better code translation. MBTA is novel in the sense that mutants are compared to their translated counterparts, and not to their original program’s translation. We conduct a proof-of-concept case study with 612 Java-Python program pairs and 75,082 mutants on the code translators TransCoder and j2py to evaluate the feasibility of MBTA. The results reveal that TransCoder and j2py fail to translate 70.44% and 70.64% of the mutants, respectively, i.e., more than two-thirds of all mutants are incorrectly translated by these translators. By analysing the MTS results more closely, we were able to reveal translation bugs not captured by the conventional comparison between the original and translated programs.

Superblocks represent regions in a program code that consist of multiple basic blocks. Compilers benefit from this structure since it enables optimization across block boundaries. This increased optimization potential was thoroughly studied in the past for average-case execution time (ACET) reduction at assembly level. In this paper, the concept of superblocks is exploited for the optimization of embedded real-time systems that have to meet stringent timing constraints specified by the worst-case execution time (WCET). To achieve this goal, our superblock formation is based on a novel trace selection algorithm which is driven by WCET data. Moreover, we translate superblocks for the first time from assembly to source code level. This approach enables an early code restructuring in the optimizer, providing more optimization opportunities for both subsequent source code and assembly level transformations. An adaption of the traditional optimizations common subexpression and dead code elimination to our WCET-aware superblocks allows an effective WCET reduction. Using our techniques, we significantly outperform standard optimizations and achieve an average WCET reduction of up to 10.2% for a total of 55 real-life benchmarks.

Instruction schedulers employ code motion as a means of instruction reordering to enable scheduling of instructions at points where the resources required for their execution are available. In addition, driven by the profiling data, schedulers take advantage of predication and speculation for aggressive code motion across conditional branches. Optimization algorithms for partial dead code elimination (PDE) and partial redundancy elimination (PRE) employ code sinking and hoisting to enable optimization. However, unlike instruction scheduling, these optimization algorithms are unaware of resource availability and are incapable of exploiting profiling information, speculation, and predication. In this paper we develop data flow algorithms for performing the above optimizations with the following characteristics: (i) opportunities for PRE and PDE enabled by hoisting and sinking are exploited; (ii) hoisting and sinking of a code statement is driven by availability of functional unit resources; (iii) predication and speculation is incorporated to allow aggressive hoisting and sinking; and (iv) path profile information guides predication and speculation to enable optimization.

Specific amino acid recognition by aspartyl-tRNA synthetase studied by free energy simulations

We address the problem of program partitioning: dividing a program into isolated compartments that communicate via remote procedure calls to follow a security policy. Existing solutions for C programs often use a simple model that offers only “sensitive or not” control and do not provide formal guarantees of partition correctness. We present a C program partitioner for security-conscious applications that addresses these shortcomings through annotation with fine-grained security constraints (chiefly, declassification of sensitive data to select parties); from these annotations, we automatically determine a partition and auto-generate code for marshaling, serialization, and remote procedure calls. We provide post-partition verification, which leverages translation validation to show that output program partitions are behaviorally equivalent to their input programs and satisfy the security policy specified by annotations. We present results that show our approach is practical when partitioning large realistic C applications with non-trivial security constraints.

The aim of this research study was to map nursing diagnoses and interventions documented and observed in a neonatal ICU to the Clinical Care Classification system and to validate the translation of these mapped diagnoses and interventions into Persian. This descriptive research used directed content analysis to map diagnoses and interventions to the Clinical Care Classification. Documentation reports of nursing care were extracted from a paper-based documentation system for infants hospitalized in April, May, and June 2011. Observations of care were conducted and compared with documentation to itemize any interventions not included in the documented record. Documented reports of nurses' care and recorded observations were analyzed through directed content analysis, and obtained expressions were mapped to the diagnoses and intervention coding system of the Clinical Care Classification and translated into Persian. Validation of the subsequent code translation was obtained from nursing experts using the Delphi method in two rounds. Findings showed the most frequent nursing diagnoses were related to respiratory condition of infants such as mechanical ventilation dependency (21.1%), and the most frequent nursing interventions were related to completing physician orders such as blood sampling and medication administration (23.9%). Only 47.8% of Clinical Care Classification diagnoses and interventions codes were reflected in the data set. The relatively low rate of nursing care documented in therecords could be due to both the lack of a nursingcare delivery framework, such as the nursing process, and the lack of any framework or standardization in the documentation system in this setting. Using a framework for care delivery and a coding system for documentation of care such as the ClinicalCare Classification would allow for the more complete documentation of nursing care and subsequently the ability to track and analyze this care.

Accurate aminoacyl-tRNA synthesis is essential for correct translation of the genetic code in all organisms. Whereas many aspects of this process are conserved, others display a surprisingly high level of divergence from the canonical Escherichia coli model system. These differences are most pronounced in archaea where novel mechanisms have recently been described for aminoacylating tRNAs with asparagine, cysteine, glutamine and lysine. Whereas these mechanisms were initially assumed to be uniquely archaeal, both the alternative asparagine and lysine pathways have subsequently been demonstrated in numerous bacteria. Similarly, studies of the means by which archaea insert the rare amino acid selenocysteine in response to UGA stop codons have helped provide a better understanding of both archaeal and eukaryal selenoprotein synthesis. Most recently a new co-translationally inserted amino acid, pyrrolysine, has been found in archaea although again there is some suggestion that it may also be present in bacteria. Thus, whereas archaea contain a preponderance of non-canonical aminoacyl-tRNA synthesis systems most are also found elsewhere albeit less frequently.

Aminoacyl-tRNA synthetase (aaRS) catalyzes the esterbond formation between the cognate amino acid andtRNA(s). The aminoacylation of tRNA is carried out in atwo-step reaction, the formation of an active intermediate(aminoacyl-adenylate or aa-AMP) from the amino acidand ATP, and the transfer of the aminoacyl moiety of theaa-AMP to the 3′ terminal adenosine (A76) of the tRNA.Strict recognition of both the amino acid and the tRNA bythe aaRS ensures the correct translation of the genetic code...

Hybrid transactional and analytical processing (HTAP) systems like SAP HANA make it much simpler to manage both operational load and analytical queries without ETL, separate data warehouses, et al. To represent both transactional and analytical business logic in a single database system, stored procedures are often used to express analytical queries using control flow logic and DMLs. Optimizing these complex procedures requires a fair knowledge of imperative programming languages as well as the declarative query language. Therefore, unified optimization techniques considering both program and query optimization techniques are essential for achieving optimal query performance. In this paper, we propose a novel unified optimization technique for efficient iterative query processing. We present a notion of query motion that allows the movement of SQL queries in and out of a loop. Additionally, we exploit a new cost model that measures the quality of the execution plan with consideration for queries and loop iterations. We describe our experimental evaluation that demonstrates the benefit of our technique using both a standard decision support benchmark and real-world workloads. An extensive evaluation shows that our unified optimization technique enumerates plans that achieve performance improvements of up to an order of magnitude faster than plans generated by the existing loop-invariant code motion technique.