Processors, Parallel Processing and Virtual Machines

Pipelining is a technique in which the fetch, decode and execute stages of successive instructions are overlapped, so that while one instruction is being executed the next is being decoded and a further instruction is being fetched. This means more than one instruction is being processed at the same time, increasing the number of instructions completed per unit time (throughput).

A virtual machine is software that emulates a complete computer, providing virtual hardware (a virtual processor, memory and storage) on which a guest operating system or program can run as though it had its own physical machine.

Example of use: running several different operating systems on one physical computer at the same time (for example, to test software on Windows, macOS and Linux without needing three separate machines). (Other valid examples: the Java Virtual Machine running platform-independent bytecode; safely running untrusted software in an isolated 'sandbox'.)

How pipelining improves performance: Pipelining overlaps the stages of successive instructions instead of finishing one instruction completely before starting the next. While instruction 1 is being executed, instruction 2 can be decoded and instruction 3 can be fetched at the same time. This keeps all parts of the processor busy on every clock cycle, so more instructions are completed per unit time (higher throughput), even though each individual instruction still takes the same number of stages.

RISC processors are well suited to pipelining because their instructions are simple, of a fixed length and (mostly) take a similar time, so the pipeline stages line up neatly and the pipeline stays full.

Situation that reduces the benefit: A branch/jump (or conditional instruction) can mean the instructions already fetched into the pipeline are the wrong ones, so the pipeline must be flushed and refilled — wasting cycles. (A data dependency, where an instruction needs the result of one still in the pipeline, has the same stalling effect.)

Flynn's taxonomy classifies architectures by the number of instruction streams and data streams.

SISD (Single Instruction stream, Single Data stream): a single processor fetches and executes one instruction at a time, acting on a single data item. This is the traditional single-processor (uniprocessor) computer; there is no parallelism.

SIMD (Single Instruction stream, Multiple Data streams): a single instruction is applied to many data items simultaneously by multiple processing elements. It suits operations that repeat the same calculation over a large dataset, such as image processing on a GPU or array/vector processors.

MISD (Multiple Instruction streams, Single Data stream): multiple processors each perform different instructions on the same single data item. This is rare and largely theoretical; it can be used where the same data is processed in different ways for redundancy/fault tolerance.

MIMD (Multiple Instruction streams, Multiple Data streams): multiple processors each execute their own (different) instructions on their own (different) data at the same time. This is the most common form of true parallel processing, found in multicore processors, multiprocessor systems and computer clusters.

Instruction set: A RISC (Reduced Instruction Set Computer) processor has a small set of simple, fixed-length instructions, most of which execute in a single clock cycle; this shifts more work onto the compiler, which must combine simple instructions to do complex tasks. A CISC (Complex Instruction Set Computer) processor has a large set of complex, variable-length instructions, some taking several cycles; this makes programs shorter and compilation simpler, but the hardware more complicated.

Registers: RISC provides many general-purpose registers (often with register windows/banks), so operands are kept in fast registers and main-memory accesses are reduced. CISC typically has fewer registers and allows more operations to act directly on memory.

Pipelining: RISC's uniform, fixed-length, one-cycle instructions divide neatly into equal pipeline stages, so RISC relies heavily on pipelining to overlap instructions and raise throughput. CISC's variable-length, multi-cycle instructions take unequal times, making efficient pipelining harder.

Interrupt handling: On RISC, instructions are short and complete quickly, so interrupts generally occur cleanly between instructions, and the many registers allow the process state to be saved and restored very quickly (e.g. by switching register sets) — so interrupt handling is simpler and faster. On CISC, a long multi-cycle instruction may be interrupted mid-execution and must be suspended or restarted, and with fewer registers more state must be copied to memory, so interrupt handling is more complex and slower.

A virtual machine (VM) is software that emulates a complete computer so that a guest operating system or program can run on it as if it had dedicated hardware. Several VMs can run on one physical host, managed by a hypervisor.

Benefits

• Multiple operating systems on one machine: several different OSes can run at the same time on a single physical computer, e.g. for testing software across Windows, Linux and macOS without buying extra machines.
• Isolation / security: each VM is sandboxed, so a crash, virus or fault in one VM does not affect the host or the other VMs — making VMs ideal for safely running or analysing untrusted software.
• Efficient use of hardware: one powerful server can be divided among many VMs, raising utilisation and reducing the number of physical machines, power and space required (the basis of cloud computing/server consolidation).
• Portability and easy management: a VM is just a set of files, so it can be copied, moved to another host, backed up, or restored from a snapshot quickly; new environments can be created on demand.
• Platform independence (intermediate machines): an intermediate VM such as the Java Virtual Machine runs bytecode, so the same compiled program runs on any device that has the VM — 'write once, run anywhere'.

Limitations

• Performance overhead: the VM software adds a layer between the guest OS and the real hardware, so programs generally run more slowly than on the bare machine.
• Resource demands: each VM needs its own share of CPU, memory and storage; running many VMs requires powerful, well-resourced hardware, and over-allocating degrades all of them.
• Not identical to real hardware: the emulated environment may not behave exactly like a physical machine, and some hardware-specific features (e.g. certain devices or performance characteristics) may be unavailable or imperfectly emulated.
• Complexity and single point of failure: managing the hypervisor adds complexity, and if the host machine fails, all the VMs running on it fail too.

Conclusion: Virtual machines bring strong benefits in flexibility, isolation and efficient hardware use, which is why they underpin testing, security sandboxing and cloud computing. The trade-off is reduced performance, heavier resource requirements and an environment that is not a perfect copy of real hardware — so for performance-critical or strongly hardware-dependent tasks a physical machine may still be preferred.