java virtual machine

Java Virtual Machine Specifications was written as a full document which helps the developing of the Java virtual machine. It is essential for compiler writers who wish to target the Java virtual machine and for programmers who want to implement a compatible Java virtual machine. It is also a definitive source for anyone who wants to know exactly how the Java programming language is implemented.

The Java virtual machine is an abstract machine. References to the Java virtual machine throughout this specification refer to this abstract machine rather than to Suns or any other specific implementation. This book serves as documentation for a concrete implementation of the Java virtual machine only as a blueprint documents a house. An implementation of the Java virtual machine (known as a runtime interpreter) must embody this specification, but is constrained by it only where absolutely necessary.

C Java Virtual Machine description
C# Java Virtual Machine is a tiny implementation of the Java VM written using C# C# Java Virtual Machine is a small implementation of the Java Virtual Machine, including simple native classes.

C# Java Virtual Machine is written using the C# language. The VM is very easily expandable by writing additional native or Java classes.

Requirements:

· .NET framework 2.0 or mono

C# Java Virtual Machine is a tiny implementation of the Java VM, including simple native classes. This project is written using the C# language. The VM is very easily expandable by writing additional native or Java classes.

Whats New in This Release:

· The DbConnection class, which provides a connection to MS SQL or PostgreSQL using ADO.NET, was added.
· The Syst.MachineName method, which returns the machine name, was added.
· String.startsWith and String.endsWith functions were added.
· Some comments for VM.cs were written.

The Microsoft Virtual Machine (Microsoft VM) is a platform-independent software engine that runs Java applets, applications, and COM objects. The Microsoft VM is an interpreter and a runtime system. As an interpreter, the Microsoft VM interprets architecture-neutral instructions, or bytecode. Bytecode is machine-independent code generated by Java compilers, such as jvc.exe or the Microsoft compiler, and executed by the Java interpreter or compiled, at the last minute, by a JIT compiler. This release of the Microsoft VM (build 3319) is for machines with Microsoft Internet Explorer 4.01 or later. This latest update eliminates a new variant of VM File Reading Vulnerability. Once installed, the Microsoft VM cannot be uninstalled.

Joeq is a virtual machine and compiler infrastructure designed to facilitate research in virtual machine technologies such as Just-In-Time and Ahead-Of-Time compilation, advanced garbage collection techniques, distributed computation, sophisticated scheduling algorithms, and advanced run time techniques.

Joeq is entirely implemented in Java, leading to reliability, portability, maintainability, and efficiency. It is also language-independent, so code from any supported language can be seamlessly compiled, linked, and executed -- all dynamically.

Each component of the virtual machine is written to be independent with a general but well-defined interface, making it easy to experiment with new ideas.

Joeq is released as open source software, and is being used as a framework by researchers on five continents on topics ranging from automatic distributed virtual machines to whole-program pointer analysis.

Joeq is a virtual machine and compiler infrastructure designed to be a platform for research in compilation and virtual machine technologies. We had three main goals in designing the system. First and foremost, we wanted the system to be flexible. We are interested in a variety of compiler and virtual machine research topics, and we wanted a system that would not be specific to researching a particular area.

For example, we have interest in both static and dynamic compilation techniques, and in both type-safe and unsafe languages. We wanted a system that would be as open and general as possible, without sacrificing usability or performance.

Second, we wanted the system to be easy to experiment with. As its primary focus is research, it should be straightforward to prototype new ideas in the framework. With this in mind, we tried to make the system as modular as possible, so that each component is easily replaceable. Learning from our experience with Jalapeno, another virtual machine written in Java, we decided to implement the entire system in Java.

This makes it easy to quickly implement and prototype new ideas, and features like garbage collection and exception tracebacks ease debugging and improve productivity. Java, being a dynamic language, is also a good consumer for many of our dynamic compilation techniques; the fact that our dynamic compiler can compile the code of the virtual machine itself means that it can dynamically optimize the virtual machine code with respect to the application that is running on it. Javas object-oriented nature also facilitates modularity of the design and implementation.

