\documentclass[10pt,a4paper]{article}

% Packages
\usepackage{fancyhdr}           % For header and footer
\usepackage{multicol}           % Allows multicols in tables
\usepackage{tabularx}           % Intelligent column widths
\usepackage{tabulary}           % Used in header and footer
\usepackage{hhline}             % Border under tables
\usepackage{graphicx}           % For images
\usepackage{xcolor}             % For hex colours
%\usepackage[utf8x]{inputenc}    % For unicode character support
\usepackage[T1]{fontenc}        % Without this we get weird character replacements
\usepackage{colortbl}           % For coloured tables
\usepackage{setspace}           % For line height
\usepackage{lastpage}           % Needed for total page number
\usepackage{seqsplit}           % Splits long words.
%\usepackage{opensans}          % Can't make this work so far. Shame. Would be lovely.
\usepackage[normalem]{ulem}     % For underlining links
% Most of the following are not required for the majority
% of cheat sheets but are needed for some symbol support.
\usepackage{amsmath}            % Symbols
\usepackage{MnSymbol}           % Symbols
\usepackage{wasysym}            % Symbols
%\usepackage[english,german,french,spanish,italian]{babel}              % Languages

% Document Info
\author{csthrowaway}
\pdfinfo{
  /Title (cs205-cheat-sheet-chapter-1-3.pdf)
  /Creator (Cheatography)
  /Author (csthrowaway)
  /Subject (CS205  (Chapter 1-3) Cheat Sheet)
}

% Lengths and widths
\addtolength{\textwidth}{6cm}
\addtolength{\textheight}{-1cm}
\addtolength{\hoffset}{-3cm}
\addtolength{\voffset}{-2cm}
\setlength{\tabcolsep}{0.2cm} % Space between columns
\setlength{\headsep}{-12pt} % Reduce space between header and content
\setlength{\headheight}{85pt} % If less, LaTeX automatically increases it
\renewcommand{\footrulewidth}{0pt} % Remove footer line
\renewcommand{\headrulewidth}{0pt} % Remove header line
\renewcommand{\seqinsert}{\ifmmode\allowbreak\else\-\fi} % Hyphens in seqsplit
% This two commands together give roughly
% the right line height in the tables
\renewcommand{\arraystretch}{1.3}
\onehalfspacing

