Skip to content
Free planNo credit card requiredStart writing
AI for Research home
AI for Research home
Dashboard
Sign inGet started

Search 250 million research papers

Read the abstract, see who wrote it and who cites it, and get the citation in APA, MLA, Chicago or Harvard.

About 2,524 papers for “Java Virtual Machine”

The Java Virtual Machine

Amrish Lal, Janet Formichelli, Constant Pool · 1998

Windows Toolkit. Its incremental real-time garbage collector was described above. All of this results in a picoPERC core that fits into less than 64 KB of memory. The company boasts that this is less than one-sixteenth of JavaSoft's Embedded Java, which will be described below. [6, pp. 50-51] 7 Competitors in the Java Virtual Machine Market 7.1 NewMonics As discussed above, NewMonics has created a hardware implementation of the Java Virtual Machine, picoPERC. This is a clean-room implementation of the Java Virtual Machine, which means that they have implemented the Java language and virtual machine independently of Sun and without any of Sun's code. Thus they have avoided paying Sun's fees. [8, p. 75] 7.2 Microsoft and Hewlett-Packard Hewlett-Packard has released its own small-footprint Java Virtual Machine and licensed it to Microsoft, charging lower licensing fees than Sun. HP's Java Virtual Machine is 19 only 500 KB, compared to Sun's 4 MB. Besides being small, this Java Virt...

Cited by 0

java virtual machine book

Elizabeth Colbert · Zenodo (CERN European Organization for Nuclear Research) · 2024

Cited by 0Open access

java virtual machine book

Elizabeth Colbert · Zenodo (CERN European Organization for Nuclear Research) · 2024

Cited by 0Open access

Virtual machines, such as the Java Virtual Machine, Java Card Virtual

Gilles Barthe, Inria Sophia Antipolis, Guillaume Dufay · 2008

Abstract. Bytecode verification is one of the key security functions of several architectures for mobile and embedded code, including Java, Java Card, and.NET. Over the last few years, its formal correctness has been studied extensively by academia and industry, using general purpose theorem provers. The objective of our work is to facilitate such endeavors by providing a dedicated environment for establishing the correctness of bytecode verification within a proof assistant. The environment, called Jakarta, exploits a methodology that casts the correctness of bytecode verification relatively to a defensive virtual machine that performs checks at run-time, and an offensive one that does not, and can be summarized as stating that the two machines coincide on programs that pass bytecode verification. Such a methodology has been used successfully to prove the correctness of the Java Card bytecode verifier, and may potentially be applied to many other similar problems. One definite advantage of the methodology is that it is amenable to automation. Indeed, Jakarta automates the construction of an offensive virtual machine and a bytecode verifier from a defensive machine, and the proofs of correctness of the bytecode verifier. We illustrate the principles of Jakarta on a simple low-level language extended with subroutines, and discuss its usefulness to proving the correctness of the Java Card platform.

Cited by 0

Měření výkonnosti Java Virtual Machine

Michal Kňazský · 2012

The aim of this work is to explore the tools for the Java Virtual Machine's performance measurement. The work deals with tools SPECjvm2008, SPECjbb2005 and J2DBench - analyzes their properties and functions and usage in practice. In practical part the tools are used to measure and compare the performance of multiple JVMs. There is also introduced program JVMBenchmarker, which was created as a part of this work. It is used for automated running of SPECjvm2008 and SPECjbb2005 tools. The part of this work is also dedicated to garbage collectors. Main GCs available in HotSpot and J9 VM are described and their performance is compared with SPECjbb2005 tool.

Cited by 0

Java Virtual Machine Profiler Interface

Deepa Viswanathan, Liang Sheng · IBM Systems Journal · 2000

We present the Java™ Virtual Machine Profiler Interface (JVMPI), which defines a general-purpose and portable mechanism for obtaining comprehensive profiling data from the Java virtual machine. We show that it is extensible, nonintrusive, and powerful enough to suit the needs of different profilers and virtual machine implementations. With the JVMPI, most profiler vendors will not need to build custom instrumentation in the Java virtual machine. In addition, we solve challenges to profiler design and implementation posed by the multithreading and garbage collection support provided by the Java virtual machine. Profilers based on the JVMPI can produce thread-aware CPU time profiles, uncover heavy memory allocation sites, detect unnecessary object retention, pinpoint scalability problems caused by high monitor contention, reveal thread deadlocks, and perform interactive profiling with minimum overhead. We also describe HPROF, a profiler based on JVMPI, developed by us to demonstrate the power of JVMPI.

Cited by 64

Java Virtual Machine Educational Tools

Tomaž Dobravec · 2019

