Implementing Unsafe Features on top of a Safe Virtual Machine

This paper describes how virtual classes can be supported in a virtual machine. Main-stream virtual machines such as the Java Virtual Machine and the .NET platform dominate the world today, and many languages are being executed on these virtual machines ...

The ubiquitous game platform implemented by our team is composed of a C++ compiler, a java translator, and a virtual machine. The EVM (Embedded Virtual Machine) is a stack-based solution that supports object-oriented languages such as C++ and java. It uses the SIL (Standard Intermediate Language) as an intermediate language, which consists of an operation code set for procedural and object-oriented languages. The existing C++ compilers are used to execute programs after translating them into a target machine code. The downside of this method is its low practicality, along with its platform-dependency. To resolve this matter, we developed a C++ compiler that generates virtual machine codes based on platform-independent stacks that are not target machine codes. This paper presents a decompiler system that converts a C++ compiler generated intermediate language, namely SIL, to a representation of a C++ program. This method optimizes the simulation needed for the generation of exacted SIL code, and a solution that can verify the SIL code generation through a C++ program represented in the decompiler. Furthermore, the ease of extracting the meaning of a program, as opposed to assembly-structured SIL codes, allows much more convenience in changing the software structure and correcting it to improve performance.

The VMIL workshop is a forum for research in virtual machines (VM) and intermediate languages (IL). It is dedicated to identifying programming mechanisms and constructs that are currently realized as code transformations or implemented in libraries but should rather be supported at the VM level. Candidates for such mechanisms and constructs include modularity mechanisms (aspects, context-dependent layers), concurrency (threads and locking, actors, software transactional memory), transactions, etc. Topics of interest include the investigation of which such mechanisms are worthwhile candidates for integration with the VM, how said mechanisms can be elegantly (and reusably) expressed at the IL level (e.g., in bytecode), how their implementations can be optimized, and how VM architectures might be shaped to facilitate such implementation efforts.

The author presents the architecture of a new family of parallel operating systems based on an alternative design approach when compared to multiprogramming, namely, generic construction of parallel virtual machines. This construction is made according to needs of models for parallel programming which shall be supported as subsystems by the parallel operating system kernel. The author presents the PAROS architecture and its generic kernel ParX which has been designed for message passing parallel computers. Several parallel virtual machines are also described, such as for instance a diffusion virtual machine, and a message passing-shared data virtual machine. >

Chapter 21 - Building a VM

Virtual machines raise the abstraction level of the execution environment at the cost of restricting the set of supported languages. Moreover, the ability of a language implementation to integrate with other languages hosted on the same virtual machine typically constrains the features of the language. In this paper, we present a highly flexible yet efficient approach to hosting multiple programming languages on an objectoriented virtual machine. Our approach is based on extending the interface of each class with language-specific wrapper methods, offering each language a tailored view of a given class. This approach can be deployed both on a statically typed virtual machine, such as the JVM, and on a dynamic virtual machine, such as a Smalltalk virtual machine. We have implemented our approach to language interoperability on top of a prototype virtual machine for embedded systems based on the Smalltalk object model, which provides interoperability for embedded versions of the Smalltalk, Java, and BETA programming languages. (Less)

Proceedings of the 10th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages

When photovoltaic inverters operate in parallel, the output of each inverter’s impedance and the line impedance of aren’t consistent, resulting in the instantaneous voltage of each inverter at the common parallel point is not equal, so in the parallel inverters system, the circulating current is easy to form between each inverter, which affects the distribution of active power together with reactive power. In this paper, feedforward compensation is leaded-in active and reactive power control channels, and dynamic virtual complex impedance method for dynamic improvement of response performance of parallel virtual synchronous machine, so as to increase the degree of freedom of dynamic characteristic control and heighten the feedback speed. The parameters of D (damping drop coefficients) and K f (excitation coefficient) to make the inductive component of virtual impedance increase and counteract the resistive component, so as to the oscillation of output power is suppressed; Improving the stability of active power and reactive power and speed up the response speed of the system. The simulation display that parallel VSG in Matlab / Simulink make clear that the proposed control strategy is valid and practicable.

In modern day pattern recognition, neural nets are used extensively. General use of a feedforward neural net consists of a training phase followed by a classification phase. Classification of an unknown test vector is very fast and only consists of the propagation of the test vector through the neural net. Training involves an optimization procedure and is very time consuming since a feasible local minimum is sought in weight space. If the training algorithm is based on error backpropagation the optimization procedure consists of the following steps: computation of the activation of the net when all the training examples are presented to it;computation of an error function based on the activation;computation of the gradients at a point in weight space; and finally,the adaptation of the weight values of the net. In this paper we present an analysis of a parallel implementation of the backpropagation algorithm using conjugate-gradient optimization for a three-layered, feedforward neural network, using networked workstations as a virtual parallel machine. The instance of the virtual machine is the PVM system, developed at Oak Ridge National Laboratory. We compare the overall performance of the parallel machine with averaged sequential runs in a typical research environment. From this, we identify the general requirements such as the size of the data set and neural net which render the parallel implementation useful, compared with the sequential execution of the same neural net training procedure.