% Commands
\newcommand{\SetRowColor}[1]{\noalign{\gdef\RowColorName{#1}}\rowcolor{\RowColorName}} % Shortcut for row colour
\newcommand{\mymulticolumn}[3]{\multicolumn{#1}{>{\columncolor{\RowColorName}}#2}{#3}} % For coloured multi-cols
\newcolumntype{x}[1]{>{\raggedright}p{#1}} % New column types for ragged-right paragraph columns
\newcommand{\tn}{\tabularnewline} % Required as custom column type in use

% Font and Colours
\definecolor{HeadBackground}{HTML}{333333}
\definecolor{FootBackground}{HTML}{666666}
\definecolor{TextColor}{HTML}{333333}
\definecolor{DarkBackground}{HTML}{A3A3A3}
\definecolor{LightBackground}{HTML}{F3F3F3}
\renewcommand{\familydefault}{\sfdefault}
\color{TextColor}

% Header and Footer
\pagestyle{fancy}
\fancyhead{} % Set header to blank
\fancyfoot{} % Set footer to blank
\fancyhead[L]{
\noindent
\begin{multicols}{3}
\begin{tabulary}{5.8cm}{C}
    \SetRowColor{DarkBackground}
    \vspace{-7pt}
    {\parbox{\dimexpr\textwidth-2\fboxsep\relax}{\noindent
        \hspace*{-6pt}\includegraphics[width=5.8cm]{/web/www.cheatography.com/public/images/cheatography_logo.pdf}}
    }
\end{tabulary}
\columnbreak
\begin{tabulary}{11cm}{L}
    \vspace{-2pt}\large{\bf{\textcolor{DarkBackground}{\textrm{CS205  (Chapter 1-3) Cheat Sheet}}}} \\
    \normalsize{by \textcolor{DarkBackground}{csthrowaway} via \textcolor{DarkBackground}{\uline{cheatography.com/201525/cs/43038/}}}
\end{tabulary}
\end{multicols}}

\fancyfoot[L]{ \footnotesize
\noindent
\begin{multicols}{3}
\begin{tabulary}{5.8cm}{LL}
  \SetRowColor{FootBackground}
  \mymulticolumn{2}{p{5.377cm}}{\bf\textcolor{white}{Cheatographer}}  \\
  \vspace{-2pt}csthrowaway \\
  \uline{cheatography.com/csthrowaway} \\
  \end{tabulary}
\vfill
\columnbreak
\begin{tabulary}{5.8cm}{L}
  \SetRowColor{FootBackground}
  \mymulticolumn{1}{p{5.377cm}}{\bf\textcolor{white}{Cheat Sheet}}  \\
   \vspace{-2pt}Not Yet Published.\\
   Updated 15th April, 2024.\\
   Page {\thepage} of \pageref{LastPage}.
\end{tabulary}
\vfill
\columnbreak
\begin{tabulary}{5.8cm}{L}
  \SetRowColor{FootBackground}
  \mymulticolumn{1}{p{5.377cm}}{\bf\textcolor{white}{Sponsor}}  \\
  \SetRowColor{white}
  \vspace{-5pt}
  %\includegraphics[width=48px,height=48px]{dave.jpeg}
  Measure your website readability!\\
  www.readability-score.com
\end{tabulary}
\end{multicols}}




\begin{document}
\raggedright
\raggedcolumns

% Set font size to small. Switch to any value
% from this page to resize cheat sheet text:
% www.emerson.emory.edu/services/latex/latex_169.html
\footnotesize % Small font.

\begin{multicols*}{3}

\begin{tabularx}{5.377cm}{x{1.04425 cm} x{1.04425 cm} x{1.04425 cm} x{1.04425 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{4}{x{5.377cm}}{\bf\textcolor{white}{Chapter 1: Interrupts}}  \tn
% Row 0
\SetRowColor{LightBackground}
What is an OS? Program that controls the execution of \seqsplit{application} programs. Interface between \seqsplit{applications} \& hardware. & Function of an operating system: Resource \seqsplit{management} \& \seqsplit{allocation}, Controls execution of user programs, Providing services to system users & \seqsplit{Components} of an OS: CPU, RAM, I/O modules, System Bus & What is an \seqsplit{instruction}? Command to perform a specific task. \tn 
% Row Count 14 (+ 14)
% Row 1
\SetRowColor{white}
\seqsplit{Components} involved: Program counter, \seqsplit{instruction} register, \seqsplit{accumulator}, memory address register, memory buffer register & \seqsplit{Instruction} \seqsplit{(fetch/execute)} cycle: PC points to \seqsplit{instruction} in memory -\textgreater{} CPU fetch \seqsplit{instruction} that is being pointed -\textgreater{} \seqsplit{Instruction} is loaded into IR -\textgreater{} PC \seqsplit{incremented} to next \seqsplit{instruction} -\textgreater{} CPU \seqsplit{interprets} \& execute the \seqsplit{instruction}. & \# possible \seqsplit{instructions} = \# Unique \seqsplit{instructions} with opcode bits = 2\textasciicircum{}(opcode bits) & Maximum directly \seqsplit{addressabsle} memory capacity = \# Unique memory addresses = 2\textasciicircum{}(Address bits) \tn 
% Row Count 38 (+ 24)
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{5.377cm}{x{1.04425 cm} x{1.04425 cm} x{1.04425 cm} x{1.04425 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{4}{x{5.377cm}}{\bf\textcolor{white}{Chapter 1: Interrupts (cont)}}  \tn
% Row 2
\SetRowColor{LightBackground}
Size of data bus to use = number of bits in \seqsplit{instruction} format & What is an \seqsplit{interrupt:} Mechanism where the normal \seqsplit{sequencing} of \seqsplit{instructions} of CPU is \seqsplit{interrupted} to address a different task. & Polling: Wait for I/O \seqsplit{Completion}. CPU \seqsplit{constantly} ask I/O if it is done. & Types of \seqsplit{interrupts:} Program interrupt \seqsplit{(Execution} of illegal \seqsplit{instruction}, illegal access of memory space), Timer interrupt (Perform specific tasks on a regular basis), I/O \seqsplit{interrupts} (Signal \seqsplit{completion} of an I/O \seqsplit{operation)}, Hardware failure (low battery, power failure, memory error) \tn 
% Row Count 29 (+ 29)
% Row 3
\SetRowColor{white}
Fetch execute \seqsplit{instruction} cycle with \seqsplit{interrupt:} CPU -\textgreater{} Fetch next \seqsplit{instruction} -\textgreater{} Execute \seqsplit{instruction} -\textgreater{} (No interrupt, back to CPU) -\textgreater{} Check for interrupt -\textgreater{} Initiate interrupt handler -\textgreater{} CPU & Fetch \& execute stage is atomic and cannot be \seqsplit{interrupted}, Interrupt is served after the end of an execution stage & Multiple \seqsplit{interrupts:} Two \seqsplit{approaches}, Disable \seqsplit{interrupts} while interrupt is being processed, use a priority scheme & Memory hierachy: \seqsplit{(Smaller/Faster)} Register -\textgreater{} Cache -\textgreater{} RAM -\textgreater{} Secondary storage -\textgreater{} Tertiary storage \seqsplit{(Larger/Slower)} \tn 
% Row Count 49 (+ 20)
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{5.377cm}{x{1.04425 cm} x{1.04425 cm} x{1.04425 cm} x{1.04425 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{4}{x{5.377cm}}{\bf\textcolor{white}{Chapter 1: Interrupts (cont)}}  \tn
% Row 4
\SetRowColor{LightBackground}
Registers, cache are part of bios & L1 cache: Data cache \& \seqsplit{instruction} cache, \seqsplit{separation} is to prevent \seqsplit{overcrowding} of either caches & L2 cache: Larger cache that stores both data \& \seqsplit{instructions} & L3 cache: Shared by all cores, store data \& \seqsplit{instructions} to be shared among all cores \tn 
% Row Count 10 (+ 10)
% Row 5
\SetRowColor{white}
I/O \seqsplit{techniques:} \seqsplit{Programmed} I/O (CPU polling and then initiates data transfer between memory \& I/O device when device is ready), Interrupt driven I/O (When I/O device is ready to transfer data, device sends an interrupt to CPU), Direct Memory Access (DMA) (Allows I/O devices to directly read \& write to memory without \seqsplit{continuous} CPU \seqsplit{involvement}, improving data transfer \seqsplit{efficiency)} & \seqsplit{Multiprocessor} systems: Two or more processes working together in a single machine, all \seqsplit{processors} share computer memory, I/O devices, work in parallel to enhance \seqsplit{performance} \& \seqsplit{reliability}. & Types of \seqsplit{Multiprocessor} systems: Symmetric \seqsplit{multiprocessing} (No one is in charge, processes are of similar \seqsplit{capability)}, \seqsplit{Asymmetric} \seqsplit{multiprocessing} (One processor is the master, \seqsplit{controlling} the system \& \seqsplit{distributing} tasks to other \seqsplit{processors}, the slaves. & Multicore systems: Chip \seqsplit{multiprocessor}, each core consists of all \seqsplit{components} of a CPU, OS allows for \seqsplit{parallelism} in \seqsplit{multiprocessing} \seqsplit{environment}, shares memory \& I/O devices \tn 
% Row Count 49 (+ 39)
\hhline{>{\arrayrulecolor{DarkBackground}}----}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{5.377cm}{x{1.04425 cm} x{1.04425 cm} x{1.04425 cm} x{1.04425 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{4}{x{5.377cm}}{\bf\textcolor{white}{Chapter 2: Multiprogramming, time sharing}}  \tn
% Row 0
\SetRowColor{LightBackground}
What is a kernel: One program running at all times on the computer. \seqsplit{Responsibilities:} Device \seqsplit{management}, \seqsplit{Scheduling}, System calls \& APIs, \seqsplit{Protection} \& Fault tolerance, security & Kernel types: \seqsplit{MicroKernel} (Only the most essential services, high security but low \seqsplit{performance)}, \seqsplit{MonolithicKernel} (Has \seqsplit{everything}, very efficient but not secure), \seqsplit{HybridKernel} (Mix of both \seqsplit{approaches}, essential services in kernel space, most other services + drivers in user space) & Modes of \seqsplit{operation:} User mode \seqsplit{(Applications} you run are limited in what they can do), Kernel mode (Full access to hardware \& can execute any CPU \seqsplit{instruction)} & \seqsplit{Uniprogramming:} One program runs until \seqsplit{completion} before the next program starts, no 2 programs run at same time) \tn 
% Row Count 29 (+ 29)
% Row 1
\SetRowColor{white}
\seqsplit{Multiprogramming:} Multiple programs run \seqsplit{concurrently} to optimize CPU util, memory should be large for \textgreater{} 2 programs \& allow context switch among all of them. & CPU util (\%): \seqsplit{sum(duration} * CPU time : process)  / total duration (uni), max duration (multi) & Memory util - multi (\%): sum{[}(\# Jobs left at t) * duration / memory capacity at t = 5m, 10m, 15m{]}/max duration & Elapsed time: sum of all duration for uni, max duration for muti \tn 
% Row Count 45 (+ 16)
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{5.377cm}{x{1.04425 cm} x{1.04425 cm} x{1.04425 cm} x{1.04425 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{4}{x{5.377cm}}{\bf\textcolor{white}{Chapter 2: Multiprogramming, time sharing (cont)}}  \tn
% Row 2
\SetRowColor{LightBackground}
System \seqsplit{throughput:} \# Jobs completed by a certain time. & Mean(avg) \seqsplit{turnaround} time: sum(t for each process to \seqsplit{complete)/number} of processes & Time sharing system: multiple \seqsplit{interactive} jobs, shared processor time, \seqsplit{simultaneous} access. (min user response time w time sharing, max cpu util w/o time sharing) & Time slicing \seqsplit{techniques:} system clock generates time \seqsplit{interrupts} at a rate of t, at each interrupt, OS takes back control from current user program, saves state and assign processor to another user program (ISR), state of current user program is saved to disk and state of next user program is loaded to MM for \seqsplit{execution.} \tn 
% Row Count 32 (+ 32)
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{5.377cm}{x{1.04425 cm} x{1.04425 cm} x{1.04425 cm} x{1.04425 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{4}{x{5.377cm}}{\bf\textcolor{white}{Chapter 2: Multiprogramming, time sharing (cont)}}  \tn
% Row 3
\SetRowColor{LightBackground}
Android OS is a Linux based OS system, & Android \seqsplit{Application} \seqsplit{framework:Activity} Manager: An activity \seqsplit{represents} a single screen with a user \seqsplit{Interface.} \seqsplit{Responsible} for starting, stopping, and resuming \seqsplit{activities}. Window Manager: Surface manager that manages frame buffering and low-level drawing. Manage top-level window's look and behavior. Package Manager: Installs and removes \seqsplit{applications}. Telephony Manager: Allows \seqsplit{interaction} with phone, SMS, and MMS services. & Content \seqsplit{Providers:} Manage data that need to be shared between \seqsplit{applications} such as contacts, calendar info, which are stored in SQL database. Resource Manager: Manages non-code resources, such as strings, graphics, layout files. View System: Provides the user interface (UI) that displays \seqsplit{information} and responds to user actions, Lists, grids, text boxes, buttons, etc. Location Manager: Allows \seqsplit{developers} to tap into \seqsplit{location-based} services, whether by GPS, cell tower IDs, or local Wi-Fi \seqsplit{databases.} \seqsplit{Notification} Manager: Manages events, such as arriving messages and \seqsplit{appointments}. XMPP: Provides \seqsplit{standardized} messaging functions between \seqsplit{applications} & Android Activity: UI screen, Android Run time (ART): VM for android, bytecode to machine code. \tn 
% Row Count 66 (+ 66)
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{5.377cm}{x{1.04425 cm} x{1.04425 cm} x{1.04425 cm} x{1.04425 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{4}{x{5.377cm}}{\bf\textcolor{white}{Chapter 2: Multiprogramming, time sharing (cont)}}  \tn
% Row 4
\SetRowColor{LightBackground}
Android system \seqsplit{libraries:} Surface Manager (display \seqsplit{management)} OpenGL (graphics engine) Media Framework \seqsplit{(video/audio} \seqsplit{streaming)} SQLite \seqsplit{(relational} database engine) Browser Engine Bionic LibC (system C library) & \seqsplit{Differences} between android OS \& Linux OS: Power \seqsplit{management} (Power collapse, component level power \seqsplit{management}, \seqsplit{Wakelocks)}, IPC (Inter process \seqsplit{communication)} &  &  \tn 
% Row Count 21 (+ 21)
\hhline{>{\arrayrulecolor{DarkBackground}}----}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{5.377cm}{x{1.04425 cm} x{1.04425 cm} x{1.04425 cm} x{1.04425 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{4}{x{5.377cm}}{\bf\textcolor{white}{Chapter 3: Process description and control}}  \tn
% Row 0
\SetRowColor{LightBackground}
What is a program: Set of \seqsplit{instructions} that the computer can execute. Can have multiple \seqsplit{instances.} & What is a process: Task that you do on your computer, an instance of a program. \seqsplit{Components:} \seqsplit{Executable} program, \seqsplit{associated} data, execution context. & Process image: current activity state reflected by CPU registers (PC, etc), Progam code, Data Sections (Global constants \& \seqsplit{variables)}, Stack, Heap & Process elements: \seqsplit{Identifier}, State, Priority, Program Counter, Memory pointers, Context data, I/O States info, \seqsplit{Accounting} info \tn 
% Row Count 15 (+ 15)
% Row 1
\SetRowColor{white}
Process control block (PCB): Data structure created \& managed by OS, full of info about each process. New process created -\textgreater{} OS updates PCB with all process details, key tool that allows support for multiple \seqsplit{processes.} & \seqsplit{Dispatcher:} Small OS that follows a \seqsplit{scheduling} policy, handles context switching for CPU, spends a lot of time saving \seqsplit{instructions}, load new \seqsplit{instructions} into CPU from PCB. Trace: Detailed log of what a process does & Process \seqsplit{Creation:App} launch, OS start a process to do task, some process start in \seqsplit{background} w/o you directly \seqsplit{interacting} with them.Some processes are started by other \seqsplit{processes.} Parent process may wait for child to finish or continue \seqsplit{concurrently}. e.g Process A spawns other process \& so forth forming a tree. & Linux system calls: Fork(): Create copy of current process, \seqsplit{exec():Execute} a program, \seqsplit{wait():Wait} for child process to finish and change state, kill(): Send a signal to terminate a process, pipe(): IPC \tn 
% Row Count 46 (+ 31)
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{5.377cm}{x{1.04425 cm} x{1.04425 cm} x{1.04425 cm} x{1.04425 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{4}{x{5.377cm}}{\bf\textcolor{white}{Chapter 3: Process description and control (cont)}}  \tn
% Row 2
\SetRowColor{LightBackground}
Two state \seqsplit{(Running/Not} Running) process model: Process created and move to queue -\textgreater{} Process stay till CPU is ready -\textgreater{} \seqsplit{Dispatcher} move a process from not running to running state -\textgreater{} Process is \seqsplit{temporarily} stopped, move back to not running state due to an interrupt -\textgreater{} If not, Process finish execution \& leave the system. & Five state process model: New, ready, running, blocked, exit & five State \seqsplit{transitions:} New process is admitted to ready queue -\textgreater{} \seqsplit{dispatcher} assign process to be run by CPU -\textgreater{} If time out goes back to ready state -\textgreater{} If event wait (I/O \seqsplit{completion)}, process admitted to block queue, event occurs, remove from block queue \& move to ready queue to await \seqsplit{dispatcher} -\textgreater{} If process completes task, exits & To handle different types of events, there can be multiple block queues. \tn 
% Row Count 34 (+ 34)
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{5.377cm}{x{1.04425 cm} x{1.04425 cm} x{1.04425 cm} x{1.04425 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{4}{x{5.377cm}}{\bf\textcolor{white}{Chapter 3: Process description and control (cont)}}  \tn
% Row 3
\SetRowColor{LightBackground}
How does OS decide which process run when \& how long: \seqsplit{Scheduling} policy \seqsplit{(Dispatcher} choose from ready queue for CPU to run), \seqsplit{Dispatcher}, Clock (timeout of process) & Solutions for limited available memory: Virtual memory (Move part of a process from RAM to disk), Swapping (move some blocked processes entirely out to disk) & Suspended queue: Process that are moved to disk is placed in a suspend queue, OS can decide to bring suspended processes back to main memory. & \seqsplit{Transition} states: Same as five state processes but for processes in the \seqsplit{block/ready} queue, can be suspended and moved to disk \seqsplit{(block/suspend} \& \seqsplit{ready/suspend)} if there are any memory \seqsplit{constraints} in RAM. Suspended processes can be moved back to the ready queue when there is enough memory to hold them or when an event they are waiting for occurs. \tn 
% Row Count 35 (+ 35)
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{5.377cm}{x{1.04425 cm} x{1.04425 cm} x{1.04425 cm} x{1.04425 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{4}{x{5.377cm}}{\bf\textcolor{white}{Chapter 3: Process description and control (cont)}}  \tn
% Row 4
\SetRowColor{LightBackground}
\seqsplit{Information} required by OS to control processes and manage \seqsplit{resources:} Memory tables, I/O tables, File tables, Process tables & Memory tables: RAM, Secondary memory (HDD/SDD), Virtual Memory. I/O Tables: Used by OS to manage I/O devices. File tables: Provide info about the existence of files location on secondary memory, current status and other \seqsplit{attributes}. & Process tables: Process location (Where a process and its data is located in memory), Process \seqsplit{Attributes} (\# \seqsplit{Attributes} used by OS for control) & Process list \seqsplit{structures:} OS has a list of PCBs in each queue (running, ready, block) it use to keep track of all \seqsplit{processes.} \tn 
% Row Count 24 (+ 24)
% Row 5
\SetRowColor{white}
\seqsplit{Transitions:} When a new process is created -\textgreater{} unique \seqsplit{identifier} assigned -\textgreater{} Memory space allocated for process image -\textgreater{} PCB is \seqsplit{initialised} -\textgreater{} set up linkage between parent and child processes -\textgreater{} Update all other data \seqsplit{structures} & \seqsplit{Process/Context} \seqsplit{switching:} Necessary for \seqsplit{multitasking}. Occurs from a clock interrupt, I/O interrupt, Traps (Errors generated with running process), \seqsplit{Supervisor} call (User process calls for I/O operation \& is blocked) & Mode \seqsplit{switching:} User Mode (Where user \seqsplit{applications} run, Less \seqsplit{privileged)}, Kernel Mode (Where the OS runs, Highly \seqsplit{privileged)} & Costs involved for mode \seqsplit{switching:} Save state of current process, switch cpu to kernel mode to execute system call, restore state of process once system call is completed and switch back to user mode. \tn 
% Row Count 47 (+ 23)
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{5.377cm}{x{1.04425 cm} x{1.04425 cm} x{1.04425 cm} x{1.04425 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{4}{x{5.377cm}}{\bf\textcolor{white}{Chapter 3: Process description and control (cont)}}  \tn
% Row 6
\SetRowColor{LightBackground}
Mode switch with process switch: Save context of processor -\textgreater{} Update PCB -\textgreater{} Move the PCB to the \seqsplit{appropriate} queue -\textgreater{} Select another process for execution -\textgreater{} Update the PCB of the process selected -\textgreater{} Update memory \seqsplit{management} data \seqsplit{structures} for address \seqsplit{translation} -\textgreater{} Restore the context of the processor to that which existed at the time the selected process was last switched out & Mode switch w/o process switch: Interrupt is pending -\textgreater{} Save the context (PC, processor registers, stack pointer) into the PCB of the current process -\textgreater{} Sets the program counter to the starting address of an interrupt handler program -\textgreater{} Switches from user mode to kernel mode & \seqsplit{Traditional} OS: All user processes rely on a single \seqsplit{monolithic} kernel & Process switching \seqsplit{functions:} OS function executes within user \seqsplit{processes.} Mode switch w/o process switch in a user program (fopen()), Process switching function takes place when a process switches its state. \tn 
% Row Count 38 (+ 38)
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{5.377cm}{x{1.04425 cm} x{1.04425 cm} x{1.04425 cm} x{1.04425 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{4}{x{5.377cm}}{\bf\textcolor{white}{Chapter 3: Process description and control (cont)}}  \tn
% Row 7
\SetRowColor{LightBackground}
\mymulticolumn{4}{x{5.377cm}}{process based OS: Processes are assigned different priorities to be scheduled for running, good for multi processor env} \tn 
% Row Count 3 (+ 3)
\hhline{>{\arrayrulecolor{DarkBackground}}----}
\end{tabularx}
\par\addvspace{1.3em}


% That's all folks
\end{multicols*}

\end{document}