Processes, Threads, Functions

Kinds of Program Control Flows

1. Functions, where things execute one at a time.  Hopefully you're familiar with normal functions.
• Registers: by convention, some are saved (must restore value for caller), some are scratch (can freely overwrite)
• Stack: organized by convention into "stack frames"
• Memory: shared between all functions
• Files: shared between all functions
  
2. User-level threads, where you save and restore processor registers yourself, usually via an explicit "swap" subroutine call.  Also called "coroutines" or "user/userspace threads", or (by Sun Java folks) "green threads".  Check out my little "minithread" example code for an example (Directory, Zip, Tar-gzip).   The key routine is just the "mth_swap" subroutine, which saves an old set of registers and loads up a new one, and the core of this is just:
       mov [eax],esp  ; Save the old stack pointer
       mov esp, [ecx] ; Load up the new stack pointer
     Typical examples include Netscape Threads, or any of a thousand tiny projects mostly relying on setjmp/longjmp or "makecontext/swapcontext".  Each thread has its own stack, usually just allocated with "malloc", but shares the rest of memory with other user-level threads.
• Registers: explicitly saved and restored by a "swap" routine.
• Stack: each user-level thread has a separate stack region in memory.
• Memory & Files: shared between all threads.
  
3. Kernel-level threads, or just "threads", are where the OS saves and restores processor registers to switch threads at interrupt time.  Also called "native threads". The most common example is pthreads.  There's actually a hybrid of kernel and user-level threads where you save and restore processor registers yourself (not in the OS), but you do it inside a signal handler during an interrupt.
• Registers: implicitly saved and restored by the OS when it decides to switch threads.
• Stack: separate regions of memory for each thread.
• Memory & Files: usually shared between all threads.
4. Processes, where the OS swaps out all of memory and all I/O connections in addition to the registers.  This is what you usually think of as a "program"--we covered it last class.
• Registers: implicitly saved and restored by the OS when it decides to switch processes.
• Stack & memory: completely separate memory area for each process.
• Files: open files are local to a process (I open a file, it's not open for you), but data in files is shared between all processes.
  
5. Virtual Machines, where the OS itself and everything in it is swapped out. QEMU is a pretty typical example.  A virtual machine is usually treated as an ordinary process inside the outer ("host") OS.
• Registers, stack, memory, files, disks, and even CPUs are all private to a virtual machine.
  

Creating Different Program Control Flows