Third, we wanted the system to be useful to a wide audience. The fact that the system is written in Java means that much of the system can be used on any platform that has an implementation of a Java virtual machine. The fact that Joeq supports popular input languages like Java, C, C++, Fortran, and even x86 binary code increases the scope of input programs. We released the system on the SourceForge web site as open source under the Library GNU Public License.

It has been picked up by researchers on five continents for various purposes, among them: automatic extraction of component interfaces, static whole-program pointer analysis, context-sensitive call graph construction, automatic distributed computation, versioned type systems for operating systems, sophisticated profiling of applications, advanced dynamic compilation techniques, system checkpointing, anomaly detection, secure execution platforms and autonomous systems. In addition, Joeq is now used as the basis of the Advanced Compilation Techniques class taught at Stanford University.

Joeq supports two modes of operation: native execution and hosted execution. In native execution, the Joeq code runs directly on the hardware. It uses its own run-time routines, thread package, garbage collector, etc. In hosted execution, the Joeq code runs on top of another virtual machine. Operations to access objects are translated into calls into the reflection library of the host virtual machine.

The user code that executes is identical, and only a small amount of functionality involving unsafe operations is not available when running in hosted execution mode. Hosted execution is useful for debugging purposes and when the underlying machine architecture is not yet directly supported by Joeq. We also use hosted execution mode to bootstrap the system and perform checkpointing, a technique for optimizing application startup times.

Joeq system consists of seven major parts:

· Front-end: Handles the loading and parsing of input files, such as Java class files, SUIF files, and binary object files.
· Compiler: A framework for performing analyses and optimizations on code. This includes the intermediate representation (IR) of our compiler.
· Back-end: Converts the compilers intermediate representation into native, executable code. This code can be output to an object file or written into memory to be executed. In addition, it generates metadata about the generated code, such as garbage collection maps and exception handling information.
· Interpreter: Directly interprets the various forms of compiler intermediate representations.
· Memory Manager: Organizes and manages memory. Joeq supports both explicitly-managed and garbage-collected memory.
· Dynamic: Provides profile data to the code analysis and optimization component, makes compilation policy decisions, and drives the dynamic compiler.
· Run-time Support: Provides runtime support for introspection, thread scheduling, synchronization, exception handling, interfacing to external code, and language-specific features such as dynamic type checking.

VMware Virtual Machine Importer 2 is the latest utility for IT professionals and software developers & testers working with virtual machines.

VMware Virtual Machine Importer is a freely available, stand-alone utility to import virtual machines from a variety of source formats into most VMware product environments.

Here are some key features of "VMware Virtual Machine Importer":

· Move virtual machines across test/development and production environments based on different virtualization products, or managed separately.
· Convert virtual machines for use across different VMware product formats.
· Create VMware virtual machines from third-party system images such as Symantec Backup Exec System Recovery (also known as Livestate) and Microsoft Virtual Server.
· Populate new virtual machine environments quickly from the large directory of virtual machine appliances.

NVM stands for NVM Virtual Machine (yes, right. It’s the still-and-forever popular recursive acronym). NVM Virtual Machine is a small, quite portable and as I hope fast virtual machine. I’ve written it without precise purpose as a work for studies but I’m considering using it for scripting one of my μC projects (mobile robot).

It consist of three programs: assembler (+disassembler), execution environment and compiler of a high-level language (higher than assembler). First two are written in C, whereas compiler is written using ocamllex and ocamlyacc.

Currently, the latest version is available at: NVM it still needs a lot of work and tests. Feel free to comment it.

An example of language which is compiled by ocamllex and ocamlyacc:
def fibo($a, $b)

$c = $a + $b;

puti($a);
puts($Sep);

$a = $b;
$b = $c;

if ($c < 10000)
call fibo($a, $b);
;;
;;

def start($test)
$Sep = n;
puts(Fibonacci series:n);
call fibo(1, 1);
;;

Language has support for functions, global and local variables, some string support and that’s all. It has if and while keywords implemented also.

Whats New in This Release:

· This is a complete and running version, but it needs a lot of testing.
· A few examples of the ASM and the higher-level language are provided.
· Compilation was tested on the x86, x86_64, and Cygwin (x86) platforms.

Microsoft Java Virtual Machine for Internet Explorer lets you view java applets on internet pages.

