ANNOUNCEMENTS

The following are in reverse chronological order.

Thu Dec 31 13:18:43 EST 2009

Semester letter grades have been posted in the averages.txt file.

Fri Dec 11 16:11:58 EST 2009

Exam 5 question 5 has been adjusted in the online grades file. Those who participated please check the grades file.

Fri Dec 11 14:51:56 EST 2009

The final exam will be those parts of chapters 1--5 of the text book that we talked about in class. The format will be similar to Exams 1--5, including closed text book, closed other books, closed notes, closed Internet, closed laptop, closed cell phone, closed old exams, closed neighbor, etc. Remember that the numbers will change from class examples. For chapter 4 on file systems we added the i-node file allocation scheme, directory organization, block buffer cache, defragmentation, cylinder group, tracking free blocks, and logical block size to what was covered for Exam 5. Of chapter 5 we covered disk arm scheduling, FCFS, SSTN (also called SSTF), bi-directional elevator (also called SCAN).

Don't forget about the accreditation questions described below. They will form a separate part of the final exam and be worth 10--20 points (in total, not each) of the 100 points of the final exam. They are closed book, closed notes, closed Internet, closed laptop, closed cell phone, closed old exams, closed neighbor, etc.

Thu Dec 10 12:54:08 EST 2009

Extra points opportunity! Now that I have everybody's attention, here is the opportunity. Find a question on one of the five exams (not question 7 of exam 5, though) where you lost a lot of points because you flubbed it badly or the thick-skulled professor just did not understand your answer. At the time, you were so upset that you texted your friends or telephoned your parents (parents don't do text). Write out the correct answer or a better explained answer. Attach your correct answer to the exam page or a photocopy of it. Turn it in at the beginning of the final exam to earn some of the points back on that question of that exam. This will also help you study for the final exam. You may do this for a single old exam question (otherwise, I'd be swamped, ha ha).

Tue Dec 8 21:28:33 EST 2009

Administrative decision on question 7 of exam 5. Answer question 7 again thoroughly and completely on a separate piece of paper. Attach a photocopy or the original of the answer you gave on exam 5 (detaching the last page of the exam is fine). Turn both in on Thursday, December 10, 2009, at the beginning of class. Assuming a correct answer on your redo of question 7, your points off will be restored.

Fri Dec 4 11:29:39 EST 2009

Start reading Chapter 5 of the text book on input and output. Also, have a look at 030Syscalls.html and 090DeviceIO.html. While reading, take note of the following terms and concepts.

• block devices for storage, character devices for streams
• device controller: control registers, data buffer
• I/O ports and I/O port space
• memory-mapped I/O
• hybrid like x86: addresses 640K--1M reserved for device data buffers, I/O ports 0--64K
• programmed I/O: polling or busy-waiting
• interrupt-driven I/O: device interrupts when packet arrives, character typed, line or character printed, disk seek performed
• DMA (direct memory access): CPU writes command to device controller, device interrupts after information placed in RAM, used with disk drives
• DMA controller does the work if device has no built-in DMA capabilities
• ``divide and conquer'' leads to layered approach
• I/O software layers
  • user level: spooling, text formatting, library procedures make system calls, easier to program if I/O systems block user process until complete
  • device independent (file system manager): uniform naming, uniform interfacing (each device driver must support a common set of operations), protection, buffering, error handling, sharing, logical block size
  • device dependent (device drivers): starts an I/O operation then blocks waiting for the interrupt, accepts FS commands to read or write blocks, translates block numbers to surface-track-sector numbers or LBA sector numbers
  • interrupt handlers: copy data from device to RAM, unblock device driver
  • device controller (hardware)
• disk arm scheduling: FCFS, SSN, bi-directional elevator, uni-directional elevator

Thu Dec 3 07:26:51 EST 2009

Information on the accelerated BS and MS in CS is available at http://www.rowan.edu/colleges/las/departments/computerscience/acad/ComputerScienceRowanUniversity1.htm and http://www.courierpostonline.com/article/20091217/GETPUBLISHED/912170386/1006/news01.

Wed Dec 2 16:19:50 EST 2009

We were talking in class the other day about SSDs (solid state drives). Here are some articles about them, http://www.linux-mag.com/id/7590 and http://www.linux-mag.com/id/7599.

Wed Dec 2 14:38:20 EST 2009

I am required to include on the OS final exam some questions related to the accreditation of the Rowan Computer Science Department by the CSAB/ABET/ACM/IEEE. The questions will be on the following. Prepare your answers in advance and bring them in your head to the final exam. These questions will be in a separate document and will be worth a number of points indicated on the document for each question.

• two views/roles/functions of an OS kernel
• how the OS serves as a bridge between the hardware and software components of a computing system
• why there is a need to share hardware and software resources in a computing system
• why there is a need to manage the sharing of hardware and software resources and allocate them in a secure, fair, and efficient manner
• what system calls are, how they are implemented, and how they provide a more secure and user-friendly interface to the hardware

Tue Dec 1 09:09:50 EST 2009

Online student evaluation for this course opens Tuesday, December 1, 2009, and ends Saturday, December 19, 2009. Instructions for students to access the evaluation:

1. Go to http://cp.rowan.edu/cp/.
2. Click "Student Self-Service" icon.
3. Click "Access Banner Services - Secure Area - login Required"
4. Enter User ID and PIN.
5. Click "Personal Information".
6. Click "Answer a Survey".
7. Click on one of the student evaluations for your classes.
8. Complete the student evaluation.
9. Click "Survey Complete" to submit your completed student evaluation.
10. Repeat for other Fall 2009 classes.

Mon Nov 30 09:24:03 EST 2009

Exam 5 is on Thursday, December 3, 2009, and covers the following: Version 4 of paged virtual memory, TLB, locality, page size choice, internal fragmentation, and Chapter 4 of the text book on file systems up to the i-node file storage/allocation scheme (how far we got in class on Tuesday). See the list below. See also 100FileSystems.html.

Mon Nov 30 09:07:45 EST 2009

The ``last assignment'' is due in class on Thursday, December 10, 2009, in hardcopy form stapled twice as two separate documents.

Fri Nov 20 12:14:50 EST 2009

Start reading Chapter 4 of the text book on file systems. Also, have a look at 100FileSystems.html. While reading, take note of the following terms and concepts.

• FS sees disks as numbered sequence of 512 byte sectors, read sector k, write sector k
• files are an abstraction of disk storage
• FS tracks file contents by user-assigned name, protects files from unauthorized access, provides system calls (file operations) for users, tracks free disk sectors
• files are unstructured sequence of bytes
• some FSs support a file of a sequence of fixed-length records
• some FSs support a file of a tree of variable-length records
• some file types are regular, directory or folder, character special (stream device), block special (storage device)
• a particular kind of regular file is an executable file produced by a compiler, from which process address space is created when the user requests the OS to execute the program that was compiled
• files can be accessed sequentially or randomly, by byte or by record
• file attributes: access control list or protection flags, owner, size, last access time, last modification time, locked, record size, read only
• file operations: create, open, read, write, close, delete, append, rename, seek, get attribute(s), set attribute(s)
• root directory
• current working directory
• change directory
• absolute path name
• relative path name
• dot and dot dot entries in a directory
• directory operations: create, opendir, readdir, link, unlink, closedir, delete, rename, get attribute(s), set attribute(s)
• hard link, soft or symbolic link
• disk layout: sector 0 is master boot record, one or more partitions, active partition
• partition (file system) layout: sector 1 is boot block, superblock, free block list, i-nodes, root directory, disk blocks for files and directories
• file allocation methods
  • contiguous allocation:
    • simple,
    • file is identified by its name and first block number plus attributes (directory entry),
    • good read performance,
    • good random I/O,
    • good for read-only file systems,
    • read-write file system fragments because of hole list,
    • growing a file might mean moving it,
    • compaction might take hours
  • linked list allocation using links in the disk blocks:
    • file system logical block size not a power of two because of link,
    • no fragmentation,
    • file is identified by its name and first block number plus attributes (directory entry),
    • poor random I/O
  • linked list allocation using links in a table in RAM (FAT):
    • file system logical block size is a power of two,
    • no fragmentation,
    • file is identified by its name and first block number plus attributes (directory entry),
    • random I/O not as bad,
    • entire FAT must be RAM resident so does not scale well
  • i-node:
    • complicated,
    • good compromise of above schemes,
    • i-node contains file attributes instead of directory entry,
    • directory entry is file name and its i-node number,
    • i-node contains the file's first k block numbers
      • plus indirect block number if needed (block full of file's disk block numbers),
      • plus double indirect block number if needed (block full of block numbers full of file's disk block numbers),
      • plus triple indirect block number if needed (block full of block numbers full of block numbers full of file's disk block numbers)
• directory organizations: map file name to file's disk block numbers containing file's data, might contain file attributes (FAT) or not (i-node scheme), file names might be fixed in length (table), or file names might be variable in length (heap)
• sharing files via multiple links
• log-structured file systems
• journaling file systems work like database atomic transactions in that a log of operations to be performed is created before doing the operations so that it can be replayed in case of a crash
• virtual file systems: create a common interface to different file system types like NTFS, FAT, ext2, ext3, ISO 9660, etc., making it easier to support new file system types
• logical block size is 2ⁿ 512-byte disk sectors for some n: larger n means fewer seeks but more internal fragmentation, in practice n is usually 1 (1024 byte blocks) to 4 (8192 byte blocks)
• tracking free blocks; bit map of 0/1 for free/nonfree blocks, linked list of free blocks, linked list of blocks where each block is full of free block numbers
• disk quotas, backups, consistency checking like fsck
• block buffer cache: keep recently used disk blocks in RAM for future reuse, linked list kept in exact LRU order, write-through option for directories and i-nodes
• block read ahead
• keeping file blocks close (cylinder group)
• defrag really means descatter
• MS-DOS FAT 16, FAT 32, NTFS (Section 11.8)
• UNIX version 7
• Linux ext2, ext3, ext4 (Section 10.6.3)

Thu Nov 12 11:34:59 EST 2009

Exam 4 covers through Version 3 (three) of 082PagingFactSheet.html.

Mon Nov 9 16:31:09 EST 2009

Exam 4 is on Thursday, November 12, 2009. It will cover the material in 080MemoryManagement.html and 082PagingFactSheet.html that we have talked about in class since Exam 3 and by the end of class on Tuesday, November 10, 2009. Specifically, in 080MemoryManagement.html, starting at ``but we still have three restrictions or limitations,'' and in 082PagingFactSheet.html, paging versions 1, 2, 3, and 4. Only stuff from the text book that we have talked about in class will be covered.

Thu Oct 22 15:22:45 EDT 2009

On Tuesday we will pick up where we left off Tuesday.

Wed Oct 21 14:24:38 EDT 2009

Exam 3 is on Thursday, October 22, 2009, and covers some of Section 2.4; it also covers Sections 3.1 and 3.2; it additionally covers some of 080MemoryManagement.html.

• interactive: ............, priority, aging, internal priority of proportion of last time slice used before losing CPU, multilevel queues with variable time slices, guaranteed proportion of the CPU perhaps based on priority, lottery perhaps with number of tickets based on priority
• fair share: modifying guaranteed proportion to group processes by owner
• a process might have input to the policy such as changing its priority
• Murphy's Law and RAM: never enough RAM
• disk and RAM used to implement an abstraction managed by OS for programmers
• managing includes mapping, allocating and deallocating
• compiler calculates or guesses sizes of code, data, heap, stack; compiler assumes program addresses start at zero run through N-1
• start with no abstraction at all: run one process at a time in RAM to completion; linker/loader must know where OS ends in RAM and free RAM starts so linker/loader can rewrite correct RAM addresses in instruction address fields as it loads program into RAM
• next: use time multiplexing of entire RAM with a swap area on disk to implement sharing (swap entire process out to disk, swap a different entire process in from disk); kind of round robbin of RAM (instead of round robbin on CPU)
• to load more than one program in RAM at a time, linker/loader uses static relocation to rewrite program addresses as a program is loaded into RAM
• better to use dynamic relocation implemented with base and limit registers to enforce memory protection
• address space abstraction: each process has range of bytes 0 to N-1 mapped by OS using base and limit to a block of N contiguous bytes in RAM
• what if not all processes user(s) want to run can fit in RAM? use swapping to swap some in and swap some out so they all get RAM and CPU some of the time
• swapping entire processes in and out has memory fragmentation problem; can be fixed with a time-consuming compaction operation; also problem of a growing heap and/or stack in a process that might collide
• 5 seconds to compact a 1 GB memory; 10 seconds to swap out to disk a 1 GB process, 10 seconds to swap another in
• keep track of free blocks of RAM with a bit map or a linked list
• merge or coalesce adjacent holes when a process terminates or is (entirely) swapped out
• first fit, next fit, best fit, worst fit; do a numerical example using some random numbers
• what if RAM is not big enough for one of the processes? what if RAM is not big enough to hold all the programs you want to run even though each could fit individually? what to do if heap and stack collide during execution?
• solve the heap-stack collision problem, code-data-heap grows from 0, stack grows from 2³¹, each with own base/limit register pair in PCB and CPU has two base/limit register pairs, OS finds a hole for each to run program
• CPU hardware address translation uses left-most address bit to distinguish code-data-heap from stack addresses and which base/limit register pair to use

Wed Oct 14 13:23:40 EDT 2009

I just now noticed that there are no classes on Tuesday, November 3, 2009, Election Day. Gasp! Because of that I have moved Exams 4 and 5 back a week. See the revised schedule at the end of the syllabus.

Wed Oct 14 09:53:20 EDT 2009

I will be on campus from about noon to about 5pm today.

Wed Oct 14 09:50:35 EDT 2009

Read sections 3.1 and 3.2 of the text book and I will verbally quiz you on them in class on Thursday, October 15, 2009.

Mon Oct 12 16:09:17 EDT 2009

Start reading Chapter 3 of the text book on memory management and virtual memory; see also the electronic handout, 080MemoryManagement.html. While reading these, take note of the following terms and concepts.

• Murphy's Law and RAM: never enough RAM
• disk and RAM used to implement an abstraction managed by OS for programmers
• managing includes mapping, allocating and deallocating
• compiler calculates or guesses sizes of code, data, heap, stack; compiler assumes program addresses start at zero run through N-1
• start with no abstraction at all: run one process at a time in RAM to completion; linker/loader must know where OS ends in RAM and free RAM starts so linker/loader can rewrite correct RAM addresses in instruction address fields as it loads program into RAM
• next: use time multiplexing of entire RAM with a swap area on disk to implement sharing (swap entire process out to disk, swap a different entire process in from disk); kind of round robbin of RAM (instead of round robbin on CPU)
• to load more than one program in RAM at a time, linker/loader uses static relocation to rewrite program addresses as a program is loaded into RAM
• better to use dynamic relocation implemented with base and limit registers to enforce memory protection
• address space abstraction: each process has range of bytes 0 to N-1 mapped by OS using base and limit to a block of N contiguous bytes in RAM
• what if not all processes user(s) want to run can fit in RAM? use swapping to swap some in and swap some out so they all get RAM and CPU some of the time
• swapping entire processes in and out has memory fragmentation problem; can be fixed with a time-consuming compaction operation; also problem of a growing heap and/or stack in a process that might collide
• 5 seconds to compact a 1 GB memory; 10 seconds to swap out to disk a 1 GB process, 10 seconds to swap another in
• keep track of free blocks of RAM with a bit map or a linked list
• merge or coalesce adjacent holes when a process terminates or is (entirely) swapped out
• first fit, next fit, best fit, worst fit; do a numerical example using some random numbers
• what if RAM is not big enough for one of the processes? what if RAM is not big enough to hold all the programs you want to run even though each could fit individually? what to do if heap and stack collide during execution?
• virtual memory abstraction combines RAM and disk into one large virtual address space for each process, of size 2ⁿ bytes where n is number of bits in an address (32 or 64 these days)
• 080MemoryManagement.html
  • solve the heap-stack collision problem, code-data-heap grows from 0, stack grows from 2³¹, each with own base/limit register pair in PCB and CPU has two base/limit register pairs, OS finds a hole for each to run program
  • CPU hardware address translation uses left-most address bit to distinguish code-data-heap from stack addresses and which base/limit register pair to use
  • virtual memory implemented with paging eliminates limitations: whole program must be loaded, two blocks of RAM for C-D-H and S, many small unusable holes in the hole list
  • 082PagingFactSheet.html
    • page table, page table entries
    • versions 1, 2, 3, 4
    • internal fragmentation, spatial and temporal locality, translation lookaside buffer, choice of page size
• pages of address space, page frames of RAM, page size of 2^k, generalization of base/limit register idea
• paging, virtual address, MMU does virtual address translation
• page table entry has page frame number, present/absent bit, modified bit, referenced bit, protection bits, caching enabled/disabled bit
• page table, page fault, choose a page to evict
• speed up address translation with lookaside buffer (TLB)
• multilevel page tables, inverted page tables for very large virtual address spaces
• page replacement algorithms based on not heavily or recently used
• algorithms: optimal, not recently used, FIFO, second chance, clock, LRU, working set, WS clock
• demand paging, locality of reference, thrashing, prepaging
• local versus global allocation policies
• page fault frequency, load control, choice of page size
• segmentation

Tue Oct 6 16:42:15 EDT 2009

Exam 2 covers threads and some of CPU scheduling (nothing from Exam 1). Scroll down to see what part of CPU scheduling Exam 2 covers.

Tue Oct 6 12:21:15 EDT 2009

I will be in my office Wednesday, October 7, 2009, from around 12:15pm until 5:30pm or so for questions and help.

Tue Sep 29 12:19:26 EDT 2009

Exam 1 grades are in the grades file.

Mon Sep 28 19:16:38 EDT 2009

While reading Section 2.4 of the text book, take note of the following terms and concepts.

• CPU scheduler chooses process to run next using an algorithm
• compute-bound process, I/O-bound process
• heuristic: when an I/O-bound process becomes ready, put it at or near the head of the ready queue (why?)
• choose when: new process, process exits, process blocks, I/O interrupt, clock interrupt
• nonpreemptive scheduling (voluntary release only), preemptive scheduling (involuntary release possible)
• batch: nonpreemptive or preemptive with large time slice
• interactive: preemptive with not-so-large time slice
• goals: fair and balanced (mix of CPU bound and I/O bound)
• batch goals: high throughput versus low turnaround time, high CPU utilization
• is a supermarket checker who cherry picks customers with small number of items to check out really more productive?
• interactive goals: fast response time, happy users
• batch: FCFS (infinite time slice), SJF (optimal for average turnaround time), SRTN
• interactive: round robin (how to select time slice size), ...........
• policy versus mechanism, above are some policies, mechanism is PCBs, ready queue, clock interrupts
• pick six random numbers between 1 and 500 and calculate average completion times for FCFS, SJN, and RR
• kernel-level thread scheduling: round robin with a preference when time slice is up to switch to another thread of the same process (no need to change base/limit registers or flush CPU cache)
• EXAM 2 DOWN TO HERE (below on next exam)
• interactive: ............, priority, aging, internal priority of proportion of last time slice used before losing CPU, multilevel queues with variable time slices, guaranteed proportion of the CPU perhaps based on priority, lottery perhaps with number of tickets based on priority
• fair share: modifying guaranteed proportion to group processes by owner
• a process might have input to the policy such as changing its priority

Fri Sep 25 09:28:28 EDT 2009

Upcoming for Tuesday, Thursday, and Tuesday, September 29, October 1, and October 6, 2009, is finishing Sections 2.1, 2.2, and 2.4 in the text book. After reading the book, your homework is to look at the following from the electronic handouts: 040Multiprogramming.html, 050CPUscheduling.html, 060Threads.html. You will have in-class verbal quizzes on both the text book and the electronic handouts (calling random students). Projects will be coming later after we have done some more basic OS stuff.

Some of you were upset seeing these links two days before the exam. I hear you. My strategy is for you to read the text book then use the electronic handouts for clarification and additional explanation. We will go over both in class. We will come back to 030Syscalls.html later.

Wed Sep 23 05:58:25 EDT 2009

Threads will not be on exam 1.

Tue Sep 22 10:54:32 EDT 2009

We are going to finish up processes and start threads today. Threads might or might not be on Exam 1, depending on how much thread stuff we do today.

Mon Sep 21 16:16:25 EDT 2009

Exam 1 on Thursday, September 24, 2009, will cover Chapter 1, Section 2.1 (processes), and Section 2.2 (threads) of the text book, and all class discussions on those areas. See also the following from the electronic handouts: 010WhatIsAnOS.html, 020Hardware.html, 030Syscalls.html, 040Multiprogramming.html, 060Threads.html.

Wed Sep 16 09:32:22 EDT 2009

Office visits will resume Thursday, September 17, 2009, during office hours, and Friday afternoon, September 18, 2009.

Sun Sep 13 06:58:51 EDT 2009

I will be in my office Monday, September 14, 2009, for office visits from about 10:30am on (no classes to teach, no meetings yet).

Fri Sep 11 14:54:17 EDT 2009

For next week, read Sections 2.1, 2.2, and 2.4 of Chapter 2 of the text book. Specifically, for Tuesday, September 15, 2009, read Section 2.1 on processes; for Thursday, September 17, 2009, read Section 2.2 on threads; for Tuesday, September 22, 2009, read Section 2.4 on scheduling. Sections 2.3 and 2.5 will be covered next semester in Concurrent Programming for those who choose to suffer through, I mean, take that course. Let me tell you, that material is hard. If interested, have a look at http://elvis.rowan.edu/~hartley/JavaConcProg/index.html. So far at Rowan, the Concurrent Programming has never had enough students to run.

While reading Sections 2.1 and 2.2 of the text book, take note of the following terms and concepts.

• definition of a process, multiple virtual CPUs, multiprogramming, pseudoparallelism
• CPU utilization as a function of degree n of multiprogramming due to overlap of CPU use and I/O use; classroom activity of n (process) people getting an index card from one person (I/O device) and having another person (CPU) count the letters on the card
• events that cause process creation, events that lead to process termination
• states a process can be in, transitions between states
• process table, process control block contents
• PCB contents for process management, memory management, file management
• interrupt vector, what the OS does when an interrupt occurs
• PCB has a field ``clock ticks used'' since last being given the CPU
• ready queue
• example of a clock interrupt
• definition of a thread
• why program with threads: simplify programming model, more efficient to create threads than processes, take advantage of multiple CPUs, overlap CPU use and I/O use in one process
• word processor example, keyboard read thread, format pages thread, autosave thread
• Web server example, dispatcher thread getting requests and worker threads serving those requests from disk (add a RAM cache, too)
• without threads only way to speed up a single-threaded Web server with RAM cache is with complicated-to-use nonblocking version of read system call
• we will look at implementing threads at the kernel level, not at the user level
• to implement threads, the PCB for each process must be modified to contain per-process information and per-thread information
• each thread has its own stack, copy of PC, copy of GPRs, state, clock ticks used
• this is as far as we will go with threads

Thu Sep 10 07:17:01 EDT 2009

I will come to campus Monday, September 14, 2009, for office visits if at least one person makes an appointment by late Sunday evening. If no one does, then I will work at home on Monday.

Mon Sep 7 14:22:26 EDT 2009

While reading Chapter 1 of the text book, take note of the following terms and concepts.

• OS provides user-friendly interface to the hardware in the form of a clean abstract set of resources (processes, address spaces, files)
• OS manages resources (hardware and software) and provides allocation and protection of resources
• user and kernel mode of the CPU
• space and time multiplexing
• program counter, stack pointer, PSW registers in the CPU
• instructions involving I/O and memory protection are privileged as is setting the user/kernel mode bit in the PSW to kernel mode
• system call TRAP instruction switches CPU to kernel mode and calls a procedure in the OS code
• other traps to the OS are divide by zero, floating point underflow and overflow, illegal instruction, memory out of bounds, etc.
• L1 and L2 cache memory, random access memory RAM, cache principle, memory hierarchy
• disk drive, cylinder, track, sector, disk arm, read/write head
• disk controller, device driver, controller registers, I/O port space, IN and OUT instructions, busy waiting, interrupt, interrupt vector, DMA (direct memory access) chip
• process is a program in some state of execution, its address space is set of addresses it can reference, address space is decoupled from RAM
• process table, PID
• UID, GID, superuser
• file, folder or directory, file system hierarchy, path name, root directory, working directory, mounted file system, pipe, file protection bits rwx, file descriptor, i-node
• what happens during a system call like count = read(fd, buffer, nbytes)
• system calls for process management: fork, waitpid, execve, exit, chdir, kill
• system calls for file and directory management: open, close, read, write, lseek, stat, mkdir, rmdir, link, unlink, chmod
• system calls for file system management: mount, umount
• other system calls: time
• these must be known ``by heart,'' which means 10^?: milli, micro, nano, pico; kilo, mega, giga, tera

Mon Sep 7 14:01:36 EDT 2009

In class on Tuesday, September 8, 2009, we will continue our discussion and review of computer hardware and software needed to study operating systems:

• base and limit registers;
• C program process model including text, data, heap, and stack;
• user and kernel mode of CPU and privileged instructions;
• user/kernel mode bit and interrupts enabled/disabled bit in PSW;
• hardware interrupts; TRAP instruction and software interrupts;
• clock chip and clock ticks used by OS to keep track of time;
• command, status, and data registers in a device controller such as disk and NIC;
• why and how clock ticks, user/kernel mode of CPU, and base/limit registers are critical to an OS of a multiuser, multiprocess system.

On Thursday, September 10, 2009, I will ``quiz'' you verbally in class on Chapter 1 of the text book to check for being prepared. Notes can be open but books are closed! I want no page flipping and no reading of answers out of the book.

Sun Sep 6 12:27:01 EDT 2009

Some interesting articles offering advice to college students, particularly first year ones, are in http://www.nytimes.com/2009/09/06/opinion/06collegeadvice.html. My favorite is, ``Don't Alienate Your Professor.''

Sat Sep 5 19:39:49 EDT 2009

Another swine-flu-on-campus article, http://www.nytimes.com/2009/09/05/us/05flu.html. This one's kinda funny. Keep washing those hands, anyway!

Sat Sep 5 08:36:35 EDT 2009

I have a meeting 10:50am--12:05pm on Wednesday, September 9, 2009. I'll be in my office after that for the rest of the day.

Wed Sep 2 13:17:17 EDT 2009

In class on Thursday, September 3, 2009, we will review material from the prerequisites, primarily computer hardware. Actually, you will review it for me. I will call on students at random to provide the details of computer hardware that we need to study operating systems. This will include you drawing pictures on the whiteboards.

Wed Sep 2 12:57:06 EDT 2009

I made a mistake in class yesterday when I said, let's make the ``don't know'' relation reflexive. Maybe I should retake Discrete Structures. What mistake did I make and what should I have said?

Sat Aug 29 09:49:35 EDT 2009

Let's keep Rowan out of the swine flu news, http://www.nytimes.com/aponline/2009/08/28/health/AP-US-Colleges-Swine-Flu.html.

Sun Aug 23 16:39:48 EDT 2009

By our class meeting on Thursday, September 10, 2009, all registered students must have completed the following. Unprepared students will be charged a half day of attendance as described in the syllabus.

• Read Chapter 1, What is an Operating System, in the text book, Modern Operating Systems, 3^rd ed.

Fri Aug 21 14:21:54 EDT 2009

Welcome to Operating Systems!

home page: http://elvis.rowan.edu/~hartley/index.html
e-mail: hartley@elvis.rowan.edu