1.2.1h Virtual Machines

A machine that is emulated on another

Implemented using hardware, software, firmware or a combination

Different forms of virtualisation
 * Processor Architecture virtualisation
 * Server virtualisation
 * OS level virtualisation
 * Process virtualisation

Architecture Virtualisation
Processors are designed for backwards compatibility
 * e.g. Intel x64 processors can emulate
 * x86 (32-bit architecture) – starts in 16-bit ‘real mode’ upon boot
 * 8086 16-bit architecture
 * 8080 8-bit architecture (cira 1974)

legacy systems
 * Why?
 * Support for
 * E.g. 32-bit MS Word will still work on a 64 bit processor
 * Keep users happy
 * Don’t have to upgrade all of their programs to the latest 64-bit version
 * Can use older 32-bit programs with a 64 bit processor

Server Virtualisation
time OSes
 * Requires a hypervisor (VM monitor)
 * Implemented in hardware, software and/or firmware
 * Manages VMs
 * Different OSes run on the same hardware at the same
 * Each VM is a guest machine
 * Hardware is the host machine
 * Each OS is oblivious to the existence of the other
 * E.g. Windows XP, Linux and Windows 10 run on the same hardware

Why?

 * Different programs can require different OSes

crashes, the others can still run
 * Different configurations for the nature of different programs/user accounts requirements
 * E.g. let students have full access to a virtual Windows NT server
 * Testing and isolating erroneous programs
 * Stability
 * If one OS
 * Maintenance
 * Easy to transfer to a new server – no need to reinstall drivers for new hardware.

OS Level Virtualisation

 * Two or more OSes share one OS Kernel
 * Each OS is effectively separate from the other OSes
 * Very little overhead
 * Virtual memory is split
 * Kernel space
 * User space (for each virtual OS)
 * Why?
 * Virtual hosts – security, hardware independence

Process (Software) Virtualisation (AKA Application Virtualisation)
run runtime
 * Code is compiled to intermediate code e.g.
 * Java => Bytecode
 * Flash => swf
 * Requires a ‘virtual machine’ emulator (software) to
 * Java VM
 * Flash Player
 * VM translates intermediate code to machine code at

Why?
software is platform independent and so portable
 * Compiled
 * Don’t need a different compiler (source code => machine code) for each platform
 * Security and testing – software runs in a sandbox – can’t see or interact with other system processes
 * The hardware can be (not always) abstracted away from the developer (less to worry about)

But
for each platform (No VM=no software)
 * Needs a VM
 * Slight decrease in execution speed
 * Program can’t be optimized for a given architecture instruction set
 * Program can’t take advantage of any specialist architecture instructions