Customers who have the Microsoft VM already installed on their machine will still be able to get important security updates through Windows Update. IOD is also still supported on operating systems other than Windows XP, which included the Microsoft VM in their default installation, to ensure that Microsoft customers get critical updates to the Microsoft VM.

Microsoft includes the Microsoft virtual machine as part of Windows XP SP1. This means that any Windows XP licensee who does not already have the Microsoft VM will receive the Microsoft VM as part of this service pack.

High Level Virtual Machine is a toolkit for developing virtual machines for dynamic languages.

The High Level Virtual Machine is:

· Based on LLVM (Low Level Virtual Machine). LLVM is HLVMs sister project. HLVM gains tremendous capability from LLVM in the areas of code generation, bytecode storage, runtime execution, etc.
· Aimed at supporting dynamic languages such as Ruby, Python, Perl, Jython, Haskell, Prolog, etc.
· A complete compiler developers toolkit for creating new languages easily. To write a new compiler, language designers simply write a plugin that describes the language to HLVM and how to translate the grammar productions into HLVMs comprehensive Abstract Syntax Tree (AST). After that, HLVM handles all aspects of code generation, bytecode storage, XML translation, JIT execution or interpretation, and native compilation.
· A language interoperability framework. Because all front end compilers generate code in the same AST, they can interoperate. Use of the runtime library for common constructs (e.g. "string") allow even complex data types to be shared between languages. Users of HLVM can write complex programs in multiple languages and be assured the result can be executed efficiently.
· A code management system including code revisioning, interface versioning, automated recompilation, separation of workspaces, etc.
· Currently under development. Project started April 20th, 2006. Stay tuned to this web site for future developments.

Virtual Machine Manager software (virt-manager for short package name) is a desktop user interface for managing virtual machines. The project presents a summary view of running domains and their live performance & resource utilization statistics. A detailed view presents graphs showing performance & utilization over time. Ultimately it will allow creation of new domains, and configuration & adjustment of a domains resource allocation & virtual hardware. Finally an embedded VNC client viewer presents a full graphical console to the guest domain.

The application logic is written in Python, while the UI is constructed with Glade and GTK+, based on mockups provided by UI interaction designers. The libvirt Python bindings are used to interacting with the underlying hypervisor. This enables the application to be written independant of any particular hypervisor technology. Initially Xen was the primary platform supported, however, since libvirt 0.2.0 and virt-manager 0.3.1 it is possible to manage QEMU and KVM guests too. It is expected that support for additional hypervisors / virtualization products will expand even further over time as additional libvirt drivers are written.
The "Virt Install" tool (virtinst for short package name) is a command line tool which provides an easy way to provision operating systems into virtual machines. It also provides an API to the virt-manager application for its graphical VM creation wizard.

The "Virt Clone" tool (virtinst for short package name) is a command line tool for cloning existing inactive guests. It copies the disk images, and defines a config with new name, UUID and MAC address pointing to the copied disks.
The "Virtual Machine Viewer" application (virt-viewer for short package name) is a lightweight interface for interacting with the graphical display of virtualized guest OS. It uses GTK-VNC as its display capability, and libvirt to lookup the VNC server details associated with the guest. It is intended as a replacement for the traditional vncviewer client, since the latter does not support SSL/TLS encryption of x509 certificate authentication.

Virtual Machine Manager (virt-manager for short package name) is a desktop application for managing virtual machines. It presents a summary view of running domains and their live performance & resource utilization statistics.

A detailed view presents graphs showing performance & utilization over time. Ultimately it will allow creation of new domains, and configuration & adjustment of a domains resource allocation & virtual hardware. Finally an embedded VNC client viewer presents a full graphical console to the guest domain.

The application logic is written in Python, while the UI is constructed with Glade and GTK+, based on mockups provided by UI interaction designers. The libvirt Python bindings are used to interacting with the underlying hypervisor.

This enables the application to be written independant of any particular hypervisor technology, although Xen is the current primary platform. When libvirt is ported to additional hypervisors minimal effort will be required to update the management UI.

The Virtual Cart Machine is a small utility for radio stations, disc jockeys or home users. It is build up like a hardware cart machine with 16 slots. But it does not only play your sound files. It also has 3 mixer functions. You can mix from one slot row to the other. This can be done either automaticly or by cross fade or manually.

