About Virtual Machine

About Virtual Machine

 

 

 

 

By  Eric Kohlbrenner

Dana Morris

Brett Morris

 

 

 

 

From: Core of Information Technology

Date:2005-4-1                     

Editor: Herry

Introduction

The concept of virtual machines is not new to the computer world, it is however a concept that not many people knows about or understand. If you are a typical computer user and you use the Internet to browse the World Wide Web, then you have probably interacted with a virtual machine, that being the Java virtual machine. Now, other than this virtual machine that most computer users use transparently, you are probably wondering why you should care about virtual machines, no?

Well, virtual machines are a concept that is used quite often in the computing world to solve very important problems, but often these are transparent to you as the user because virtual machines are typically used within programs and operating systems that users use everyday. Some of these problems include: sharing the same hardware among many programs by partitioning the hardware, allowing software to be "portable" between various operating systems, as well as running older software on a newer computer. All of these uses of virtual machines are very important to the way that we compute today.

All of these uses of virtual machines are very important to the way that we compute today.

As you read on, we will attempt to show you how virtual machines help to solve these important problems, and therefore why they are an important piece of computers today.

When trying to explain the concept of virtual machines, it is first necessary to understand the meaning of the term virtual. Virtual is a term that originally came from optics, to understand objects in a mirror. Objects in a mirror are reflections of an actual physical object but mirrors are not actually that object. This means that the image looks exactly like the actual object and looks to be in the same location. Virtual has evolved to describe pretty much anything that is a simulation of a real object nowadays, with terms like virtual memory, virtual disks, and virtual reality. We use the term Virtual when talking about virtual machines because we would like our virtual machine to look and behave exactly like the real machine. This means the virtual machine is not really the actual machine, but behaves exactly like the actual machine.

Now, in defining the term virtual, we have used the term simulation. A simulation is something that imitates something else. A good example of a modern day application of a simulation is used in the training of Air Force and Marine pilots. Pilots are trained on flight simulators; computer based machines that look like the cockpit of a jet plane. This machine gives the pilot the look and feel of actually flying a real jet plane, without ever having to leave the ground. This simulator imitates everything from the actual maneuverability of the plane, to the effect of wind and weather conditions on flying the plane. In essence, the simulator allows the pilot to have all of the facilities and feelings of flying a real jet plane from the safety of the ground.

A simulation is something that imitates something else.

This concept of simulation, or imitating another object has been carried over into the design of computer systems. Although there are many incarnations of virtual machines, at its most basic, a virtual machine is the appearance of a machine that is not actually there. This is of course a very general definition and not a very clear one, but bear with us.

Let us now think about the concept of a machine in general. All machines have one thing in common, whether that machine is a refrigerator, a VCR, or a computer; they all have a certain set of instructions that they are designed to carry out. These instructions make up an instruction set. An instruction set for any machine can be thought of as a box of Legos, where these Legos are put together to form a whole object. With machines, these Legos are instructions, and they are used to tell a machine what to do, or what tasks to perform.

With virtual machines, the virtual really refers to these sets of instructions. There are many types of virtual machines, but the common theme between them is the idea of simulating an instruction set. Each virtual machine uses a virtual instruction set which the user has access to, and then the virtual machine "maps" these virtual instructions to the real instruction set of the computer. This mapping is demonstrated in Figure 1.1 below.

There are four major schools of thought in the virtual machine world. The first is a nearly one-to-one mapping, represented by the IBM virtual machine model. The second lineage consists of a mapping of every instruction in the machine with a virtual instruction, represented by the Java virtual machine. The UNIX virtual machine model and the OSI virtual machine model represent the final two models we will cover. These models map some of the instructions directly, while some others are calls to the operating system’s functions directly.

 

 

 

 

The History of Virtual Machines

In today’s computing world the concept of the virtual machine has been used to solve many problems. From partitioning the machine (The IBM model), to creating a semi-platform independent programming language (The Java model), to creating operating systems (The UNIX model and The OSI model), the concept of virtual machines has proven to be a powerful tool in shaping today’s computer. However, this idea was not always clear to everyone and it was not until the mid 1960s that this idea was put into practice.

