Dynamic class loading during program execution in the java(TM) programminglanguage is an impediment for generating code that is as efficient as code generated using static whole-program analysis and optimization. Who...
详细信息
Dynamic class loading during program execution in the java(TM) programminglanguage is an impediment for generating code that is as efficient as code generated using static whole-program analysis and optimization. Whole-program analysis and optimization is possible for languages, such as C++, that do not allow new classes and/or methods to be loaded during program execution. One solution for performing whole-program analysis and avoiding incorrect execution after a new class is loaded is to invalidate and recompile affected methods. Runtime invalidation and recompilation mechanisms can be expensive in both space and time, and, therefore, generally restrict optimization. To address these drawbacks, we propose a new framework, called the errant analysis framework, for interprocedural optimization of programs that support dynamic class (or method) loading. Given a set of classes comprising the closed world, we perform an offline static analysis which partitions references into two categories: (1) unconditionally extant references which point only to objects whose runtime type is guaranteed to be in the closed world;and (2) conditionally extant references which point to objects whose runtime type is not guaranteed to be in the closed world. Optimizations solely dependent on the first category can be statically performed, and are guaranteed to be correct even with any future class/method loading. Optimizations dependent on the second category are guarded by dynamic tests, called extane safety tests, for correct execution behavior. We describe the properties for extant safety tests, and provide algorithms for their generation and placement.
This paper describes the use of model-based reasoning for locating bugs in java programs, Model-based diagnosis is a technology that uses a declarative, generic description of the behavior of the components occurring ...
详细信息
ISBN:
(纸本)3540676899
This paper describes the use of model-based reasoning for locating bugs in java programs, Model-based diagnosis is a technology that uses a declarative, generic description of the behavior of the components occurring in a domain to construct a model of the overall system which can then be used at the desired level of abstraction to predict a system's behavior and derive assumptions about which parts of the system are incorrect. This approach is particularly enticing when applied to software since the model can be constructed from the program automatically. However, the actual choice of models poses interesting challenges. We show a simple model based on dependencies that can be used to diagnose very large programs, and walk through an example debugging session.
We have paid attention to the favors of Machine Translation (MT) users for a few years, and found that. most users prefer that the system is fast, inexpensive, easy to control, and easy to update. This means that some...
详细信息
ISBN:
(纸本)0780365836
We have paid attention to the favors of Machine Translation (MT) users for a few years, and found that. most users prefer that the system is fast, inexpensive, easy to control, and easy to update. This means that some times we do not need to aim a MT system with high fluency of the translations. At fact, usually we call not build such MT system which can get a high fluency of the translations. According the viewpoint, we have proposed a new MT paradigm called Super-Function Based Machine Translation(SFBMT) to try to address the MT users' requests. SFBMT uses Super Function(SF) to translate without thorough syntactic and semantic analysis as most MT systems usually do. The SF is a function that shows the correspondence between original language sentence patterns and target language sentence patterns. One key point for building a. SFBMT system is how to acquire the SF from the practical natural language phenomenon. In this paper, we present a method for aiding human to acquire the SF from parallel corpus, and describe the TOOL called MKSF. MKSF has been constructed in java. A experimental MT system based on proposed method has been built using java and some translation experiments have carried out.
To guarantee typesafe execution, java and other strongly typed languages require bounds checking of array accesses. Because array-bounds checks may raise exceptions, they block code motion of instructions with side ef...
详细信息
To guarantee typesafe execution, java and other strongly typed languages require bounds checking of array accesses. Because array-bounds checks may raise exceptions, they block code motion of instructions with side effects, thus preventing many useful code optimizations, such as partial redundancy elimination or instruction scheduling of memory operations. Furthermore, because it is not expressible at bytecode level, the elimination of bounds checks can only be performed at run time, after the bytecode program is loaded. Using existing powerful bounds-check optimizers at run time is not feasible, however, because they are too heavyweight for the dynamic compilation setting. ABCD is a light-weight algorithm for elimination of Array Bounds Checks on Demand. Its design emphasizes simplicity and efficiency. In essence, ABCD works by adding a few edges to the SSA value graph and performing a simple traversal of the graph. Despite its simplicity, ABCD is surprisingly powerful. On our benchmarks, ABCD removes on average 45% of dynamic bound check instructions, sometimes achieving near-ideal optimization. The efficiency of ABCD stems from two factors. First, ABCD works on a sparse representation. As a result, it requires on average fewer than 10 simple analysis steps per bounds check. Second, ABCD is demand-driven. It can be applied to a set of frequently executed (hot) bounds checks, which makes it suitable for the dynamic-compilation setting, in which compile-time cost is constrained but hot statements are known.
In this paper we present Jam, an extension of the javalanguage supporting mixins, that is, parametric heir classes. A mixin declaration in Jam is similar to a java heir class declaration, except that it does not exte...
详细信息
ISBN:
(纸本)3540676600
In this paper we present Jam, an extension of the javalanguage supporting mixins, that is, parametric heir classes. A mixin declaration in Jam is similar to a java heir class declaration, except that it does not extend a fixed parent class, but simply specifies the set of fields and methods a generic parent should provide. In this way, the same mixin can be instantiated on many parent classes, producing different heirs, thus avoiding code duplication and largely improving modularity and reuse. Moreover, as happens for classes and interfaces, mixin names are reference types, and all the classes obtained instantiating the same mixin are considered subtypes of the corresponding type, hence can be handled in a uniform way through the common interface. This possibility allows a programming style where different ingredients are "mixed" together in defining a class;this paradigm is somehow similar to that based on multiple inheritance, but avoids the associated complications. The language has been designed with the main objective in mind to obtain, rather than a new theoretical language, a working and smooth extension of java. That means, on the design side, that we have faced the challenging problem of integrating the java overall principles and complex type system with this new notion;on the implementation side, that we have developed a Jam to java translator which makes Jam sources executable on every java Virtual Machine.
The standard reflection API of java provides the ability to introspect a program but not to alter program behavior. This paper presents an extension to the reflection API for addressing this limitation. Unlike other e...
详细信息
ISBN:
(纸本)3540676600
The standard reflection API of java provides the ability to introspect a program but not to alter program behavior. This paper presents an extension to the reflection API for addressing this limitation. Unlike other extensions enabling behavioral reflection, our extension called javassist enables structural reflection in java. For using a standard java virtual machine (JVM) and avoiding a performance problem, javassist allows structural reflection only before a class is loaded into the JVM. However, javassist still covers various applications including a language extension emulating behavioral reflection. This paper also presents the design principles of javassist, which distinguish javassist from related work.
This paper addresses the problem of resolving virtual method and interface calls in java bytecode. The main focus is on a new practical technique that can be used to analyze large applications. Our fundamental design ...
详细信息
This paper addresses the problem of resolving virtual method and interface calls in java bytecode. The main focus is on a new practical technique that can be used to analyze large applications. Our fundamental design goal was to develop a technique that can be solved with only one iteration, and thus scales linearly with the size of the program, while at the same time providing more accurate results than two popular existing linear techniques, class hierarchy analysis and rapid type analysis. We present two variations of our new technique, variable-type analysis and a coarser-grain version called declared-type analysis. Both of these analyses are inexpensive, easy to implement, and our experimental results show that they scale linearly in the size of the program. We have implemented our new analyses using the Soot framework, and we report on empirical results for seven benchmarks. We have used our techniques to build accurate call graphs for complete applications (including libraries) and we show that compared to a conservative call graph built using class hierarchy analysis, our new variable-type analysis can remove a significant number of nodes (methods) and call edges. Further, our results show that we can improve upon the compression obtained using rapid type analysis. We also provide dynamic measurements of monomorphic call sites, focusing on the benchmark code excluding libraries. We demonstrate that when considering only the benchmark code, both rapid type analysis and our new declared-type analysis do not add much precision over class hierarchy analysis. However, our finer-grained variable-type analysis does resolve significantly more call sites, particularly for programs with more complex uses of objects.
In this paper we address the problem of performing worst case execution time (WCET) analysis of java Byte Code (JBC) which may be generated from different compilers and from different compilers and from different sour...
详细信息
ISBN:
(纸本)0769507344
In this paper we address the problem of performing worst case execution time (WCET) analysis of java Byte Code (JBC) which may be generated from different compilers and from different compilers and from different source languages. The motivation for the framework presented is to provide WCET analysis which is portable and therefore more likely to be used in an industrial context. Two issues are addressed in this paper, how to extract data flow and control flow information from JBC programs and how to provide a compiler/language independent mechanism to introduce WCET annotations in the source code. We show that an annotation mechanism based on calls to a static class with empty methods result in similar code when generated by java or Ada compilers.
作者：
Ege, RKFlorida Int Univ
Sch Comp Sci High Performance Database Res Ctr Miami FL 33199 USA
The paper explores issues that arise from storing java objects in databases. The java program with its classes and objects tries to maintain an object-oriented paradigm as much as possible. However, the database schem...
详细信息
ISBN:
(纸本)0769507751
The paper explores issues that arise from storing java objects in databases. The java program with its classes and objects tries to maintain an object-oriented paradigm as much as possible. However, the database schema and data are not necessarily of the same object-oriented mold. We report on ail architecture that allows the java program to pretend that all objects are in main memory, relieving the java program from most database housekeeping chores. The architecture is supported by APIs to an actual database: the API can map to an object-oriented database, a relational database via JDBC, or to files using object serialization. We report on the design of these three approaches and experiences with their implementation.
One typically defines a read-only method as a method that does not perform any write operations;however, with respect to a multi-threaded program, we augment this interpretation and let a read-only method be one that ...
详细信息
ISBN:
(纸本)3540411852
One typically defines a read-only method as a method that does not perform any write operations;however, with respect to a multi-threaded program, we augment this interpretation and let a read-only method be one that does not write to a memory location visible to more than one thread. Such a method can execute concurrently with other read-only methods. With the relaxation of mutual exclusion in mind, we present a read-write analysis that employs the ideas of shape analysis and escape analysis to identify read-only methods in java. Approximately 31% of the methods in the JDK 1.2 core libraries meets this definition of read-only-nearly 50% more than those that do not perform any write operations.
暂无评论