Virtual Drum Machine is a simple drum machine.

It works for little endian/linux kind of machines. You may let it work on others machines, but you probably will get troubles with it.

You definitely need oss (or maybe alsa) for sound output, and a posix-like operating system. To let it work on a big endian machine should be painful.

You write a rhythm, then you compile it, then you are able to play it to your sound card or save it to a file.

The Virtual Drum Machine is made of

* the Rhythm Compiler,
* the runtime library.

The Virtual Drum Machine is in the public domain. Who needs a license? money makers? Protection against robbery? let me laugh... Read any text of law, you will see where the robbers reside.

A simple file would look like :

void main_rhythm(void)
{
tempo = 120;
* a
. b
. b
.
* a
.b
* a
.
. b
. b
* a c
. b
}

Install:

Do a "./configure" in the drums directory, then "make", then "make install", it should be alright. You can listen to some examples in the examples/ directory.

Who yo use it?

Write a rhythm. Compile it with "rc". Run the produced program. You are done.

See the examples/ directory to get the point.

When you run an example, try "-h" to get the available options.

It should be self-explanatory.

The rhythm compiler has several options. By running "rc --help", all should be clear.

Technical Details:

The compiler will parse the input file line by line.

If a line starts with "*" or "." (not counting leading white spaces), the whole line is seen as a rhythm line, and is transformed into C code. If not, it is passed as is to the C file.

Beware! You MUST NOT start any C code line by "*" or "."!

You can create as much functions as you want, write any C code you want. But remember that a line starting by "*" or "." is seen as a rhythm line and is translated by "rc" into C code.

You must provide a "void main_rhythm(void)" function, that will be called by the library. It is the starting point of your rhythm. It can be "void main_rhythm(int argc, char *argv[])" too, with common meaning for those parameters (non-C coders will have trouble with the Virtual Drum Machine).

You can change the tempo (ex. "tempo=100;") or the volume (ex "vol=0.4;") at any time. Each sample comes with its own volume and panning (ex. "a.vol = 0.1;" "a.pan=-0.8;"). Volumes range from 0 to what you want. 1 is for the normal volume. Panning ranges from -1 (left) to 1 (right). 0 is center. All values are double. You can use "volume" instead of "vol", and "panning" instead of "pan". There is no global panning, if you want all left, set all samples to left.

To run in stereo mode, dont forget "-s" when running the generated program. It is mono by default.

You absolutely need to compile and run the examples, and read them to get the point out of it!

The "rc.conf" file contains configuration informations. You specify the sample by "sample" followed by its name (the one you will use in your rhythm files), then the file that will be played. The name of the sample must start by a letter, followed by letters and/or numbers (it must be a valid C identifier, without "_" though). The configuration file contains the install directory, used by "rc" to compile your rhythms. Take a look at the one that is provided to see how to use it.

The sound files are simple wav files. They all should be of the same rate, which can be specified to the generated program, using the "-f" option (44100 is the default). (The library only handles very basic wav files, if yours dont work, you probably will have to modify the library for the program to handle it.)

When you add a sample, you must modify "rc.conf" for the changes to appear. The samples are hard-linked to the produced program, so if you change "sample a /some/dir/file1.wav" by "sample a /one/other/dir/file2.wav" in the configuration file, the previously generated programs will still use "/some/dir/file1.wav". You will have to compile them again to take the changes into account.

Whats New in This Release:

· The code has been modified to let gcc 4 compile it.

System Center Virtual Machine Manager description
Provides centralized administration of virtual machine infrastructure Microsoft System Center Virtual Machine Manager 2007 is a part of the Microsoft System Center family of system management products and was designed to provide a simple and cost-effective solution for unified management of physical and virtual machines, consolidation of underutilized physical servers, and rapid provisioning of new virtual machines by leveraging the expertise and investments in Microsoft server technology.

System Center Virtual Machine Manager application will provide centralized administration of virtual machine infrastructure and will enable increased physical server utilization and rapid provisioning of new virtual machines by the administrator and authorized end users.

Here are some key features of "System Center Virtual Machine Manager":