Around 1965 the researchers at IBM were attempting to measure the actual effectiveness of some new ideas in the computer science field. The researchers needed a way to shut off these new features so they could measure the performance of the machine with the options both on and off. These researchers were based at the IBM Yorktown Research center. They devised a scheme where they needed to be able to partition the machine into "smaller pieces". These pieces needed to be able to manage their own resources so that the researchers could test many different conditions in the system at the same time without altering the other "pieces" of the system. They believed an implementation as a virtual machine could work extremely well for this experiment.

After this experiment, IBM eventually went on and developed an implementation of its notion of a virtual machine and began selling it as a real world Operating System for multiple user environments. Many businesses and universities use this Operating System because it allows them to share the power and resources available on their mainframe computers with many people. Each user has his/her own virtual machine that they work within, thereby sharing the resources with every other user without affecting those other users. This machine is now known as the IBM System 370 (S/370) and the IBM System 390 (S/390). These machines make use of the IBM VM/ESA operating system and are collectively referred to as IBM’s VM lineage.

This implementation of virtual machines has proven to be quite powerful, as it is a machine that is still being sold today. The idea of virtual machines has since been used to solve many other computing problems. Problems such as computer program portability and operating system design. One of the first implementations to utilize virtual machines to address these problems was the UNIX operating system.

The UNIX operating system was spawned from a paper published, in 1974, by Denise Richie and Ken Thompson of Bell Labs. Their idea for the UNIX operating system was quickly adapted in PDP-11 computers used in universities. From universities it was quickly spread to the commercial computer industry by graduating students. From 1980 to 1985 the IEEE standards board began POSIX (Portable Operating System) project to provide a standard for UNIX Library functions. The idea was that any software producer could write program code using the standard library functions and port the code to any UNIX system. In 1990 the IEEE POSIX project published "Information Technology Portable Operating System Interface". This specified the standard for UNIX shell and utility routines, which formalized specification for Unix Application Interface enabling UNIX processes to operate as separate virtual machines.

One problem that has plagued programmers for many years is the idea of creating truly portable computer programs. In other words, programmers want to write one program that will work on any platform. In the mid 1990s this idea has nearly been made possible utilizing the idea of the virtual machines to create the Java programming language.

The idea of the Java programming language, however, was not a new idea in the 1990s. It was actually thought of in the late 1970's by a gentleman named Bill Joy. Joy thought about creating a language that would merge the best features of MESA and C. Other projects (like co-founding Sun), however, intervened and it would be many years before this idea became a reality. By the early 90's Joy was getting tired of huge programs. In late 1990 Joy wrote a paper called Further which outlined his pitch to Sun engineers that they should produce an object environment based on C++. Around this time James Gosling had been working for several months on an SGML editor called "Imagination" using C++. Due to Gosling’s frustration with C++ on this "Imagination" project, the Oak programming language was created.

Patrick Naughton started the Green Project on December 5th, 1990. Naughton defined the project as an effort to "do fewer things better". That December he recruited Gosling and Mike Sheridan to help start the project. Joy showed them his Further paper, and work began on graphics and user interface issues for several months in C.

In April of 1991 the Green Project (Naughton, Gosling and Sheridan) settled on smart consumer electronics as the delivery platform, and Gosling started working heavily on the Oak programming language. Gosling wrote the original compiler in C; and Naughton, Gosling and Sheridan wrote the runtime-interpreter, also in C. Oak was running its first programs in August of 1991.

By the fall of 1992 "*7", a cross between a PDA and a remote control, was ready. This was demoed to Scott McNealy, Sun's president, in October. Following that the Green Project was set up as First Person Inc., a wholly owned Sun subsidiary. In early 1993 the Green team heard about a Time-Warner request for proposal for a set-top box operating system. First Person quickly shifted focus from smart consumer electronics to the set-top box OS market, and placed a bid with Time-Warner. Fortuitously, Sun lost the bid. First Person continued work on set-top boxes until early 1994, when it concluded that like smart consumer electronics set-top boxes were more hype than reality.