The Evolving Tree Transformation System (ETTS) has been developed as a model of a reconfigurable learning machine. In this paper we present an examination of the opportunities for parallel processing in the Evolving Tree Transformation System (ETTS) as well as an implementation which takes advantage of the inherent parallelism. The implementation uses the distributed software system Parallel Virtual Machine (PVM) to handle process control and inter-process communication. Experiments conducted on the implementation are presented which reveal a strong correlation between performance, the size and nature of the input data and the size of the parallel machine. Using a sixteen processor virtual parallel machine, we are able to achieve a speedup of 13.5 using idealized data and a speedup of 7.6 using real (natural) data. Performance models for the parallel implementations are also presented.

This paper describes a high level general purpose language which evolved from another high level systems programming language. As well, the compiler, pseudocode, and virtual machine are discussed in some detail. The new language is a powerful PL/1 dialect, as is its parent language, XPL 1. PL/EXUS (Programming Language/Extended XPL Users' Superset), was created to satisfy a particular set of needs. A highly machine independent, mobile, compact, and powerful programming system was needed for implementation of programs to manipulate medical record data on modestly configured minicomputers. The primary extensions to XPL were semantic and dictated the structure of a host virtual machine. Because of the number of different data types and implicit mixed mode conversion rules, the virtual machine has a tagged data architecture. This results in a small instruction set of under 64 operators and thus enables powerful, implicit, run time instruction interpretation. The PL/EXUS virtual machine has a basic eight bit word size. Its virtual memory capabilities require only a fraction of the program and data to be in real memory at a time. The ability to specify storage space for most data types results in parsimonious space allocation in spite of the presence of tag words (one eight-bit byte per identifier or constant). Some instructions were specifically created to allow the compiler to “peep-hole” (i.e., locally) optimize generated pseudocode programs. The compiler itself is written in XPL, which permits self-compilation and makes possible its execution on the virtual machine or a simulated (interpretive) version of it.

A computer is nothing more then a virtual machine programmed by source code to perform a task. The program`s source code expresses abstract constructs which are compiled into some lower level target language. When a virtual machine breaks, it can be very difficult to debug because typical debuggers provide only low-level target implementation information to the software engineer. We believe that the debugging task can be simplified by introducing aspects of the abstract design and data into the source code. We introduce OODIE, an object-oriented extension to programming languages that allows programmers to specify a virtual environment by describing the meaning of the design and data of a virtual machine. This specification is translated into symbolic information such that an augmented debugger can present engineers with a programmable debugging environment specifically tailored for the virtual machine that is to be debugged.

In the field of parallel processing, there is a great diversity of languages and architectures which become obsolete at a rapid pace. In this environment, portability is an important issue. Unfortunately, most parallel languages are not portable. This portability problem can be solved using a virtual machine approach. In this approach, front-end translators translate various parallel source languages into code for a virtual machine. Back-end translators translate the virtual machine code into executable codes for a variety of parallel architectures. The Virtual Machine for Parallel Processing (VMPP) is designed to provide portability for a variety of high-level parallel programming languages without significantly sacrificing performance. >

Many of today’s programming languages are broken. Poor performance, lack of features and hard-to-reason-about semantics can cost dearly in software maintenance and inecient execution. The problem is only getting worse with programming languages proliferating and hardware becoming more complicated. An important reason for this brokenness is that much of language design is implementation-driven. The diculties in implementation and insucient understanding of concepts bake bad designs into the language itself. Concurrency, architectural details and garbage collection are three fundamental concerns that contribute much to the complexities of implementing managed languages. We propose the micro virtual machine, a thin abstraction designed specifically to relieve implementers of managed languages of the most fundamental implementation challenges that currently impede good design. The micro virtual machine targets abstractions over memory (garbage collection), architecture (compiler backend), and concurrency. We motivate the micro virtual machine and give an account of the design and initial experience of a concrete instance, which we call Mu, built over a two year period. Our goal is to remove an important barrier to performant and semantically sound managed language design and implementation.

Nowadays computing plays a vital role in information technology and all other fields. Yes, the cloud computing is one of the biggest milestone in most leading next generation technology and booming up in IT filed and business sectors. In our day to day life the data is being generated is enormous amount such as tera (TB), peta (PB), zeta (ZB) bytes. Hadoop Map Reduce is the popular distributed computing paradigm to process data intensive jobs in cloud. Completion time goals for deadline of map reduce jobs set by users are becoming crucial in existing cloud based data processing environments like Hadoop. In this paper proposes a real-time implementation of multi node Hadoop virtual cluster on open stack cloud environments and also it processes the huge data sets in parallel different virtual machines (VMs) and it compares average execution time for different node virtual clusters and various size inputs.