In today's networks, the evolution of wide-area services is constrained by standardization and compatibility concerns. The result is that the introduction of a new service occurs much more slowly than the emergence of new applications and technologies that benefit from it. To ameliorate this problem, an active network exploits mobile code and programmable infrastructure to provide rapid and specialized service introduction. A viable active network has the potential to change the way network protocols are designed and used, stimulating innovation and hastening the arrival of new functionality. There are, however, a number of challenges that must be overcome in the design of an active network. Chief among them are how to express new services as network programs, and how to execute these programs efficiently and securely.

This paper presents a novel approach to the problem of bytecode verification for Java Card applets. Owing to its low memory requirements, our verification algorithm is the first that can be embedded on a smart card, thus increasing tremendously the security of post-issuance downloading of applets on Java Cards.

A new paradigm for computing is emerging based on the Internet and the World Wide Web, accompanied by a new standard programming platform based on the Java(tm) technology recently announced by Sun Microsystems [4]. The Java technology includes the definition for a platformindependent byte code representation for small applications called applets, which allows Java-enabled Web browsers to download and execute these Java applets using a byte code interpreter. Although the Java byte-code representation was designed specifically for the new Java language, it turns out that the underlying semantic models of Ada 95 and Java are sufficiently similar that a very direct mapping from Ada 95 to Java byte codes is possible. We at Intermetrics are in the process of adapting our Ada 95 compiler front end to generate Java byte codes directly, thereby allowing the development of Java-compatible applets in Ada 95. This paper explains our approach, and provides details on the mapping fro...

We present our experiences in using Java as an intermediate language for the high-level programming language Nesl. First, we

Virtual machines (VMs) are commonly used to distribute programs in an architecture-neutral format, which can easily be interpreted or compiled. A long-running question in the design of VMs is whether stack architecture or register architecture can be implemented more efficiently with an interpreter. We extend existing work on comparing virtual stack and virtual register architectures in two ways. Firstly, our translation from stack to register code is much more sophisticated. The result is that we eliminate an average of more than 47 % of executed VM instructions, with the register machine bytecode size only 25 % larger than that of the corresponding stack bytecode. Secondly we present an implementation of a register machine in a fully standardcompliant implementation of the Java VM. We find that, on the Pentium 4, the register architecture requires an average of 32.3 % less time to execute standard benchmarks if dispatch is performed using a C switch statement. Even if more efficient threaded dispatch is available (which requires labels as first class values), the reduction in running time is still approximately 26.5 % for the register architecture.

The Java language incurs a runtime overhead for exception checks and object accesses without an interior pointer in order to ensure safety. It also requires type inclusion test, dynamic class loading, and dynamic method calls in order to ensure flexibility. A "JustIn -Time" (JIT) compiler generates native code from Java byte code at runtime. It must improve the runtime performance without compromising the safety and flexibility of the Java language. We designed and implemented effective optimizations for the JIT compiler, such as exception check elimination, common subexpression elimination, simple type inclusion test, method inlining, and resolution of dynamic method call. We evaluate the performance benefits of these optimizations based on various statistics collected using SPECjvm98 and two JavaSoft applications with byte code sizes ranging from 20000 to 280000 bytes. Each optimization contributes to an improvement in the performance of the programs. 1. Introduction Java [1] is a ...

We present an algorithm based on arithmetic coding that allows decompression to start at any point in the compressed #le. This random access requirement poses some restrictions on the implementation of arithmetic coding and on the model used. Our main application area is executable code compression for computer systems where machine instructions aredecompressed on-the-#y before execution. We focus on the decompression side of arithmetic coding and we propose a fast decoding scheme based on #nite state machines. Furthermore, we present a methodtodecode multiple bits per cycle, while keeping the size of the decoder small.

This paper presents a new intermediate format called Static Single Information (SSI) form. SSI form generalizes the traditional concept of a variable de nition to include all information de nition points, or points where the analysis may obtain information about the value in a variable. Information de nition points include conditional branches as well as assignments. Because SSI form provides a new name for each variable at each information de nition point, it provides excellent support for both predicated analyses, which exploit information gained from conditionals, and backwards dataow analyses.

Abstract. Java is normally compiled to bytecode, which is verified and then executed by the Java Virtual Machine. Bytecode produced via compilation must pass verification. The main cause of complexity for bytecode verification is subroutines, used by compilers to generate more compact code. The techniques to verify subroutines proposed in the literature reject certain programs produced by mundane compilers or are otherwise difficult to realize within an implementation of the Java Virtual Machine. This paper presents a novel technique which is very simple to understand, implement, and prove sound. It is also very powerful: the set of accepted programs has a simple characterization which most likely includes all code generable by current compilers and which enables future compilers to make more extensive use of subroutines. 1 Java Bytecode Java [2, 11] is normally compiled to a platform-independent bytecode language, which is executed by the Java Virtual Machine (JVM) [18]. This bytecode language features intra-method subroutines, used by Java compilers to generate more compact code [18, Sect. 7.13].

Development of reusable software is an important software-engineering problem. Researchers address this problem by designing programming languages with features to support the development of modular software. Object-oriented languages support modularity by providing abstractions, such as Modula-3's abstract data types, that separate a software component's interface from its implementation. Some object-oriented features, however, incur runtime costs, because they shift binding time, which is the time when the complete representations of types and variables are known, from compile time to run time. Late binding makes it difficult for a compiler to implement these features efficiently. This thesis describes a software approach to the problem of implementing high-level programming languages with late binding. We show how Modula-3's and C++'s features that require late binding can be implemented more efficiently with an optimizing linker. We describe the design and implementation of m...