Without a market to be seen First Person was rolled back into Sun in 1994. However around this time it was realized that the requirements for smart consumer electronics and set-top box software (small, platform independent secure reliable code) were the same requirements for the nascent web. For a third time the project was redirected, this time at the web. A prototype browser called WebRunner was written by Patrick Naughton. After additional work by Naughton and Jonathan Payne this browser became Hot Java. In 1995 Oak was renamed Java. In May of 1995 the first Java Development Kit (JDK) 1.0 alpha was released. Since that time there have been several revisions leading up to the current version of the JDK 1.2.

Appendix: Events in history

Circa 1965

Yorktown IBM Research Center took the IBM 7044 machine and made an image of the 7044 in each partition on the system. Each image was called a 7044/44X and was created in order for IBM to better understand multiprogrammed operating systems. This was the beginning of IBM's notion of a virtual machine as a copy of an actual machine with reduced memory.

 

 

 

 

1967

Djiskstra built an operating system at THE University which consisted of a series of layered virtual machines which abstracted different levels of the machine. Each level abstracted from the level below. This is the first major lineage of the Virtual Machine.

 

 

 

 

Circa 1968

An IBM group in Cambridge Massachusetts built an Operating System and named it the Cambridge Monitoring System (CMS). CMS was an experiment in time sharing systems and eventually became the architecture used for the VM/370 machine that was sold as a time sharing system.

 

 

 

 

1974

Denise Ritchie and Ken Thompson of Bell Labs publish landmark paper on Unix Operating System. For their work on the Unix Operating system they received the prestigious ACM Turing Award in 1984.

 

 

 

 

1980 - 1985

IEEE Standards Board starts POSIX (Portable Operating System) project to provide a standard for Unix Library functions.

 

 

 

 

1990

IEEE POSIX publishes "Information Technology Portable Operating System Interface". This specified the standard for UNIX shell and utility routines.

 

 

 

 

1990

Patrick Naughton started the Green Project on December 5th, 1990. This project involving James Gosling and Mike Sheridan marked the early development of Java when it was known as the Oak programming language.

 

 

 

 

1995

In 1995, the Green project was redirected at the web. A prototype browser was created and the Oak programming language was renamed Java.

 

 

 

 

1999

In May of 1995 the first Java Development Kit (JDK) 1.0 alpha was released. Since then there have been several revisions on the way to the current version of the JDK, version 1.2.

 

 

 

 

The IBM Virtual Machine Model

IBM’s model is one in which each virtual machine is an exact copy of a real machine with a reduced memory capacity.

One of the major Virtual Machine (VM) models in use today is the International Business Machines (IBM) view of virtual machines. IBM’s model is one in which each virtual machine is an exact copy of a real machine with a reduced memory capacity. With this notion, a large and powerful mainframe computer can be split up, or partitioned, into many virtual machines with slightly less resources available than the original mainframe computer.

The IBM view of virtual machines is similar to the other VM lineages in that it serves as a mapping of functionality. This means that the VM intercepts virtual instructions and then maps these virtual instructions to the actual instructions on the machine. In the case of the IBM lineage of the VM, these instructions basically enjoy a one-to-one mapping, meaning that every virtual instruction is mapped to a single corresponding actual machine instruction and is executed as such. Essentially users actually have access to, and execute all of the instructions directly on the machine.

Now, you are probably wondering how the IBM VM operating system maintains security if it essentially gives a user all of the functionality they would have on the actual machine. Security is accomplished through this mapping method by simply blocking or trapping a certain set of instructions that are deemed sensitive. An example of such instructions would be those that attempt to directly alter the processor’s memory (registers). This type of instruction, if allowed, would allow the user to directly alter the actual machine, thereby altering the other VMs that might be running at any given time. If this were allowed to occur, then each user’s VM would not be completely independent and could therefore damage other user’s environments.

Essentially, the IBM VM system executes all non-sensitive instructions directly, and blocks the sensitive instructions. When the machine blocks these sensitive instructions, it attempts to simulate the desired operation so that the user is not aware they have attempted an illegal operation. The VM system provides virtual execution of the sensitive instructions if possible, thereby providing the user with all of the functionality they expect while still maintaining the OS/370 hardware’s system integrity. All of this functionality is provided by the VM Operating System running on the hardware.

How does it work?