Java virtual machine is becoming an industry standard for running platform-independent programs. It is available for a wide range of different platforms - from very simple embedded systems to large sophisticated computers. In spite of the fact that JVM supports efficient execution of complex programs with performances comparable to those achieved by non-virtualised programs, the JVM architecture is quite simple and as such it has very high educative value. The details about the JVM internal mechanisms, memory management procedures and bytecode execution processes can help software and hardware developers to understand the operation and the structure of the computer at the lowest level. For system developers, this knowledge can be used as a good example of a fast and efficient working environment, while the programmers can use it to write optimized programs that are in line with the JVM capabilities. In this paper, we present some behind-the-scenes details about JVM. We list selected tools that can be used in the production as well as in the educational process to learn about and to take ad-vantages of JVM as an efficient working environment. We present programs like javap, Bytecode Visualizer, and PyJVMGui, with some verbose test cases.

Cited by 1

Inside the Java Virtual Machine

Bill Venners · Medical Entomology and Zoology · 1997

From the Book: My primary goal in writing this book was to explain the Java virtual machine-and several core Java APIs closely related to the virtual machine-to Java programmers. Although the Java virtual machine incorporates technologies that have been tried and proven in other programming languages, prior to Java, many of these technologies had not yet entered into common use. As a consequence, many programmers will encounter these technologies for the first time as they begin to program in Java. Garbage collection, multi-threading, exception handling, dynamic extension---even the use of a virtual machine itself-might be new to many programmers. The aim of this book is to help programmers understand how all these things work, and in the process we hope to help them become more adept at Java programming. Another goal I had in mind as I wrote this book was to experiment a bit with the changing nature of text. Web pages have three interesting characteristics that differentiate them from paper-based text: they are dynamic (can evolve over time), they are interactive (especially if you embed Java applets in them), and they are interconnected (you can easily navigate from one to another). Besides the traditional text and figures, this book includes several Java applets (in a mini-Web site on the CD-ROM) that serve as interactive illustrations of the concepts presented in the text. In addition, I maintain a Web site at art ima. com on the Internet that serves as a launching point for readers to find more (and more current) information about the topics covered in the book. This book is composed of all of these components: text, figures, interactive illustra. tions, and constantly evolving links tofurther reading.

Cited by 289

1.1 The Java Virtual Machine

Allen Goldberg · 1997

This paper gives a mathematical specification the Java Virtual Machine (JVM) bytecode verifier. The specification is an axiomatic description of the verifier that makes precise subtle aspects of the JVM semantics and the verifier. We focus on the use of data flow analysis to verify type-correctness and the use of typing contexts to insure global type consistency in the context of an arbitrary strategy for dynamic class loading. The specification types interfaces with sufficient accuracy to eliminate run-time type checks. Our approach is to specify a generic dataflow architecture and formalize the JVM verifier as an instance of this architecture. The emphasis in this paper is on readability of the specification and mathematical clarity. The specification given is consistent with the descriptions in the Lindholm’s and Yellin’s The Java ™ Virtual Machine Specification. It less committed to certain implementation choices than Sun’s version 1.1 implementation. In particular, the specification does not commit an implementation to any loading strategy, and detects all type errors as early as possible.

Cited by 0

CEJVM: "cluster enabled Java Virtual Machine"

M.U. Janjua, Muhammad Yasin, Falak Sher et al. · 2003

CEJVM is a cluster enabled Java Virtual Machine, which executes in a distributed fashion among collaborating nodes of a dedicated cluster. It extends Java's multithreading mechanism to the parallel computing paradigm by transparent migration of independent application threads modeled in master worker paradigm. The goal is to obtain improved performance for computationally-intensive multi-threaded Java programs without modifying traditional JVM code, Java language or compiler implementation. Deploying a master worker relationship among the nodes in the cluster, CEJVM monitors, packs, transports and resurrects the Java threads on "Master JVM" and helper "Worker JVMs". Currently, we have created a prototype that runs pure Java applications on the local Ethernet based cluster of Win2K computers. We have achieved appreciable speedup for an ANN training program written in Java (with independent threads) on CEJVM without any modification to the program's source code.

Cited by 2

Auto-Tuning the Java Virtual Machine

Sanath Jayasena, Milinda Fernando, Tharindu Rusira et al. · 2015

We address the problem of tuning the performance of the Java Virtual Machine (JVM) with run-time flags (parameters). We use the Hot Spot JVM in our study. As the Hot Spot JVM comes with over 600 flags to choose from, selecting a subset manually to maximize performance is infeasible. In prior work, the potential performance improvement is limited by the fact that only a subset of the tunable flags are tuned. We adopt a different approach and present the Hot Spot Auto-tuner which considers the entire JVM and the effect of all the flags. To the best of our knowledge, ours is the first auto-tuner for optimizing the performance of the JVM as a whole. We organize the JVM flags into a tree structure by building a flag-hierarchy, which helps us to resolve dependencies on aspects of the JVM such as garbage collector algorithms and JIT compilation, and helps to reduce the configuration search-space. Experiments with the SPECjvm2008 and DaCapo benchmarks show that we could optimize the Hot Spot JVM with significant speedup, 16 SPECjvm2008 startup programs were improved by an average of 19% with three of them improved dramatically by 63%, 51% and 32% within a maximum tuning time of 200 minutes for each. Based on a minimum tuning time of 200 minutes, average performance improvement for 13 DaCapo benchmark programs is 26% with 42% being the maximum improvement.

