List of Figures

1. Required and Recommended
2. Abstract view. Where the OS fits in.
3. Operating systems turn ugly hardware into beautiful abstractions.
4. A modern computer system.
5. Booting the computer.
6. UNIX System initialization
7. Interrupt time line for a single process doing output.
8. Interrupt
9. Fetch and Execute Cycle
10. A typical memory hierarchy. The numbers are very rough approximations.
11. Cache and Main Memory
12. Left: Cache Memory. Right: (a) A quad-core chip with a shared L2 cache. (b) A quad-core chip with separate L2 caches.
13. IBM Advanced Storage Roadmap.
14. Left: Structure of a disk drive. Right: The steps in starting an I/O device.
15. Upper: Top-level Components. Lower: The structure of a large Pentium system.
16. The shell
17. An IBM 704 mainframe.
18. An early batch system.(a) Programmers bring cards to 1401. (b) 1401 reads batch of jobs onto tape. (c) Operator carries input tape to 7094. (d) 7094 does computing. (e) Operator carries output tape to 1401. (f) 1401 prints output.
19. Left: Memory layout of a simple batch. Right: A multiprogramming system with three jobs in memory.
20. Job Interleaving
21. IBM PC XT.
22. Left: Tightly coupled system. Right: The Cray-2, the world's fastest computer from 1985 to 1989.
23. Symmetric multiprocessing architecture.
24. A Dual-Core Design.
25. Left: Client-Server. Right: An example of a computer cluster - this is a Silicon Graphics Cluster-SGI.
26. Transition from user to kernel mode.
27. A process tree. Process A created two child processes, B and C. Process B created three child processes, D, E, and F.
28. Performance of various levels of storage.
29. A stripped-down shell.
30. Example of how system calls are used.
31. The handling of a user application invoking the open() system call.
32. Passing of parameters as a table.
33. Some of the major POSIX system calls.
34. Examples of Windows and Unix System Calls.
35. C library handling of write().
36. MS-DOS execution. (a) At system start-up. (b) Running a program.
37. FreeBSD running multiple programs.
38. MS-DOS layer structure.
39. UNIX system structure.
40. A layered operating system.
41. Structure of the THE operating system.
42. Structure of the MINIX 3 system.
43. Solaris loadable modules.
44. System models. (a) Nonvirtual machine. (b) Virtual machine.
45. VMware architecture.
46. The Java virtual machine.
47. (a) Multiprogramming of four programs. (b) Conceptual model of four independent, sequential processes. (c) Only one program is active at once.
48. Process in memory.
49. Diagram of process state.
50. The lowest layer of a process-structured OS handles interrupts and scheduling. Above that layer are sequential processes.
51. Process control block (PCB).
52. Some of the fields of a typical process table entry.
53. Diagram showing CPU switch from process to process.
54. The ready queue and various I/O device queues.
55. Queueing-diagram representation of process scheduling.
56. Addition of medium-term scheduling to the queuing diagram.
57. CPU utilization as a function of the number of processes in memory.
58. Process creation.
59. Communications models. (a) Message passing. (b) Shared memory.
60. The first column lists some items shared by all threads in a process (process properties). The second one lists some items private to each thread.
61. Single-threaded and multithreaded processes.
62. Left: A word processor with three threads. Right: A multithreaded web server.
63. (a) A user-level threads package. (b) A threads package managed by the kernel.
64. Many-to-one model.
65. One-to-one model.
66. Many-to-many model.
67. Some of the Pthreads function calls.
68. Some flags for $clone()$ system call.
69. Alternating sequence of CPU and I/O bursts.
70. Histogram of CPU-burst durations.
71. Bursts of CPU usage alternate with periods of waiting for I/O. (a) A CPU-bound process. (b) An I/O-bound process.
72. Some goals of the scheduling algorithm under different circumstances.
73. An example to First-Come First-Served.
74. An example of shortest job first scheduling. (a) Running four jobs in the original order. (b) Running them in shortest job first order.
75. An example to Shortest Job First.
76. Example of non-pre-emptive SJF and pre-emptive SJF.
77. A scheduling algorithm with four priority classes.
78. An example to Priority-based Scheduling.
79. Round-robin scheduling. (a) The list of runnable processes. (b) The list of runnable processes after B uses up its quantum.
80. The way in which a smaller time quantum increases context switches.
81. An example to Round Robin.
82. Multilevel queue scheduling.
83. Multilevel feedback queues.
84. The relationship between priorities and time-slice length.
85. List of tasks indexed according to priority.
86. Mutual exclusion using critical regions.
87. General structure of a typical process $P_i$.
88. Solution to the critical-section problem using locks.
89. A proposed solution to the critical region problem. (a) Process 0. (b) Process 1.
90. The structure of process $P_i$ in Peterson's solution.
91. Peterson's solution for achieving mutual exclusion.
92. Mutual-exclusion implementation with semaphores.
93. Some of the Pthreads calls relating to the mutexes.
94. Using threads to solve the producer-consumer problem.
95. The structure of the producer process.
96. The structure of the consumer process.
97. The producer-consumer problem using semaphores.
98. The structure of a writer process.
99. The structure of a reader process.
100. The situation of the dining philosophers.
101. The structure of philosopher $i$.
102. A solution to the dining philosophers problem.
103. Syntax of a monitor.
104. Schematic view of a monitor.
105. An outline of the producer-consumer problem with Java.
106. Using a semaphore to protect resources. (a) One resource. (b) Two resources.
107. (a) Deadlock-free code. (b) Code with a potential deadlock.
108. An example to Deadlock.
109. Resource allocation graphs. (a) Holding a resource. (b) Requesting a resource. (c) Deadlock.
110. Left: Resource-allocation graph. Middle: Resource-allocation graph with a deadlock. Right: Resource-allocation graph with a cycle but no deadlock
111. Resource Allocation Graphs. Lower; either $P_2$ or $P_4$ could relinquish (release) a resource allowing $P_1$ or $P_3$ (which are currently blocked) to continue.
112. An example of how deadlock occurs and how it can be avoided.
113. Summary of approaches, to deadlock prevention.
114. Safe, unsafe, and deadlock state spaces.
115. Demonstration that the state in is safe (Upper), is not safe (Lower).
116. (a) Resource-allocation graph. (b) Corresponding wait-for graph.
117. (a) A resource graph. (b) A cycle extracted from (a).
118. A base and a limit register define a logical address space.
119. Hardware address protection with base and limit registers.
120. Multistep processing of a user program.
121. Dynamic relocation using a relocation register.
122. Swapping of two processes using a disk as a backing store.
123. Hardware support for relocation and limit registers.
124. Paging hardware.
125. Paging model of logical and physical memory.
126. Paging example for a 32-byte memory with 4-byte pages.
127. Free frames (a) before allocation and (b) after allocation.
128. Valid (v) or invalid (i) bit in a page table.
129. Sharing of code in a paging environment.
130. User's view of a program.
131. Segmentation hardware.
132. Example of segmentation.
133. Diagram showing virtual memory that is larger than physical memory.
134. Virtual address space.
135. Shared library using virtual memory.
136. Transfer of a paged memory to contiguous disk space.
137. Page table when some pages are not in main memory.
138. Steps in handling a page fault.
139. Before process 1 modifies page C.
140. After process 1 modifies page C.
141. Need for page replacement.
142. Page replacement.
143. Graph of page faults versus number of frames.
144. FIFO page-replacement algorithm.
145. Optimal page-replacement algorithm.
146. LRU page-replacement algorithm.
147. Thrashing.
148. Some possible file attributes.
149. File operations.
150. A simple program to copy a file.
151. Common file types.
152. (a) An executable file. (b) An archive.
153. Three kinds of files. (a) Byte sequence. (b) Record sequence. (c) Tree.
154. Sequential-access file.
155. Simulation of sequential access on a direct-access file.
156. Example of index and relative files.
157. A typical file-system organization.
158. Single-level directory.
159. Two-level directory structure.
160. Tree-structured directory structure.
161. Acyclic-graph directory structure.
162. A UNIX directory tree.
163. File system. (a) Existing system. (b) Unmounted volume.
164. Mount point.
165. Layered file system.
166. A possible file system layout.
167. A typical file-control block.
168. In-memory file-system structures. (a) File open. (b) File read.
169. Schematic view of a virtual file system.
170. (a) Contiguous allocation of disk space for seven files. (b) The state of the disk after files D and F have been removed.
171. Contiguous allocation of disk space.
172. Storing a file as a linked list of disk blocks.
173. Linked allocation of disk space.
174. File allocation table.
175. An example i-node.
176. Indexed allocation of disk space.
177. The steps in looking up /usr/ast/mbox.
178. The UNIX inode.
179. (a) Contiguous allocation (b) Contiguous allocation with compaction (c) Storing a file as a linked list of disk blocks (d) Storing a file as a linked list of disk blocks with defragmentation (e) Indexed allocation with block partitions (f) Indexed allocation with variable-length partitions.
180. Linked free-space list on disk.
181. (a) Storing the free list on a linked list. (b) A bitmap.
182. Moving-head disk mechanism.
183. Disk Performance.
184. System's partition table.
185. Physical geometry of a disk with two zones and a possible virtual geometry for this disk.
186. Disk parameters for the original IBM PC floppy disk and a Western Digital WD 18300 hard disk.
187. Network-attached storage.
188. Storage-area network.
189. FCFS disk scheduling.
190. SSTF disk scheduling.
191. SCAN disk scheduling.
192. C-SCAN disk scheduling.
193. C-LOOK disk scheduling.
194. An illustration of cylinder skew.
195. RAID levels.