The VM Operating System is the "brains" of the entire IBM Virtual Machine architecture. The entire system, both Operating System and hardware is referred to as the VM System. Each VM system is controlled by a program called the Control Program. In addition to managing the actual physical hardware, this Control Program creates a virtual machine for any and every user of the system, with this virtual machine being an exact simulation of a System/370 or System/390 mainframe computer. The important part of this IBM concept of virtual machines is that each user can run programs, store data and even crash the virtual machine they are running on without ever interfering with the VM system itself, or the other users of the system. Therefore, the IBM VM model not only allows resource sharing, but also protection of system resources.

Therefore, the IBM VM model not only allows resource sharing, but also protection of system resources.

The Control Program is the most important part of a VM system, and actually runs directly on the hardware of the mainframe computer. The Control Program administers the system hardware, system support tasks including startup and shutdown, as well as scheduling and execution of requests. The Control Program also manages the programming features that are supplied to each virtual machine, as well as the creation and maintenance of each virtual machine.

Along with the Control Program, the other main component that users of a VM system interact with is the Conversational Monitor System (or CMS for short). This term sounds complex, but basically the CMS provides the Operating system tasks that users need to work. Some of these services include file system commands, the ability to load and execute programs, memory management, screen and window services and the services that allow a user to write applications. The CMS is an Operating system that has been designed for a single user with a single task at a time. Although the system has the ability to handle multiple tasks at once, it is primarily used for a single task at a time. Each virtual machine has its own copy of CMS, thereby giving all users the same interface and functionality.

In addition to the Control Program and the CMS, there are a few other pieces that make up the VM system architecture. These pieces include the Group Control System, the Transparent System Access Facility, some additional Services, and the Dump Viewing Facility. I know what you are thinking, what does all of that gobbledygook mean? Well, to be honest, none of the aforementioned is essential to achieving a basic understanding of the IBM Virtual Machine system. So, we will now concentrate on the way that the Control Program and the Conversational Monitoring System handle this mapping of instructions.

...the IBM VM system's instruction set is essentially a one-to-one mapping.

As mentioned in the overview above, the instruction set is essentially a one-to-one mapping. For speed and conveniences sake, most every instruction available on the System/370 and System/390 system is run directly by the system. This means that the CMS allows the user to run the instruction and have the functionality that the user would expect, with no penalty in speed. Now, I did say most, and this leaves us with the small subset of instructions, which the VM system deems as sensitive.

A sensitive instruction in this case would be one that essentially would allow the user to alter the state of another user’s virtual machine, alter the state of the system hardware, as well as a few other sensitive or protected functions. Now, to illustrate this, let’s look at an example:

Let’s say a user tries to execute an instruction which grants them access to another user’s virtual machine and its resources. This instruction would be trapped by the CMS, and flagged as a sensitive instruction. This means that the CMS would recognize this instruction as a protected instruction and then pass it on to the Control Program with a special flag which would tell the Control Program, "this is a protected instruction." The computing term is called an interrupt, but that’s not important for this article.

Now, the Control Program would receive this instruction with this flag telling the Control Program that the instruction is a sensitive one. The Control Program would then take this instruction and perform some special routines, or checks, on the instruction to see what it should do. These routines would tell the Control Program whether it can attempt to simulate the execution of the instruction, or whether the instruction should be blocked altogether. If the Control Program simulates the instruction, the user would never know that they had attempted to run a sensitive instruction, and their system would continue as if nothing out of the ordinary occurred. If the Control Program must block the execution of the instruction, then a message would be relayed back to the user telling them the error and the program would most likely stop execution.

Conclusion

After reading through the above paragraphs, you now have a basic understanding of what the IBM model of the Virtual Machine is, and how it works. That’s all well and good, but I will bet you are wondering if this model actually works. Does it perform as advertised? Well, to be perfectly honest, having used the system myself, it does indeed work.

The IBM VM system provides a way to share large systems with multiple users in a secure way.

The IBM VM system provides a way to share large systems with multiple users in a secure way. By creating copies of the actual machine for each user, the IBM system allows each user the same functionality and resources, without compromising any single user’s privacy or security. The system is stable enough after nearly thirty years of development that it is widely used in both businesses and universities as a resource-sharing system.

The Java Virtual Machine Model

