Compiler System Research Articles

DESIGNING A MANAGEMENT FRAMEWORK FOR STRATEGIC ENVIRONMENTAL ASSESSMENT OF URBAN PLANS IN CHINA

Based on the revision of the Methods for Urban Plan Formulation and the Technical Guidelines of Environmental Impact Assessment for Urban Master Plan (in draft), this paper proposes a management framework for Strategic Environmental Assessment (SEA) of Urban Plans. In this context, the urban plan compilation system and the requirements for Urban Plan SEAs are explained. This is followed by the introduction of three types of urban plan SEAs, namely forecasting SEA, monitoring or follow-up SEA, and retrospective SEA. The relationship among the institutions/agencies involved in urban planning SEAs is discussed and three implementation modes are proposed, including an internal-implementation mode, an external-implementation mode and a mixed-implementation mode. Finally, substantive SEA aspects for various types of urban plans are identified.

Mostly static program partitioning of binary executables

We have built a runtime compilation system that takes unmodified sequential binaries and improves their performance on off-the-shelf multiprocessors using dynamic vectorization and loop-level parallelization techniques. Our system, Azure, is purely software based and requires no specific hardware support for speculative thread execution, yet it is able to break even in most cases; that is, the achieved speedup exceeds the cost of runtime monitoring and compilation, often by significant amounts. Key to this remarkable performance is an offline preprocessing step that extracts a mostly correct control flow graph (CFG) from the binary program ahead of time. This statically obtained CFG is incomplete in that it may be missing some edges corresponding to computed branches. We describe how such additional control flow edges are discovered and handled at runtime, so that an incomplete static analysis never leads to an incorrect optimization result. The availability of a mostly correct CFG enables us to statically partition a binary executable into single-entry multiple-exit regions and to identify potential parallelization candidates ahead of execution. Program regions that are not candidates for parallelization can thereby be excluded completely from runtime monitoring and dynamic recompilation. Azure's extremely low overhead is a direct consequence of this design.

On the implementation of bytecode compression for interpreted languages

AbstractThis paper describes a new method for code space optimization for interpreted languages called LZW‐CC. The method is based on a well‐known and widely used compression algorithm, LZW, which has been adapted to compress executable program code represented as bytecode. Frequently occurring sequences of bytecode instructions are replaced by shorter encodings for newly generated bytecode instructions. The interpreter for the compressed code is modified to recognize and execute those new instructions. When applied to systems where a copy of the interpreter is supplied with each user program, space is saved not only by compressing the program code but also by automatically removing the unused implementation code from the interpreter. The method's implementation within two compiler systems for the programming languages Haskell and Java is described and implementation issues of interest are presented, notably the recalculations of target jumps and the automated tailoring of the interpreter to program code. Applying LZW‐CC to nhc98 Haskell results in bytecode size reduction by up to 15.23% and executable size reduction by up to 11.9%. Java bytecode is reduced by up to 52%. The impact of compression on execution speed is also discussed; the typical speed penalty for Java programs is between 1.8 and 6.6%, while most compressed Haskell executables run faster than the original. Copyright © 2008 John Wiley & Sons, Ltd.

Mortality pattern of hospitalized children in a tertiary care hospital of kolkata.

The causes of mortality are often poorly documented in developing countries. The Medical Records Department in a teaching hospital has a system of compilation and retention of records, yet the acquisition of meaningful statistics from these records for health care planning and review is lacking. Mortality data from hospitalized patients reflect the causes of major illnesses and care-seeking behaviour of the community as well as the standard of care being provided. Records of vital events like death constitute an important component of the Health Information System. Hospital-based death records provide information regarding the causes of deaths, case fatality rates, age and sex distribution, which are of great importance in planning health care services. A better understanding of childhood mortality could contribute to a more effective approach to saving these lives. A country needs sound epidemiological information to prioritize, plan and implement public health programmes. There is a paucity of information about direct causes of child mortality in developing countries.(1) This information also provides the basis for patient care and helps the administration in managing day-to-day hospital affairs. The present study was aimed at finding the causes of mortality of inpatients in the Paediatric Department admitted during 2005 and provides epidemiological information related to child mortality.

Using Web resources to construct multilingual medical thesaurus for cross-language medical information retrieval