Cited by 13

Java Virtual Machine using graph grammars

2003

dr. P.M. van den Broek dr. ir. A. Rensink Summary Model checking is used to find problems in software. However the run-time behaviour of a program is poorly covered by existing model checking. To be able to analyse this run-time behaviour we want to be able to translate a Java program into graph grammars. This report especially focuses on the translation of Java byte code into graph grammars. To be able to do this translation, a run-time state of a program has to be represented in a graph. For this representation a Meta model is developed. A translator has been designed and implemented to create graphs and graph production rules corresponding to this Meta model. Using this translator simple Java programs can be translated to graph grammars. Currently not all JVM instructions and Java concepts are implemented; this is planned for the future. The templates used for the translation are very complex and need to be systematically designed in the future. This translator can contribute to better software analysis and in the end help to find more bugs. 3

Cited by 0

Safety-Critical Java Virtual Machine Services

James Baxter, Ana Cavalcanti, Andy Wellings et al. · 2015

To ensure that Safety-Critical Java (SCJ) programs run correctly and safely, the virtual machine they run on must be shown to operate correctly. To the best of our knowledge, however, currently we do not even have a clear specification of the requirements for such a virtual machine. In this paper, we present an identification of these requirements for the SCJ API and infrastructure, based on the requirements of the SCJ standard and on consideration of existing virtual machines for SCJ. Formal methods provide a powerful tool in modelling and eliciting requirements, and establishing correctness of implementations. We also present here a formal model of the requirements written in the Circus specification language, which has already been used in a technique for verification of SCJ programs. Our work is a contribution to establishing a framework for the development of fully verified systems using SCJ.

Cited by 3

Programming for the Java¿ Virtual Machine

Joshua Engel · CERN Document Server (European Organization for Nuclear Research) · 1999