One interpretation of a virtual machine (VM) that is used frequently in the computer industry is the idea of the "simulated machine." This notion of the VM is very different from the IBM view of the VM. IBM’s idea was to partition the systems memory and resources into separate exact copies of the current machine. In the case of the simulated machine the system is not separated. A new "machine" or VM is instead placed on the current system, lending its distinct functionality to the user without altering the system. This type of VM has proven to be quite powerful allowing software developers to emulate one machine on a completely different machine. Recently this idea has brought about the creation of the powerful computer programming language, known as Java.

The Java programming language relies on the simulated machine, known as the Java virtual machine (JVM). The JVM allows the computer programmer to communicate with the virtual machine instead of the system. Thus the programmer utilizes functions that are built into the JVM and not the operating system. This is advantageous, because it allows for portability. If the same JVM is installed on two completely different machines then one Java program should work on both machines, because it relies on the JVM and not the system it is running on. Due to its relatively high portability, Java has become the principal programming language of the Internet. Many web pages now incorporate Java programs, which perform specialized tasks to be displayed on a browser.

Due to its relatively high portability, Java has become the principle programming language of the Internet.

The JVM is also very small. In other words, it does not use large amounts of memory. This means that the JVM can be placed into many different machines. Machines like TV sets, cellular phones, as well as computers. Thus, it is possible to add more complex functionality, like games, to many of the devices we use today.

How does it work?

What you might be wondering is how exactly a Java program works. How is the JVM used? Well, the JVM is what we call an abstract computer. In other words, it is implemented in software on top of a "real" hardware platform and operating system. Java programs are compiled for the JVM instead of the system. What that means is the programmer writes his/her Java program and the Java compiler translates that into language/codes that the JVM implements. These codes are called byte codes. Byte codes can be thought of as the machine language for the JVM. The JVM interprets a stream of byte codes as a sequence of instructions. These instructions are then executed to generate the desired output. Figure 1.1 shows the pathway a java program takes on its way towards execution.

As Figure 1.1 shows, once the byte codes are interpreted by the JVM the instructions are mapped to instructions in the operating system or on the hardware. What this means is the JVM actually uses operating system and machine instructions to carry out the instructions it has been given. Thus the JVM must have a possible mapping for its instructions on every operating system or machine that it is installed on in order to work. This is one of the reasons why the Java programming language has not achieved 100% portability. It is possible that the JVM has instructions that one operating system is capable of carrying out, while another is not.

Conclusion

The main purpose of the Java Virtual Machine is to solve the problems with creating portable computer programs. The question is, does the JVM completely solve this problem. The answer is no...It does not completely solve this problem. However, it provides a good solution that is for the most part effective (although not 100 percent effective). Java has still achieved a relatively high degree of portability. The power of the Java has allowed people to develop many cross-platform applications and has proven to be a useful and powerful interpretation of a virtual machine.

 

 

 

 

The OSI Virtual Machine Model

..."virtual" is used to imply that an object or device is observable without physically existing at that time and place.

 The term "virtual machine" can conjure up a wide range of images for many people. The term "virtual" is commonly used by the popular media and news broadcasts in reference to new developments in computer simulations and computer gaming programs. In either case, "virtual" is used to imply that an object or device is observable without physically existing at that time and place. This use of the term virtual is a reasonable assumption concerning the development of an extended virtual machine. The creation and continued development of an extended virtual machine is a logical growth of computer operating systems in both ability and versatility.