Due to the language barrier, non-English users are unable to retrieve the most updated medical information from the U.S. authoritative medical websites, such as PubMed and MedlinePlus. However, currently, there is no any cross-language medical information retrieval (CLMIR) system that can help Chinese-speaking consumers cross the language barrier in finding useful English medical information. A few CLMIR systems utilize MeSH (Medical Subject Headings) to help overcome the language barrier. Unfortunately, the traditional Chinese version of MeSH is currently unavailable. In this paper, we employ a semi-automatic term translation method to construct a Chinese–English MeSH by exploiting abundant multilingual Web resources, including Web anchor texts and search–result pages. Through this method, we have developed a Chinese–English Mesh Compilation System to assist knowledge engineers in compiling a Chinese–English medical thesaurus with more than 19,000 entries. Furthermore, this thesaurus has been used to develop a prototypical system for cross-language medical information retrieval, MMODE, which can help consumers retrieve top-quality English medical information using Chinese terms.

Towards Harmonised Balance of Payments and International Investment Position Statistics - The Experience of the European Compilers

External statistics - specifically balance of payments and international investment position statistics - are among the primary statistics on which policy-making bodies and markets rely as a basis for their decisions in globalised economies. Monitoring and enhancing data quality in the context of rapidly changing economies impose heavy constraints on compilers of these statistics. As it becomes increasingly important worldwide to adhere to a set of international statistical standards in order to ensure the comparability of statistics, the elaboration of meaningful EU/euro area aggregates hinges critically on attaining a high degree of homogeneity across countries' contributions. In addition to offering their own value for analysis, the euro area external statistics are the main source for the compilation of the rest-of-the-world account in the quarterly euro area (financial and nonfinancial) accounts. Bearing this in mind, a lot has been achieved since the inception of the euro area to harmonise concepts and definitions in line with international statistical standards, to review the data collection and compilation systems, as well as to enhance the overall data quality. However, asymmetries1 both across euro area countries and with counterparts elsewhere still need to be overcome. Additionally, new challenges lie ahead for compilers of statistics, with the steady process of globalisation and the increasing role of financial innovation (in terms of both new instruments and new institutional vehicles) observed in financial markets. While the compilation of euro area statistics continues to be based on country contributions, which are mostly derived from national collection systems in accordance with the principle of subsidiarity, common tools are built up and maintained by the European Central Bank and national compilers. In particular, the Centralised Securities Database is playing a pivotal role in the move towards security-by-security reporting and should greatly enhance the quality of security-related information, i.e. portfolio investment flows, stocks and income. The tremendous work of European statisticians towards producing harmonised euro area statistics that are fit for purpose has also benefited statisticians elsewhere and is playing an important role in the current updating of international standards (the 1993 System of National Accounts and the International Monetary Fund's Balance of Payments Manual, fifth edition). Statisticians have worked in close cooperation in various European fora to clarify concepts and identify best practices with a view to enhancing data quality and reducing the reporting burden. This paper aims to make this experience widely available.

TRICK

Compilers, during compilation, analyze the application being compiled and build up extensive knowledge about the program. This knowledge is essential for the compiler to produce correct object code. Though some part of this knowledge is retained in the generated object files as symbol table information to be used by the linker and/or debugger, most of it is discarded after the compilation is done. In this paper, we introduce the TRICK framework, which is an attempt to retain and reuse this internal information generated by the compiler as part of its program analysis, in building new tools or enhancing existing tools as well for reuse by the compiler for continuous program optimization. We present examples of how development and maintenance of various program analysis tools can be simplified by using the TRICK framework describing tools developed by our group as well as how TRICK framework can be employed in continuous program optimization by the compiler. TRICK framework can be part of both static and dynamic compilation system, though our current usage model is in the context of a static compilation system,

Trade Balance: Numbers Can be Deceiving

Trade disputes have become more prevalent and acute in recent years. Almost all center on bilateral trade balance and/or market access of certain merchandise or services. However, since at least the mid 1980s, affiliate sales have become a more direct and more powerful form of market access than the traditional cross-border commercial transactions for developed countries, whereas developing countries still rely predominantly on traditional trade. The importance of the international production supply chain is increasing with a bias against downstream producers. The current data collection and compilation system of trade balance can not reflect these changes in the world economic environment. It overstates exports of developing countries and understates their imports. None of the countries in the world can illustrate the weakness of the conventional system better than China. (Edited by Zhinan Zhang)

OpenGR: A directive-based grid programming environment

