CSCI 3323 (Principles of Operating Systems), Fall 2015:
Homework X

Credit:

Up to 30 extra-credit points.

General Instructions

Answer as many (or few) of the following questions as you like. (Notice, however, that you can receive at most 30 extra-credit points.)

I am also open to the possibility of giving extra credit for other work -- other problems from the textbook, a report on something course-related, etc. If you have an idea for such a project, let's negotiate (by e-mail or in person).

For this assignment, please work individually, without discussing the problems with other students. If you want to discuss problems with someone, talk to me.

Problems

For these problems, please submit hard copy (in one of my mailboxes -- ASO or outside my door). (If that's a huge hassle, e-mail is okay, but I will print it to grade it.)

Problems from Chapter 9

Answer any or all of the following questions (from the textbook chapter on security).

1. (Up to 2 points.) Answer question 26 on p. 708 of the textbook. (Hint: What are the odds of being able to guess the password if you know its length? if you don't?)

2. (Up to 2 points.) Answer question 27 on p. 709 of the textbook.

3. (Up to 2 points.) Answer question 34 on p. 709 of the textbook.

4. (Up to 2 points.) Answer question 37 on p. 709 of the textbook.

5. (Up to 2 points.) Answer question 46 on p. 710 of the textbook.

Essay Questions

Write a page or more of prose about one or more of the following questions, writing for an audience of fellow students. Include a short informal bibliography listing the source(s) of your information.

1. (Up to 10 points) We talked briefly early in the semester about VM/370, an operating system that allows running multiple ``guest'' operating systems side by side. What are some other ways of accomplishing similar things? How do they work? (The discussion of virtualization in Chapter 8 of the textbook looks promising as a source of information.)

2. (Up to 10 points) Most of the memory-management schemes discussed in the textbook are based on the idea that each process has its own ``address space'', each of which uses the same range of virtual addresses ranging from 0 to some large number (often the maximum possible based on the number of bits in an address). However, some of the older mainframe operating systems instead defined a single address space shared by all processes, with each process having a different range of virtual addresses. There have been indications in the not-so-dim past that this idea might be considered again. Speculate on how it might be done, what advantages there might be, what disadvantages there might be, and so forth. (In particular it might revive the program-relocation problem.)

Programming Problems

Do one or more of the following optional programming problems. Submit source code and other files by e-mail, as for previous assignments. (I.e., submit your program source (and any other needed files) by sending mail to bmassing@cs.trinity.edu, with each file as an attachment. Please use a subject line that mentions the course number and the assignment (e.g., ``csci 3323 extra credit''). You can develop your programs on any system that provides the needed functionality, but I will test them on one of the department's Linux machines, so you should probably make sure they work in that environment before turning them in.

1. (Up to 10 extra-credit points). Write a program that simulates execution of one or more of the following page replacement algorithms: FIFO, Optimal, Second Chance, Clock, NRU (Not Recently Used), LRU (Least Recently Used), NFU (Not Frequently Used), Aging (with a 16-bit counter), Working Set, WSClock. In writing your code, feel free to consult any descriptions of the algorithms, but do not look for code to copy/modify.

   How much credit you get will depend on how many algorithms you simulate and how correctly. You can use any language of your choice, as long as I can run/test your program on the department machines using an interface more or less like the following. (I'd prefer that you use exactly this interface for input -- it makes my testing job easier -- but if you use something else, put comments at the top of your code telling me how to run your code with my test data.)

   • Command-line arguments:
     • Required:
       • name of input file (format below)
       • number of page frames
     • Optional:
       • ``-clockTickInterval N'' to specify interval for ``clock ticks``, for algorithms that need this -- the idea being to consider that a ``clock tick'' happens every N references)
       • ``-tau N'' to specify time interval for working set algorithms
   • Input file format:
     • number of pages
     • one or more lines of the form ``R n'' or ``W n'', where R/W indicates whether this is a read or write reference, and n is the page number being referenced

   Output should be the following information, for each page replacement algorithm implemented:

   • name of algorithm
   • total number of page references
   • number of page references that changed the page ('W')
   • number of page faults
   • number of times a page had to be written out

   Make the following assumptions:

   • Initially memory is empty.
   • All memory references are valid -- if the page is not in memory, it can be read in from disk. (You don't have to simulate that part, just count how often it happens.)

   Here are files containing some sample input and output:

   • Command-line parameters pagingsimulator.in 4 -clockTickInterval 10 -tau 20
   • Input file
   • Output

2. (Up to 10 extra-credit points). Add one or more features to the simple shell program you wrote (or should have written!) for Homework 1. How much credit you get will depend on the level of difficulty involved. A not-too-difficult choice involves adding a command history; the man page for readline and associated reading is a good starting point.