The need to understand how a modern computer is designed and manipulated by an operating system is the key to comprehending the extended virtual machine model. Modern operating systems consist of sets of instructions combined into service routines. These service routines are combined with data into programs that are entered into the computer as application programs. The combining of instructions into service routines is analogous to combining the simple actions of an office clerk to perform a more complex task such as an inventory of office supplies. For example, the file clerk could have a limited set of basic instructions that he can perform from memory. These instructions might be as limited as counting something, record result of a previous operation, and file or store some information for later use. These instructions used individually are of limited value. However, the instructions could be combined in a sequence of instructions to direct the office clerk to perform an inventory of office supplies. The sequence of instructions could look something like: count note paper, record result, count pencils, record result, count paper clips, record result, and file results for storage. This sequence could then be used over repeatedly to perform the inventory service when ever it was requested. The use of instructions such as "count note paper" does assume that the office clerk has certain "built-in" abilities, such as recognizing note paper and counting it properly. In a human office clerk this ability to recognize objects and count is a natural function of the clerk’s brain and eyes. In the simulated office clerk or computer these functions would be designed and built into the computer circuitry the at the hardware level. The need to implement some basic frequently used functions in circuitry instead of combining simpler instructions is apparent when examining the office clerks actions in detail. The office clerk has to physically move around the office, visually detect objects, use a note pad and pencil to record counts etc. These functions would be implemented as repeated sequences of hardware actions and software instructions. For example, the instruction "record result of last operation" would involve accessing a storage device such as a disk drive, locate space to record data, retrieve the data to be recorded from local registers, transferring the data, and writing it to the space on the hard disk. There has to be a basic level where all the instructions originate at the circuit level.

The most basic instruction is when a pattern of ones and zeros is presented to the computer and produces an action to move data, configure the system or set up a condition for needed for the next action. This level can be considered the machine instruction level from which the operating system level instructions are made. It should be clear now that any instruction set is simply a combination of lower level instruction sets. The office clerk is performing tasks that are really a series of sub tasks strung together to form a more complex sequence of actions. When the instruction "inventory" is given to the office clerk an observer perceives only the meaning of the word inventory and the associated action of the office clerk. The underlying sub sets of instructions are hidden from the observer. Each successive layer of instructions, machine circuitry, machine code, operating system instructions, and application program code, hides the underlying levels of instructions from the next user. This ability to combine instructions and construct more complicated actions is a key concept in understanding the extended virtual machine.

The eventual goal of the extended virtual machine is to build capabilities and simulated devices that do not actually exist physically in the computer. For example, most computers have a hard disk for storing data and program instructions. The hard disk may in fact be located on a different computer or consist of multiple drives attached to the same computer. An extended virtual machine approach to this situation could be to program sequences of instructions to present the user with the appearance that there is only one hard disk drive attached to the computer. The single simulated hard drive would have a storage capacity equal to all the attached hard drives. The user would see only one hard drive through the computer and simply use the combined instructions to store and retrieve data as if there was one large hard drive available. The instructions called by the user access sub routines that are combinations of lower level instructions that handle the details of tracking what information was stored on which hard disk.

 

 

 

The UNIX Virtual Machine Model

The concept of using and designing Virtual Machines has been a successful method of creating interchangeable and robust virtual devices that solve many of the problems facing computer engineers. The Virtual Machine concept has been incorporated to the UNIX operating systems process model to a very refined level. The UNIX operating system is one of the most successful and respected operating systems in used with modern computers. The wide spread use of UNIX demands that its virtual machine attributes be fully explored and categorized as true virtual machines. The UNIX operating system uses a series of independent processes to accomplish user commands by creating processes that can be arranged and configured to pass and manipulate data. The UNIX processes can be viewed conceptually as a virtual machine because it can posses many of the virtual machine attributes organic to the other three Virtual Machine models. The UNIX Virtual Machine has characteristics that emulate the IBM Virtual Machine model by using identical user shells, which act like the virtual machines of the IBM VM system. The UNIX user shells can be considered independent Virtual Machines because each user interface is an independent entity with a complete set of hardware resources available. The users’ shells act as master coordinators by spawning new processes and directing data from one process to another in order to accomplish the commands presented to the user shell by the user. The shells are constrained by memory limitations and some shared resource coordination limits to eliminate contention for critical hardware devices. However, the principle of the IBM model is retained in the isolation and separation of the user shell from its neighbor user shells.

The UNIX process also possesses a feature of the Java Virtual machine because it utilizes the uniform platform library functions presented by the layered design of the operating system. The UNIX operating system is constructed to provide a uniform set of distinct library services to user processes in execution. The UNIX operating system is built in layers with each layer providing services and functions to the layer above. This standardization enables users to execute programs on different platforms using a standard set of functions. This is possible in UNIX using the POSIX standard published by the IEEE POSIX project "Information Technology Portable Operating System Interface (POSIX?? Part 2: Shell and Utilities)" which specifies the standard for UNIX shell and utility routines. While the program code for particular program must still be compiled for each platform used, the program code is truly portable in that each compliant UNIX platform supports the same set of functions.