A new grid programming environment for remote procedure call (RPC) based master–worker type task parallelization is presented. The environment is realized through the use of a set of compiler directives, called OpenGR, and is implemented in the present study based on the Omni OpenMP compiler system and Ninf-G grid-enabled RPC system as a parallel execution mechanism. Using OpenGR directives, existing sequential applications can be readily adapted to the grid environment as master–worker parallel programs using the RPC architecture. The combination of OpenGR and OpenMP directives also allows for the hybrid parallelization of sequential programs, supporting both synchronous and asynchronous parallelism.

Design and evaluation of dynamic optimizations for a Java just-in-time compiler

The high performance implementation of Java Virtual Machines (JVM) and Just-In-Time (JIT) compilers is directed toward employing a dynamic compilation system on the basis of online runtime profile information. The trade-off between the compilation overhead and performance benefit is a crucial issue for such a system. This article describes the design and implementation of a dynamic optimization framework in a production-level Java JIT compiler, together with two techniques for profile-directed optimizations: method inlining and code specialization. Our approach is to employ a mixed mode interpreter and a three-level optimizing compiler, supporting level-1 to level-3 optimizations, each of which has a different set of trade-offs between compilation overhead and execution speed. A lightweight sampling profiler operates continuously during the entire period while applications are running to monitor the programs' hot spots. Detailed information on runtime behavior can be collected by dynamically generating instrumentation code that is installed to and uninstalled from the specified recompilation target code. Value profiling with this instrumentation mechanism allows fully automatic profile-directed method inlining and code specialization to be performed on the basis of call site information or specific parameter values at the higher optimization levels. The experimental results show that our approach offers high performance and low compilation overhead in both program startup and steady state measurements in comparison to the previous systems. The two profile-directed optimization techniques contribute significant portions of the improvements.

Fast and efficient searches for effective optimization-phase sequences

It has long been known that a fixed ordering of optimization phases will not produce the best code for every application. One approach for addressing this phase-ordering problem is to use an evolutionary algorithm to search for a specific sequence of phases for each module or function. While such searches have been shown to produce more efficient code, the approach can be extremely slow because the application is compiled and possibly executed to evaluate each sequence's effectiveness. Consequently, evolutionary or iterative compilation schemes have been promoted for compilation systems targeting embedded applications where meeting strict constraints on execution time, code size, and power consumption is paramount and longer compilation times may be tolerated in the final stage of development, when an application is compiled one last time and embedded in a product. Unfortunately, even for small embedded applications, the search process can take many hours or even days making the approach less attractive to developers. In this paper, we describe two complementary general approaches for achieving faster searches for effective optimization sequences when using a genetic algorithm. The first approach reduces the search time by avoiding unnecessary executions of the application when possible. Results indicate search time reductions of 62%, on average, often reducing searches from hours to minutes. The second approach modifies the search so fewer generations are required to achieve the same results. Measurements show this approach decreases the average number of required generations by 59%. These improvements have the potential for making evolutionary compilation a viable choice for tuning embedded applications.

Dynamic mapping of cooperating tasks to nodes in a distributed system

Networks of workstations (NOWs) are a low-cost and widespread platform for parallel computing. This paper focuses on the dynamic task-scheduling problem in NOW environments. The aim is to minimize the completion time of parallel programs by distributing cooperating concurrent tasks to homogeneous networked nodes. Cooperation dependencies as well as creation and termination dependencies between tasks are taken into account. An event lattice model is introduced to describe past, actual and future behavior of a parallel program in execution. Based on this model an algorithm is presented to dynamically assign tasks to the nodes of a dedicated distributed system. Crucial for the efficiency of this approach is a top-down construction of all operating system entities involved in distributed resource management, particularly the close cooperation of the compiler and runtime system, which allows the creation of event lattice clippings at runtime.

Retargetable compilers and architecture exploration for embedded processors

Retargetable compilers can generate assembly code for a variety of different target processor architectures. Owing to their use in the design of application-specific embedded processors, they bridge the gap between the traditionally separate disciplines of compiler construction and electronic design automation. In particular, they assist in architecture exploration for tailoring processors towards a certain application domain. The paper reviews the state-of-the-art in retargetable compilers for embedded processors. Based on some essential compiler background, several representative retargetable compiler systems are discussed, while also outlining their use in iterative, profiling-based architecture exploration. The LISATek C compiler is presented as a detailed case study, and promising areas of future work are proposed.

A fast, memory-efficient register allocation framework for embedded systems

