Software Systems
Fall 2006

For today you should have

1) worked on your project

2) read Rosenblum and Ousterhout (questions below)

3) read the next section of LBoS and done the barbershop problem

4) prepared for a quiz

Coming up: exam #2 November 16


Today:

1) quiz

2) LFS

3) file system interface

4) Archy


For next time you should:

1) work on your project -- progress report due Monday November 13

2) read Chapter 23 of the Cow Book

3) read the handout from Raskin, "The Humane Interface"

   http://wb/ss/handouts/raskin00humane.pdf

   the Wikipedia page on Archy: http://en.wikipedia.org/wiki/Archy

   You may also want to read http://en.wikipedia.org/wiki/Jef_Raskin

4) optional: read the next section of LBoS and do the H2O problem



File system interface
---------------------

What is the primary abstraction created by the file system?

What details of the implementation are generally hidden?

What is the interface to the abstraction (for example, what is the
sequence of operations to read a byte from a file and write a new
byte)?


Most file systems provide interfaces at several layers:

1) user interface: what is the user's model of a file?
   What tools does the user have to interact with files?

   a) Graphical: file = document, click and drag.

   b) command line: file = sequence of bytes; ls, wc, awk, grep, etc.

   In most graphical systems, documents belong to applications.

   In UNIX, many applications can operate on the same file.

2) High-level API

   cat file1 > file2

   print open(filename).read()

3) Middle-level API

   fopen, fscanf, fprintf, fclose

4) Low-level API

   creat, open, read, write, close

5) Really low-level API

   getblk, bread, bwrite

6) Really, really low-level interface

   SCSI
   
7) The hardware interface


The ioloop.c that I gave you demonstrates level 4:

#define FILE_MODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)
 
int main (int argc, char *argv[])
{
  int i = 0;
  int iterations;
  double x;
  FILE *fp;
  int fd;
  int n;
  char buf[] = "a";
 
  if (argc == 2) {
    iterations = atoi (argv[1]);
  } else {
    printf ("Usage: loop [iterations]\n");
    exit (-1);
  }

  fd = creat ("temp", FILE_MODE);

  for (i=0; i<iterations; i++) {
    n = write (fd, buf, 1);
    if (n != 1) {
      perror ("error");
    }
    n = fsync (fd);
    if (n != 0) {
      perror ("error");
    }
  }
  close (fd);
}

Each time you drop down a level, the number of lines of
code to perform the same task gets multiplied by 5-10.

What do you get in return?

This is an example of a common OS feature, a multi-layer interface.

In general, the higher levels provide

1) more abstraction, more work handled for you

2) more concise code

3) shorter development time

4) fewer errors

In general, the lower levels provide

1) detailed control, power

2) performance.


Power and performance are the sirens that lead
software projects to their doom!

And in some cases you don't even get the performance,
because the abstraction hides an algorithm that's
smarter than you.

Choose the highest level interface that can possibly
solve your problem, and only drop down if there is
no alternative.



Archy
-----

To install Archy:

1) install pygame by running the following as root

yum install pygame

2) download my slightly fixed up version of Archy

wget http://wb/ss/code/archy-build115.tar.gz
tar -xzf archy-build115.tar.gz
cd archy-build115.tgz

Follow the instructions you (should) see in the document.

You might want to read

http://rchi.raskincenter.org/index.php?title=Using_Archy

first.


Homework 5 debrief
------------------

Level of detail in reports like this is hard to get right.

In this case there were small pieces of code that were critical
to explaining your experimental setup.  You should embed them in
the text.

Leave out things like #include and other pro-forma code.

If you have more than 2-3 numbers embedded in a paragraph, put
them in a table, especially is you expect readers to be able to
make comparions.

Consider:

"For the first version, the average over 10 runs was 2.3 seconds of
user time and 0.3 seconds of system time, so the average total was
2.6 seconds with standard deviation 0.3, minimum 2.1 and maximum 3.1.
For the second version, the average over 10 runs was 1.7 seconds of
user time and 1.1 seconds of system time, so the average total was
2.9 seconds with standard deviation 0.9, minimum 1.6 and maximum 3.0."

Quick, which version is better?

Reporting percents only makes sense if the number before the
percent sign is human comprehensible.  For very rare events, report
xxx events in 10^n attempts, which n is chosen so that xxx is between
1 and 100.

I continue to be amazed that my x86 lock works.

In some cases, the pthread implementation was faster than my x86
lock, which makes perfect sense because mine is a spin lock and the
pthread implementation blocks.

In some cases, my x86 implementation was faster, which makes perfect
sense, because mine is lean assembly language code, and the pthread
implementation has more overhead.

Fortunately, no matter what you saw, you had a perfect explanation
for it.