EEN521 T, Operating Systems, Spring 2015
Tues, Thurs at 5:00 p.m. in MM202

The Book

Documentation

Assignments

email to grader521 at rabbit.eng.miami.edu, include typescript/screenshot.
     1   Due   Sat 31 Jan      Basic BCPL data structures.     
2   Due   Sat 28 Feb Stack Over-Run Security Vulnerability.
Here is the innocent little program that must be exploited.
3   Due   Thur 9 Apr Make a Process.
4   Due   Sun 19 Apr Multiprocessing, with a small command shell.
5   Due   Sun 26 Apr Disc file system, will need a working newvec/freevec.
6   Due   Tues 5 May 4 and 5 combined into a usable OS.
The grader's reminders page.

Class History

Class 1  Tue 13‑1‑2015   Quick introductions, etc.
Mystery one: apparently sharing the same memory between two programs.
Mystery two: the blocks on a little disc (.doc), (.docx).
Recommend you print the BCPL documentation and bring it to next class for note taking.
Class 2  Thur 15‑1‑2015   The lineage and nature of languages including BCPL, C, and Java.
The basics of BCPL.
Class 3  Tue 20‑1‑2015   Highlights: why switch is fast, STACK FRAMES and the frame pointer, numbargs, lhs, static, @ and !, vec.
Class 4  Thur 22‑1‑2015   All about the heap, data structures, and various little bitty details.
Class 5  Tue 27‑1‑2015   Mode = SYS or USR: how you can stop mischievous programmers from doing things they shouldn't while still allowing the operating system to do things it should. The primitive basis for virtual memory - although the diagram was complicated, the concepts are not; work through it and make sure you've got it. (here is a simplified diagram, it only supports two segments, and leaves out a lot of details, but might help you to remember).
Class 6  Thur 29‑1‑2015   Debugging the serious way - this is the incorrect program that we debugged.
Also included: the exact instruction by instruction sequence for function calls / stack frame construction.
Class 7  Tue 3‑2‑2015   Here is the virtual memory picture from last week.
The modern version, cache (fast associative memory) and page based virtual memory.
Class 8  Thur 5‑2‑2015   Starting an operating system up.
Class 9  Tue 10‑2‑2015   Setting up virtual memory.
Alternate sources: Intel's version (from the 80486), which is almost identical to ours. The book also covers it in the "virtual memory" chapter.
Here is a plain text version of the program.
Class 10  Thur 12‑2‑2015   Manipulating and working under virtual memory.
The starting point, Causing a page fault and not surviving
Adding a physical page to the virtual address space
Catching and dealing with a page fault.
Class 11  Tue 17‑2‑2015   Things to learn from magnetic tapes (picture A, B), a reminder about probability,
Blocks, CRCs, inter-block gaps: all very necessary, even for modern discs.
Class 12  Thur 19‑2‑2015   The article about the unreliability of tape backups.
Magnetic drums: one, two, specs from 1957.
A high-end disc drive from 1963.
Disc organisation: keeping trach of free and in-use blocks - one bit per block (slow), FAT-16 (dreadful). CHS numbering but we use Logical Block Access now, Partitions.
Class 13  Tue 24‑2‑2015   Clusters, defragmentation, methods for maintaining a free block list: bitmaps not good, list (i.e. stack or queue) of addresses of free blocks better than it sounds; moving window(s) into list kept in memory makes it fast.
Class 14  Thur 26‑2‑2015   Actual file structures, 1-level, 2-level and so on indexes, variable level indexes, I-nodes. Minimum and maximum file sizes and access times for sequential and random access. The significant effect of cluster size on all of those things. Memory buffers help a lot.
Class 15  Tue 3‑3‑2015   What goes in directory entry vs header block? Hard and soft links. Other considerations for header block contents. The unix I-node list, fsck.
What is a B-Tree?
Class 16  Thur 5‑3‑2015   What we really want is a B+ tree for ReiserFS
Hash tables and ISAM on disc - really just for databases.
8th to 14th Break
Class 17  Tue 17‑3‑2015   Google announcement, flyer.
How easy it is to manipulate a buffer over-run if you experiment.
Slight beginnings of heap management.
Class 18  Thur 19‑3‑2015   All about heap implementation. Using space in the free chunks themselves to keep a doubly linked list of them, needing to store the size and status in all chunks, even used ones. Merging neighbouring free chunks to avoid memory fragmentation. A separate list for each free chunk size restores efficiency.
Class 19  Tue 24‑3‑2015   Various physical devices, memory Mercury delay line, again, Nickel wire, Ferrite cores: two, three, four, five, six, seven.
and others: card reader, line printer, graph plotter, ASR33 teletype.
The problems that occur when devices (such as memory or card readers) are shared. Device drivers seem to solve the problem, but it turns out something more is needed. What a Critical Section is.
Class 20  Thur 26‑3‑2015   Learning how to use "devctl" to read and write with disc and tape; a demonstration simple file system to show how these work in practice.
Class 21  Tue 31‑3‑2015   Critical sections, semaphores (and) mutexes, P(s), V(s), atomic operations, test and set instructions, race conditions, implementing semaphores, deadlock.
Class 22  Thur 2‑4‑2015   Implementation of the variants on semaphores (counting, queueing) still just using the basic Atomic Test And Set instruction. The dining philosophers.
vax instructions,
Class 23  Tue 7‑4‑2015   What we learn from the dining philosophers.
Interrupt processing: inch() from io.b. Timer first, now keyboard too.
Class 24  Thur 9‑4‑2015   Monitors little, big.
Java's synchroniZed.
Coroutines: Almost, There.
Class 25  Tue 14‑4‑2015   Threads, a basic pthreads (the standard unix threads implementation) example.
Introduction to the basics of networking.
Class 26  Thur 16‑4‑2015   Thinking of a distributed file system: FTP, RPC (remote procedure call), NFS (network file system), Agreed timestamping. The problems are with locking remote files while in use, persistent connections use resources, non-persistent ones waste time with reconnections. Stateless vs. stateful, client programs crashing, etc.
Class 27  Tue 21‑4‑2015   Once again: working with your page tables and controlling memory.
Dynamically linked libraries.
Some only slightly out of date guidance on multiprocessing. The life-cycle of a unix process.
Class 28  Thur 23‑4‑2015   Why emulators are slow. Other bits in a page table entry, paging and swapping, resident set size vs. virtual size, what fork and exec do, the COW bit for efficiency.