In this work, we describe a "just-in-time," <i>usage density-based register allocator</i> geared toward embedded systems with a limited general-purpose register set wherein speed, code size, and memory requirements are of equal concern. The main attraction of the allocator is that it does not make use of the traditional live range and interval analysis nor does it perform advanced optimizations based on range <i>splitting</i> but results in very good code quality. We circumvent the need for traditional analysis by using a measure of <i>usage density</i> of a variable. The usage density of a variable at a program point represents both the frequency and the density of the uses. We contend that by using this measure we can capture both <i>range</i> and <i>frequency</i> information which is essentially used by the good allocators based on <i>splitting</i>. We describe a framework based on this measure which has a linear complexity in terms of the program size. We perform comparisons with the static allocators based on graph coloring and the ones targeted toward just-in-time compilation systems like linear scan of live ranges. Through comparisons with graph coloring (Brigg's style) and live range-based (linear scan) allocators, we show that the memory footprint and the size of our allocator are smaller by 20% to 30%. The speed of allocation is comparable and the speed of the generated code is better and its size smaller. These attributes make the allocator an attractive candidate for performing a fast, memory-efficient register allocation for embedded devices with a small number of registers.

Exploiting program branch probabilities in hardware compilation

This paper explores using information about program branch probabilities to optimize the results of hardware compilation. The basic premise is to promote utilization by dedicating more resources to branches which execute more frequently. A new hardware compilation and flow control scheme are presented which enable the computation rate of different branches to be matched to the observed branch probabilities. We propose an analytical queuing network performance model to determine the optimal settings for basic block computation rates given a set of observed branch probabilities. An experimental hardware compilation system has been developed to evaluate this approach. The branch optimization design space is characterized in an experimental study for Xilinx Virtex FPGAs of two complex applications: video feature extraction and progressive refinement radiosity. For designs of equal performance, branch-optimized designs require 24 percent and 27.5 percent less area. For designs of equal area, branch optimized designs run up to three times faster. Our analytical performance model is shown to be highly accurate with relative error between 0.12 and 1.1 /spl times/ 10/sup -4/.

A Framework for Incremental Extensible Compiler Construction

Extensibility in complex compiler systems goes well beyond modularity of design and it needs to be considered from the early stages of the design, especially the design of the Intermediate Represen...

The Reincarnation of Virtual Machines

The term virtual machine initially described a 1960s operating system concept: a software abstraction with the looks of a computer system’s hardware (real machine). Forty years later, the term encompasses a large range of abstractions?for example, Java virtual machines that don’t match an existing real machine. Despite the variations, in all definitions the virtual machine is a target for a programmer or compilation system. In other words, software is written to run on the virtual machine.

Fast searches for effective optimization phase sequences

It has long been known that a fixed ordering of optimization phases will not produce the best code for every application. One approach for addressing this phase ordering problem is to use an evolutionary algorithm to search for a specific sequence of phases for each module or function. While such searches have been shown to produce more efficient code, the approach can be extremely slow because the application is compiled and executed to evaluate each sequence's effectiveness. Consequently, evolutionary or iterative compilation schemes have been promoted for compilation systems targeting embedded applications where longer compilation times may be tolerated in the final stage of development. In this paper we describe two complementary general approaches for achieving faster searches for effective optimization sequences when using a genetic algorithm. The first approach reduces the search time by avoiding unnecessary executions of the application when possible. Results indicate search time reductions of 65% on average, often reducing searches from hours to minutes. The second approach modifies the search so fewer generations are required to achieve the same results. Measurements show that the average number of required generations decreased by 68%. These improvements have the potential for making evolutionary compilation a viable choice for tuning embedded applications.

Automatic validation of code-improving transformations on low-level program representations

This paper presents a general approach for automatically validating code-improving transformations on low-level program representations. The approach ensures the correctness of compiler and hand-specified optimizations at the machine instruction level. The method verifies the semantic equivalence of the program representation before and after a transformation to determine the validity of the transformation. To verify that the transformation is semantics preserving, the method derives semantic effects from the instructions that span the execution paths affected by the transformation. The semantics are preserved if the normalized semantic effects are unchanged. A validating compilation system was implemented that is able to validate traditional compiler transformations and more powerful transformations that modify the branch structure of a program.

A retrospective on

Previous selective dynamic compilation systems have demonstrated that dynamic compilation can achieve performance improvements at low cost on small kernels, but they have had difficulty scaling to larger programs. To overcome this limitation, we developed DyC, a selective dynamic compilation system that includes more sophisticated and flexible analyses and transformations. DyC is able to achieve good performance improvements on programs that are much larger and more complex than the kernels. We analyze the individual optimizations of DyC and assess their impact on performance collectively and individually.