Virtualization
==============

Clients and servers are expensive - what if we could run different clients and servers on the same machine?

Techniques
----------

- Multiplexing: create multiple virtual objects from one underlying object
    - e.g. disk partitioning, virtual memory, sockets
- Aggregation: create one virtual object from multiple underlying objects
    - e.g. RAID
- Emulation: create a new type of virtual object from underlying objects
    - e.g. console emulators

Common Abstractions
-------------------

- send and recv with bounded buffer
    - abstraction of communication
- virt memory
    - abstraction of physical memory
- threads and processors
    - abstraction of interpreter

All of these are more general and can be provided directly, or by using virtualization

Multiplexing
^^^^^^^^^^^^
**Physical v. Temporal**

Take, for example, the CPU. We need to multiplex the CPU but obviously can't have certain applications only use
*part* of the CPU - so we multiplex in **time** using **threads**.

This is called **timesharing**. Only one application is really using the CPU at a time.

On the other hand, we *can* multiplex memory by splitting it up into virtual blocks - which is **physical**
multiplexing. (handled by the Memory Management Unit on CPU)

A thread (CPU abstraction) + virtual memory is called a **process**.

Threads
"""""""

- a single thread state consists of:
    - reference to next instruction (PC)
    - references to environment (stack, heap, registers, etc)
- single thread can be suspended at any time and later resumed
    - save thread state, protect the environment
- OS multiplexes the CPU using threads

**Managing Threads**

- thread created by another thread
    - program says to create a thread
    - user requests one (special case of program doing it)
- first thread created by OS: ``init``, parent of all processes
    - child threads (in unix) are spawned using ``fork()``
- OS
    - initializes the thread state
    - finds the thread code and data and loads it into memory
    - sets the initial PC
- thread manager in OS maintains illusion of vCPU
    - gives CPU to one thread at a time
    - ensures one thread doesn't monopolize CPU
    - protects threads from one another

**Interrupts**

- a change in "normal" execution of a CPU
- 2 different kinds:
    - computer-wide: hardware such as a disk or network card
    - thread-specific: address error, illegal instruction, math error
- computer-wide interrupts:
    - may have nothing to do with the current running thread
    - runs in the context of the OS (interrupt handler)
    - delivered to appropriate thread when it's running (maybe later)
- thread-specific interrupts (**exceptions**):
    - runs in the state of the current thread
    - delivered to individual thread without impacting other threads

Bounded Buffer
^^^^^^^^^^^^^^

- OS provides bounded buffers
    - allows threads to communicate
    - supports SEND/RECV
    - various implementations - threads don't care
- threads can't communicate directly w/o the OS
    - reduces error propogation
    - allows use of different mechanisms

Emulation
^^^^^^^^^
An OS is an "easy to use" abstraction - VMs are virtualization via emulation

the interface appears exactly the same as raw hardware, but it's not