· Centralized deployment and management of virtual machines
· Intelligent Placement analysis to determine the best servers for virtualization
· Quick physical-to-virtual and virtual-to-virtual conversion
· Ease of use with a familiar interface and seamless integration with other Microsoft products
· Faster deployments with administrator-managed self-service provisioning
· Resource efficiency with server consolidation and increased processor utilization
· Quick automation via PowerShell scripting integration


Requirements:

· A virtualization product that supports the VHD format is required to use this virtual machine. Microsoft Virtual PC or Microsoft Virtual Server are provided for free and can be used with these VHD based virtual machines.
· In addition to the System Requirements for the virtualization product, you will need additional disk and memory resources for running the virtual machine. This VHD is pre-configured to use approximately 10GB of hard disk space and approximately 512MB of memory.


Limitations:

· 120 days trial

Java Source Machine II description
Java Source Machine II - generate 12 customized JavaScripts for use in web pages Java Source Machine II is a small, simple and easy to use application that is designed to generate 12 customized JavaScripts for use in web pages:

· Dynamic Title Bar,
· Week Day Image,
· Date and Time Stamp,
· Disable Right Clicking on Web Page,
· Expanding Window,
· Random Page,
· Browser Information,
· Referrer,
· Write and Slide,
· Confirm Entry,
· Welcome Cookie & Marquee.

Java Source Machine I description
Java Source Machine I - generate 15 customized JavaScripts for use in web pages Java Source Machine I is a small, simple and easy to use application that is designed to generate 15 customized JavaScripts for use in web pages:

· Blur Text,
· Multi-Search Engine Search,
· Page Fade-In,
· Flying Text,
· Alerts on Load & Unload,
· No Spam E-mail,
· Number Countdown,
· Refresh/Redirect,
· Dictionary and Thesaurus,
· Exit Window,
· Pop Up Window with Auto Close,
· Jumping Text,
· Link Message,
· Type-in Status Bar
· Status Bar Wiper.

The change auditing and reporting is a critical management process to prevent erroneous and unauthorized changes of System Microsoft Center Virtual Machine Manager configuration. The virtual infrastructure is maintained by many administrators and you need to have full control over every change that happens to prevent unplanned outages and faulures.

NetWrix Change Reporter Microsoft System Center Virtual Machine Manager captures all changes and creates comprehensive reports showing every change made through the last day and before.
Setup once, this freeware product sends a daily e-mail detailing every change made to your virtual machines, host groups, libraries, hosts and their hardware, including "before" and "after" values.

NetWrix Change Reporter Microsoft System Center Virtual Machine Manager is a perfect tool to prepare reports for your compliance auditors, such as SOX, HIPAA and GLBA.

NOTE: The product is provided free of charge for use by organizations and individuals. The commercial version with advanced functionality and technical support is available, please visit www.netwrix.com for more details.

Network Virtual Terminal for Java is a library that can drive a terminal emulator connected to the application through a telnet session.

Usage:

The API consists of the interface nvt4j.Terminal . The implementation of this class is called nvt4j.impl.Terminal. To allow the user to connect to the application you need to listen for a tcp connection and then wrap a Terminal object around it:

ServerSocket serverSocket = new ServerSocket(8000);
Socket socket = serverSocket.accept();
Terminal terminal = new nvt4j.impl.Terminal(socket);

For example, to run the sample class Example.java from an xterm session, you can
do this:

user@localhost$ java -classpath nvt4j.jar Example &
user@localhost$ telnet localhost 8000

NVT4J uses the Telnet LINEMODE option to put the terminal driver (xterm in this case) in what the posix standard calls raw or non-canonical mode, so that it can receive all user inputs asap, instead of waiting for a new-line character.

Unfortunately in pure Java there is no way to put the operating system console in
raw mode. On Linux and similar systems this is done using the stty command, which is a native program which manipulates the terminal driver in the operating system.

Whats New in This Release:

First alpha release. This code is quite limited but it already provides the basic functions needed to drive a terminal emulator for Java, namely putting the terminal driver in raw mode, turning off the cursor and client-side echo, and detecting the size of the terminal emulator window.

This code has been tested only with xterm.