The OSI Virtual Machine model is also expressed in the UNIX user shell through the basic construction of the Unix Operating System. The extension of the hardware by the Unix Operating system is a basic feature of UNIX. For example, an array of separate storage disks may be used by hardware to provide a large file system. These separate disks will appear to a user a single disk, while the layer of instruction sets will provide the ability to transfer the commands from the user level to the hardware and back up the user level.

The attributes of all tree previous types of Virtual Machine models are used by the Unix Virtual Machine model to produce a very reliable and versatile method of using UNIX processes to act as Virtual Machines by creating other processes and directing process output to accomplish user tasks. The UNIX user process accepts user input and creates a series of virtual machine with the output of one machine being directed to the input of the next.

The end result of data manipulation and redirection of output is the completion of the user specified task.

 

 

 

 

Virtual Machine Demonstration

The applet contained below is a demonstration of the IBM Virtual Machine model. When you click on the Start button, the applet will begin running. The instruction boxes contained in the VM #2 box represent the instructions the user of VM #2 is attempting to execute. The numbers below each "box" represent the locations in memory that each user is allowed to access. As each instruction is entered, the box will light up green if the instruction is legal or red if illegal. Each instruction will show up in the CP and will once again be green for legal, red for illegal. At the completion of each instruction, you will see a message in the "user's screen" telling the user the result of each operation. Please scroll down to the bottom of the browser window and click Start to begin. If you wish to run the demonstration again, please click Clear then Start.

Note: This java applet only execute in a web browser. So, in this paper, tow pictures showing the applet’s interfaces before and after execution are inserted by editor Herry.

App’s interface before execution

 

App’s interface after execution

 

Virtual Machine Conclusion

The primary objective of the Virtual Machine project has been to provide an interested reader with an introduction to the advantages and uses of Virtual Machines. The initial focus was to define the four major conceptual models of Virtual Machines used today, The IBM Model as demonstrated in the IBM S/390, the Java Virtual Machine Model evident with multi platform Internet applications and the Extended Machine Model utilized in modern operating systems. Followed by the Unix Virtual Machine model represented by the UNIX user shell. The basis for all four Virtual Machine models is the combining of instruction sets to simulate devices or machines. The prime characteristics from each type of Virtual Machine solved a distinctly different problem that confronted computer and software engineers.

The basis for all three Virtual Machine models is combining instruction sets to simulate devices or machines.

The IBM model solved the need for a single computer system that could simulate multiple computers with different operating systems. This enabled users to create and manage multiple copies of different Virtual Machines on a single computer. A significant feature in the IBM model was that it enabled programs to share the same hardware by partitioning the computer resources and completely isolating the programs.

The Java Virtual Machine addresses the need for an application that will run on multiple operating systems. The multi-platform portability provided by the Java Virtual Machine solved the need to rewrite programs in order to move them to a different operating system. The most significant feature of the Java Virtual Machine the ability writes a program once and executes it with Java Virtual Machines on multiple platforms.

The OSI Virtual Machine model solved the problem of providing services and functions at the operating system level that did not exist in the system hardware. The Extended Machine model uses combinations of instructions to build more complex instruction sets to provide the user level with the Virtual device or service. The primary advantage of the Extended Machine is the ability to create Virtual devices and extend the features of computer systems using software. The element of commonality that connects all three Virtual Machine concepts is the mapping of instructions from the user level to lower level instruction sets and back up to the user level. This action tales place transparently to the user's view of the computer's actions. The term "transparent", however, should not be confused with the term "virtual". A transparent object actually exists but is not visible to the user. In contrast, a virtual object is visible to the user, but does not actually exist.

The Unix Virtual Machine model solved series of computer engineering problems by addressing the need for a modular approach to managing the launching and control of UNIX processes. The success of the UNIX operating systems is to a largely to the versatility and scalability of the UNIX process.

The power and success of the Virtual Machine concept comes from the ability of users to access and utilize functions and devices that are simply combinations of instruction sets. The ability to provide a virtual solution to the real limitations of modern computer systems is a very powerful tool that is continuing to extend the abilities of modern computer systems.