Preface. 1. Introduction to the Java Virtual Machine. Java Virtual Machine and Java. What Is the Java Virtual Machine? Instruction Set. class File Format. Verification. Java Platform. Organization of the Java Virtual Machine. Class Area. Java Stack. Heap. Native Method Stacks. Example. Garbage Collection. Finalization. Timing of Garbage Collection. JVM Implementations. Versions of the Virtual Machine. Future of the Java Virtual Machine. 2. Oolong. Hello, World. .class and .super Directives. main Method. Instructions. Structure of an Oolong Program. Defining the Class. Superclasses. Declaring Fields. Declaring Methods. Interfaces. 3. Writing Methods. Some Definitions. Types. Numeric Types. Object Types. Type returnAddress. Mnemonic Naming Conventions. Testing Code Examples. Returns. Constants. General Constants. Small Constants and null. Local Variables. Initializing Variables. Local Variables as Method Arguments. Math. Arithmetic Operations. Nonnumbers and Infinity. Bitwise Operations. Floating-Point Arithmetic and strictfp. Type Conversions. Conversion Example. Widening and Narrowing. Stack Manipulations. Arrays of Numbers. Just Biding Your Time. 4. Classes and Objects. What Is an Object? Objects and References. Class Names. Packages. Creating Objects. Constructors. Using Fields. Types and getfield. Inheriting Fields. Changing Field Values. Invoking Methods on Objects. Virtual Invocation. Method Inheritance and Overriding. Overloading and Method Matching. Invoking a Method Directly. invokespecial and super. Casting. Casting, Fields, Methods, and Java. Returning Objects. Interfaces. Static Fields and Methods. Class Initialization. Arrays. Arrays of Reference. Multidimensional Arrays. Length of Arrays. 5. Control Instructions. Comparing Integers. Comparing References. Other Comparisons. Switches. Subroutines. Exceptions. Multiple Exception Handlers. .throws Directive. Other Ways to Throw Exceptions. A Gentler Way of Checking Type. 6. Verification Process. How the Verification Algorithm Works. Is It a Structurally Valid class File? Are All Constant References Correct? Will Each Instruction Always Find a Correctly Formed Stack and Local Variable Array? Example 1: Hello, World. Example 2: gotos and ifs. Example 3: Code That Doesn't Verify. Example 4: Dealing with Subclasses. Algorithm. Do External References Check Out? Java Language and Verification Algorithm. Fooling the Virtual Machine with a Java Compiler. Other Languages and the Verification Algorithm. Other Safety Requirements. Checking Verification. 7. Debugging. Debugging Directives in Oolong. .source Directive and .line Directives. .var Directive. Debugging Oolong Programs. Runtime Tracing. 8. Class Loaders. How Classes Are Loaded. Loading. Linking. Loading Classes without a Class Loader. Making Your Own Class Loader. Caching Classes. Examples. Working with Class Objects. Reflection. 9. Inside a Java class File. class File Header. Constant Pool. UTF8 Entries. Constant Entries. Field, Method, and Class Entries. Class Information. Fields and Methods. Class Attributes. Other Attributes. ConstantValue Attribute. Exceptions Attribute. InnerClasses Attribute. 10. Compiling Java. Expressions and Statements. Expression Types. Numeric Types. Object Types. Expression Result Types. Compile-Time Types and Type Restrictions. Type Safety and Verifiability. Compiling Statements and Expressions. Local Variable Declarations. Fields and Variables. Abbreviations. Other Assignments. Assignments as Expressions. Type-Checking in Assignments. Creating New Objects. Class Name Abbreviations. Arithmetic Expressions. Numeric Coercions. Casting Numeric Values. Operator. Method Calls. Virtual Method Calls. Static Method Calls. Example of Method Calls. Overriding. Overloading. Interfaces. Expressions as Statements. Ifs and Booleans. Boolean Values. if Statements. Comparisons. Floating-Point Comparisons and NaN. Integer Comparisons. References and Object Equality. Boolean Operators. Other Control Structures. Loops. Compiling Control Constructs. Compound Statements and Verification. Returns. Field Declarations. Method Declarations. Constructors. Using Other Constructors in the Same Class. Default Constructors. Field Initializers and the Constructor. Conclusion. 11. Compiling Other Languages. Java Version 1.1. Class Literals. Inner Classes. Variable Scoping with Inner Classes. Regular Expressions. Iterators. Iterators in Sather. Implementing Iterators. Iterators with Arguments. Using Iterators. Parameterized Types. Implementing Parameterized Types with a Generic Class. Implementing Parameterized Types as Templates. Multiple Inheritance. Interfaces for Multiple Inheritance. Implementing the Interfaces. Fields. Conclusion. 12. Implementing Scheme. Scheme Concepts. Compiling Scheme into Bytecodes. Compiling Lambda Expressions. Example. Scheme Library. Optimizing Scheme. Static Scoping. Using Local Variables. Inlining. Tail Recursion. Using Type Information. 13. Implementing Prolog. Introduction to Prolog. Asking Questions. Binding Patterns. Implications. Binding Patterns and Implications. Facts as Rules. More About Unification. Implementation Basics. Unification. Unification Algorithm. Managing Bindings. Rules as Programs. inside. within. yield and Backtracking. Implementing Rules. Implementing within. Implementing Conjunctions. Constructing within. Compiling Facts. Case Study. 14. Performance. Fast Virtual Machines. Garbage Collection Performance. Implementing References. Bytecode Optimization Techniques. Warning. Constant Propagation. Strength Reduction. Loop Unrolling. Peephole Optimization. Inlining. Inlining Fields. Separate Compilation. 15. Security and the Virtual Machine. Java platform and Need for Security. Security Promises of the JVM. Security Architecture and Security Policy. Example. Basic Applet Security Policy. More Sophisticated Policies. Some Potential Attacks. Implementation Details. Protecting the Security Manager. Bypassing Java Security. Using Unconstructed Objects. Invalid Casts. Changing the Class of a Reference. Reading Uninitialized Fields. Array Bounds Checks. Catching Exceptions. Hidden Code. Conclusion. 16. Threads and Synchronization. Threads. Example: Multithreaded Web Server. Exceptions and Threads. Sharing State Between Threads. Need for Synchronization. Exception: longs and doubles. Monitors and Object Locks. Synchronization in Java. Synchronized Methods. Scheduling. Surrendering Control of the CPU. Waiting for Another Thread. Conclusion. A. Tables. Instructions by Opcode. Instructions Alphabetically. Instructions by Category. Arithmetic. Array. Constant. Control. Data Type Conversion. Object. Stack Manipulation. Synchronization. Variable. B. Oolong Reference. Using the Oolong Assembler. Gnoloo. DumpClass. Oolong Language. Comments. source. class. interface. end class. super. implements. field. method. limit locals. limit stack. line. var. throws. catch. end method. Instructions. Instructions with No Arguments. Integers. Labels. Classes. Fields and Methods. invokeinterface. multianewarray. ldc, ldc_w, and ldc2_w. newarray. tableswitch. lookupswitch. C. Answers to Selected Exercises. Further Readings. Java and the JVM. Newsgroup. Other Languages. Compilers. Index. 0201309726T04062001

Cited by 39