Lab 4: Multiprogramming
Computer Science 377
Due: Friday, April 30, 1:00 PM

In the assignment, we tell you to put output statements in your code at various places. To do this, use the DEBUG procedure call, passing '4' as the first argument, as in:

DEBUG ('4', "Allocating frame %d.\n", frame);

To see this output run nachos with the -d 4 flag. This should facilitate debugging on your part and will also facilitate testing and grading. These statements must be present to receive full credit for a portion of the assignment. Feel free to add additional statements that you feel help clarify how your code is working. (Error messages that must be reported to the nachos user, such as when a system call is given bad parameter values, should be output with normal printf statements so that they always appear.)

Before beginning this assignment, do the following:

1. In machine/machine.h, change

   #define NumPhysPages    32
   

   to

   #define NumPhysPages    48
   

2. In vm/Makefile, delete -DUSE_TLB from the line:

   DEFINES = -DUSER_PROGRAM -DFILESYS_NEEDED -DFILESYS_STUB -DVM -DUSE_TLB

3. Rebuild the makefile (gmake depend in the vm directory.

4. Recompile nachos (gmake nachos in the vm directory.

1. (20 pts.) Implement an object to keep track of free pages. It's an instance of BitMap (from bitmap.h). The bitmap must be updated whenever a process starts or stops. Ignore the use and dirty bits since we are not implementing demand paging. Change the addrspace constructor to initialize the page table by looking for free page frames; currently it assumes they are all free. Output a DEBUG statement on each page allocation and deallocation identifying the frame number.

2. (20 pts.) Implement a memory management scheme that does paging. You should load a process's entire address space into physical memory when the process is started. You do not need to implement demand paging. If there is not enough memory to meet a process's needs, you can simply display an error message and abort the process. Remember to free the memory when the process exits. Output a DEBUG message for each page loaded into memory identifying the virtual page number and the physical page frame.
   • Tip: Currently, Nachos zeros the entire main memory when an address space is created using a call to bzero. You need to be sure that you only zero the pages actually allocated to that process.

3. (20 pts.) Implement the Exec() system call. Exec is quite similar to StartProcess in userprog/progtest.cc. Output a DEBUG message at the beginning and end of Exec identifying it as an Exec call. In the end message, identify the id of the new process created. This is the value that Exec will return.
   • Tip: The Exec system call should not actually start the new process. It should create all the necessary data structures and then call Fork (like in producer/consumer and barber). Here is the procedure that you should send as the first parameter to Fork:

     //----------------------------------------------------------------------
     // ExecProcess
     // 	This is called by SyscallExec to actually run the new process.
     //	It is a forked kernel thread which begins by setting up it's
     //	address space and initializes things.  It then calls machine->Run
     //	which causes it to execute.
     //
     //----------------------------------------------------------------------
     
     
     void ExecProcess(int execFileName)
     {
       DEBUG('4', "Starting process %s\n", (char *) execFileName);
       currentThread->space->InitRegisters();
       currentThread->space->RestoreState();	// load page table register
       machine->Run();		        // jump to the user progam
       ASSERT(FALSE);			// machine->Run never returns;
       					// the address space exits
     					// by doing the syscall "exit"
     }
     

4. (20 pts.) Implement the Join() system call. Join results in a process waiting for another specific process to finish. Join puts itself to sleep to wait for the process whose id is passed in to complete. Nachos must be able to map from SpaceIds to threads, much as it maps from OpenFileIds to files. Output a DEBUG message at the beginning of Join identifying it as a Join. Also, identify the process id of the current thread and the id of the thread it wants to wait for. When a process waits for another process, indicate this with a DEBUG message before going to sleep. Before Join returns, output another DEBUG message indicating which process is continuing.

5. (10 pts.) Make whatever changes are necessary to your system call implementations. For example, if you used a global file table, you must now turn that into a per-process file table. (You do not need to implement the file pointer. You can let the underlying Unix implementation of the file system manage that for you.) Also, if you implemented Exit as a call Halt in the last lab, you need to change this. You should only halt Nachos if there are no more processes alive.

6. (5 pts.) Use semaphores to provide synchronized access to the SynchConsole class you implemented in the last lab so that multiple processes can read and write from/to the console. Essentially, you should prevent two threads from executing PutChar concurrently or GetChar concurrently.

7. (5 pts.) Implement a timer so that each user process gives up the CPU after its timeslice expires. In threads/system.cc, there is currently code to create a timer if the program is called with the -rs flag. You just need to change this so that the timer is always created. All other aspects of the timer are already implemented. (The length of the time slice is defined by TimerTicks defined in machine/stats.h.)

Most of your work will again be in the userprog directory. Here are the files you will need to read/understand to complete this assignment.

Testing MultiProgramming Using Exec and Join