Spring2011.CSCI340Homework5 History

Hide minor edits - Show changes to output

Changed lines 49-52 from:
Your program should output the total number of page faults generated, the miss rate for the current page-replacement algorithm, and the number of modified pages evicted.

For example
:
to:
Your program should output a single line for each page fault, for example, as follows:
Changed lines 52-54 from:
Total page faults = 85
Miss rate = 34%
Modified pages evicted = 40
to:
Page fault: Process 3, page 4 loaded in frame 10.
Added lines 55-64:
Your program should also output the total number of page faults generated, the miss rate for the current page-replacement algorithm, and the number of modified pages evicted.

For example:

(:source lang=c tabwidth=3 -trim:)
Total page faults = 85
Miss rate = 34%
Modified pages evicted = 40
(:sourcend:)
Changed lines 99-102 from:
# To simulate memory references, for every time unit that a process runs, it will perform a single page reference. The page that's referenced will be decided using @@rand()@@. For example, if a process has 5 pages then every time unit '''you'll generate a random number between 1 and 50 (50 = 5 pages * 10 locations per page) and make a memory reference to that page location.''' [-('''Hint:''' Recall that C arrays (i.e., your main memory) are zero-indexed - you will need to account for that in your memory references.)-]

# Another call to @@rand()@@ will tell you if the program will make a modification to this page location (i.e., whether to set the page's modification bit). There is a 50% chance for modifications to happen. '''If a modification happens, then simply decrement this memory location by 1.'''
to:
# To simulate memory references, for every time unit that a process runs, it will perform a single page reference. The page that's referenced will be decided using @@rand()@@. For example, if a process has 5 pages then every time unit '''you'll generate a random number between 1 and 50 (50 = 5 pages * 10 locations per page) and make a reference to that memory location.''' [-('''Hint:''' Recall that C arrays (i.e., your main memory) are zero-indexed - you will need to account for that in your memory references.)-]

# Another call to @@rand()@@ will tell you if the program will make a modification to this memory location (i.e., whether to set the page's modification bit). There is a 50% chance for modifications to happen. '''If a modification happens, then simply decrement this memory location by 1.'''
Changed lines 103-104 from:
# If physical memory is full, a page replacement algorithm will be used to select a page from memory, move it to the backing store and load in the requested page. '''For the bonus part, simply print the process ID, the page frame number, and the modified page (all 10 ints) to the standard output'''. [-(If this were a real OS, you would be storing the modified page in secondary storage.)-]. Then, simply overwrite the page information in main memory.
to:
# If physical memory is full, a page replacement algorithm will be used to select a page from memory, move it to the backing store (if modified-bit is set), and load in the requested page. '''For the bonus part, when a page gets evicted, print the process ID, and the page frame number (of the evicted page) to the standard output. If the page was modified, also print out the modified page information (all 10 ints)'''. [-(If this were a real OS, you would be storing the modified page in secondary storage.)-]. Then, simply overwrite the page information in main memory.
Changed lines 99-100 from:
# To simulate memory references, for every time unit that a process runs, it will perform a single page reference. The page that's referenced will be decided using @@rand()@@. For example, if a process has 5 pages then every time unit '''you'll generate a random number between 1 and 50 (50 = 5 pages * 10 locations per page) and make a memory reference to that page location.'''
to:
# To simulate memory references, for every time unit that a process runs, it will perform a single page reference. The page that's referenced will be decided using @@rand()@@. For example, if a process has 5 pages then every time unit '''you'll generate a random number between 1 and 50 (50 = 5 pages * 10 locations per page) and make a memory reference to that page location.''' [-('''Hint:''' Recall that C arrays (i.e., your main memory) are zero-indexed - you will need to account for that in your memory references.)-]
Added lines 85-104:
!!Bonus

The above simulation is simplistic. It stops short of creating and allocating main memory to the incoming processes. As is, each page is assigned to a page frame (in the page table), but that page frame (which is an index to the main memory area used to store the page) is unused.

So to make things more realistic, in addition to the above, have your program allocate physical memory (an array of ints) using @@malloc()@@, at run time. The size of the array will be determined by the number of page frames stated in the (first line of) the input file. (Remember to deallocate that memory at the end of the simulation.)

For now, let's make each page be 10 ints (memory locations) long. ('''Hint:''' Define this as a constant at the top of your program.) The array is contiguous, i.e., page frame boundaries are imaginary (calculated using the page frame number and the length of each page).

!!!Modifications

[-(The information below is repeated/modified from above - see '''bold for modifications'''.)-]

# The first time a page is referenced it will need to be “page faulted” in. That is, a free frame in physical memory will need to be allocated and an entry in the page table will need to be created to point to it. '''For this simulation (instead of actually loading the process's data/code into the page frame, let's just store the process ID in *every* memory location of this page.'''

# To simulate memory references, for every time unit that a process runs, it will perform a single page reference. The page that's referenced will be decided using @@rand()@@. For example, if a process has 5 pages then every time unit '''you'll generate a random number between 1 and 50 (50 = 5 pages * 10 locations per page) and make a memory reference to that page location.'''

# Another call to @@rand()@@ will tell you if the program will make a modification to this page location (i.e., whether to set the page's modification bit). There is a 50% chance for modifications to happen. '''If a modification happens, then simply decrement this memory location by 1.'''

# If physical memory is full, a page replacement algorithm will be used to select a page from memory, move it to the backing store and load in the requested page. '''For the bonus part, simply print the process ID, the page frame number, and the modified page (all 10 ints) to the standard output'''. [-(If this were a real OS, you would be storing the modified page in secondary storage.)-]. Then, simply overwrite the page information in main memory.
Changed line 2 from:
'''Due Date''': Monday, May. 2, 2011\\
to:
'''Due Date''': Monday, May 2, 2011\\
Added lines 69-70:
'''Note:''' You may assume that the maximum possible number of processes is 100 (ID ranges from 0 to 99), and that the maximum possible number of page frames is 100.
Added lines 79-80:
'''Note:''' If the NRU page replacement algorithm cannot find a page to evict that is not referenced, then it should mark all pages as not referenced (aging) and try again. (''Hint:'' a recursive call would be fine.)
Changed lines 49-50 from:
Your program should output the total number of page faults generated, the miss rate for the current page-replacement algorithm (i.e., @@miss rate = page faults / total number of references@@), and the number of modified pages evicted.
to:
Your program should output the total number of page faults generated, the miss rate for the current page-replacement algorithm, and the number of modified pages evicted.
Added lines 59-62:
where ''miss rate'' is calculated as follows:

@@miss rate = page faults / total number of references@@
Changed lines 128-129 from:
% submit csci340 hmwk5 virtualMemorySimulation.c
to:
@@% submit csci340 hmwk5 virtualMemorySimulation.c@@
Changed lines 7-8 from:
[--'''NOTE:''' This homework is an extension of [[Spring2011.CSCI340Homework3 | homework 3]]. The extension involves adding memory management and page replacement algorithms. It also changes the format of the input data.--]
to:
[-'''NOTE:''' This homework is an extension of [[Spring2011.CSCI340Homework3 | homework 3]]. The extension involves adding memory management and page replacement algorithms. It also changes the format of the input data.-]
Changed lines 7-8 from:
[--'''NOTE:''' This homework is an extension of [[Spring2011.CSCI340Homework3 | homework 3]]. Verbiage from homework 3 is included here to make this assignment self-contained. The extension involves adding memory management and page replacement algorithms. It also changes the format of the input data.--]
to:
[--'''NOTE:''' This homework is an extension of [[Spring2011.CSCI340Homework3 | homework 3]]. The extension involves adding memory management and page replacement algorithms. It also changes the format of the input data.--]
Changed line 15 from:
* To gain experience with virtual memory and memory management.
to:
* To gain experience with virtual memory management.
Changed lines 17-18 from:
to:
* To gain more experience with linked lists and process simulation.
Changed lines 21-25 from:
Create a memory management simulation in C that implements a '''xxxx''', '''xxxx''', and '''xxxx''' page replacement algorithms.

Read in process information from an ASCII file. The name of the file will be provided as input to your
program, using C command-line arguments
.
to:
Create a virtual memory management simulation in C that implements a '''Random-Replacement (Random)''', '''First-In-First-Out (FIFO)''', and '''Not-Recently-Used (NRU)''' page replacement algorithms.

Using the code from [[Spring2011.CSCI340Homework3 | homework 3]], implement a First-Come-First-Serve process scheduling algorithm, which will read in processes from an input file. Each process will now have a memory requirement (i.e., number of pages it needs), which will be used in the creation and management of a page and frame table.

The Random, FIFO, and NRU page replacement algorithms will be implemented to handle loading pages into memory (and storing pages, if modified, back to the backing store). Since, program execution is simulated, the loading (and saving of modified pages) will be also simulated (i.e., not actually performed).

This simulation will output the number of page faults, the miss rate, and the number of modified pages evicted.

!!Input

The first line of the input file will contain 3 integer values. The first value is the seed to the random number generator @@srand()@@ (so results can be reproduced). The second value specifies the page replacement algorithm to use (Random = @@'r'@@, FIFO = @@'f'@@, NRU = @@'n'@@). The third value is the maximum number of frames that physical memory can store. You may assume that the first and second values are separated by a single space character.

On each additional line, the input file will contain 3 integers describing a single process to be run. The first integer is the process ID, the second integer is the total execution time for the process, and the third integer is the required memory for the process.

You should ignore anything past the third integer on each line.

The file may contain an arbitrary number of lines (processes).

Example file contents:
Changed lines 42-47 from:
int main(int argc, char *argv[])
(
/* argc equals the number of arguments received
argv is an array containing all command line arguments
argv[0] is set to the name of the program */
}
to:
12345 r 20 # seed for random number generator, the scheduler to use and the number of frames
0 4 3
# first process ID is 0, it will execute in 4 seconds, and requires 3 pages
1 2 5 # ... 2 78
Changed lines 47-67 from:
For example, see [1].

!!!Input

The first line
of the input file will contain 1 integer, 1 character, and 1 integer values:
* The first value will be used as a seed to
the random number generator @@srand()@@ (so results can be reproduced),
* the second value will define which scheduling algorithm should be used (FCFS = @@'f'@@, Priority = @@'p'@@, RR = @@'r'@@), and
* the third will be the quantum (time-slice) value to use for the preemptive algorithms.

You may assume that the first and second values are separated by a single space character.

On each additional line, the input file will contain 4 integers describing a single process to be run:
* The first integer is the process ID,
* the second integer is the arrival time of the process,
* the third integer is the required execution time of the process (remember, we are simulating execution), and
* the forth integer is the probability the process will block for IO.

You should ignore anything past the forth integer on each line. The file may contain an arbitrary number of processes.

Example file contents:
to:
!!Output

Your program should output the total number
of page faults generated, the miss rate for the current page-replacement algorithm (i.e., @@miss rate = page faults / total number of references@@), and the number of modified pages evicted.

For example:
Changed lines 54-57 from:
12345 r 5 # seed the random number generator with 12345, and run the RR scheduler with a 5-sec quantum
0 1 4 30 # process ID is 0, arrives at sec 1, will execute in 4 secs, has 30% chance to block for IO
1 3 2 5 # ...
2 6 7 80
to:
Total page faults = 85
Miss rate = 34%
Modified pages evicted = 40
Changed lines 59-161 from:
You may only assume that processes are sorted by arrival time.

!!!Details

In addition to your C program file, also create a C header (.h) file with all data type definitions and function prototypes. This file should be included in your C program.

Processes and their related information should be stored in ProcessBlockRecords (PBR) organized as a
queue in order of their arrival time. The PBRs should be represented as C structs, and the queue as a linked list.

Below is an example struct for the PBR. Depending on the scheduling algorithm, your struct may require additional fields (e.g. priority) - be sure to document the rationale for your changes/additions. The same data structure should be used for all three algorithms.

(:source lang=c tabwidth=3 -trim:)
struct PBR
{
int processID;
int processArrivalTime;
int remainingRunTime;
struct PBR *next; /* a pointer to the next PBR in the queue (i.e. linked list) */
};
(:sourcend:)

To allocate space for the C structs use @@malloc()@@. For example:

(:source lang=c tabwidth=3 -trim:)
struct PBR *head = (struct PBR *)malloc(sizeof(struct PBR));
(:sourcend:)

To deallocate the space use @@free()@@. For example:

(:source lang=c tabwidth=3 -trim:)
free(head);
(:sourcend:)

Your program should deallocate all the space it allocated. A good strategy is to deallocate the PBR of any process that has completed. Also, depending on how you implement your linked list, you may also use a function called @@cleanUp()@@, which takes as argument(s) the program's dynamic data structure(s). It should be called before the program exits.

Instead of maintaining actual time in your program, you should use a counter and treat every increment
made as the passing of 1 second.

In a real system, each process would perform some sort of work while executing, but, for simplicity,
this simulation will omit this detail.

To simulate IO- and CPU-bound processes, every process is provided with a probability of blocking for IO in the input file. For each unit of time a process is running, a check must be made to see if the process should block.

Again, in a real system, a process that blocks for IO would normally be blocked for some duration while the IO occurs. However, for this assignment, we are concerned only with simulating the blocking of each process. So, for this assignment, you can assume that once a process blocks it can be immediately rescheduled.

To check if a process will block, use the C @@rand()@@ function for every unit time that the process is running. For example:

(:source lang=c tabwidth=3 -trim:)
/* map random range to 0 through 99 */
int result = rand() % 100;

/* assuming an IO chance of 30% */
if (result < 30)
/* process blocks and is rescheduled */
else
/* process keeps running */

/* time is advanced by 1 */
/* ... */
(:sourcend:)

To make sure all executions of your code can be reproduced, make a call to the @srand(seed)@ function near the beginning of your program, where @@seed@@ is provided in the input file.

Lastly, '''you have two options on how to handle arriving processes''':

# Either read and schedule processes from the input file one line at a time. That is, once your code has read the first process from the input, do not read in the next process until the current process is ready to be scheduled (i.e., its arrival time <= current time).

# Or, read all the processes from the input file and place them in a temporary queue (ordered by time of arrival). Move processes from the temporary to the ready queue when they are ready to be scheduled (i.e., their arrival time <= current time).

Modularize your design using meaningfully named functions.

!!!Scheduling

For this assignment, you will be implementing three separate scheduling algorithms. The algorithm to be used is indicated by the second integer on the first line of the input file.

Implement the following scheduling algorithms:

* '''First Come First Serve (FCFS)''': There will be no time quantum/slice, therefore the implemented algorithm will be non-preemptive.

* '''Priority Scheduling''': The priority for each process will be defined as @1/f@, where @f@ is the fraction of the previous quantum used by that process. For example, assuming a time quantum of @50@, if a process runs for @25@ time units, then its fraction of used time is @25/50 = 1/2@. Hence, the priority of that process becomes @1/(1/2) = 2@ ('''Note:''' You should initialize all incoming processes to the highest possible priority, so that every process will run at least once initially.)

* '''Round Robin''': Using the quantum value provided via the input file, implement the Round Robin algorithm.

!!!Output

Upon completion of the simulation, i.e., when all processes have finished executing, your program should output the following statistics:

(:source lang=c tabwidth=3 -trim:)
average wait time: x

average turnaround time: y

average execution time: z
(:sourcend:)

where @@x@@, @@y@@, @@z@@ are float values.

'''Average wait time:''' Average (across all processes) of elapsed time between a process' arrival time and the moment it is allocated the CPU.

'''Average turnaround time:''' Average (across all processes) of elapsed time between a process' arrival time and its completion.

'''Average execution time:''' Average of all the processes' run times.
to:
!!Details

As in [[Spring2011.CSCI340Homework3 | homework 3]], each process should be stored in C structs as PBRs.

A single, global page table will be used to map virtual addresses to physical addresses. To differentiate between processes in the page table, the process ID is used as an initial index into the table.

To simulate memory references, for every time unit that a process runs, it will perform a single page reference. The page that's referenced will be decided using @@rand()@@. For example, if a process has 5 pages then every time unit you'll generate a random number between 1 and 5 and make a memory reference to that page.

Another call to @@rand()@@ will tell you if the program will make a modification to this page (i.e., whether to set the page's modification bit). There is a 50% chance for modifications to happen.

All processes will start out with zero pages currently in memory. The first time a page is referenced it will need to be “page faulted” in. That is, a free frame in physical memory will need to be allocated and an entry in the page table will need to be created to point to it.

If physical memory is full, a page replacement algorithm will be used to select a page from memory, move it to the backing store and load in the requested page. For this simulation, we will not implement a backing store, i.e., you simply overwrite the page information.

Your program should deallocate all the space it allocated.

Modularize your design using meaningfully-named, well-documented functions.
Changed lines 79-80 from:
Follow the Golden Rule of Style: "A program should be as easy for a human being to read and understand as it is for a computer to execute." [2]
to:
Follow the Golden Rule of Style: "A program should be as easy for a human being to read and understand as it is for a computer to execute." [1]
Changed lines 128-129 from:
% submit csci340 hmwk4 processScheduler.c
to:
% submit csci340 hmwk5 virtualMemorySimulation.c
Deleted lines 137-138:
# Cprogramming.com, [[http://www.cprogramming.com/tutorial/c/lesson14.html | Accepting command line arguments]], accessed on-line, March 20, 2011.
Added lines 1-228:
'''Assigned Date''': Monday, Apr. 18, 2011\\
'''Due Date''': Monday, May. 2, 2011\\
'''Due Time''': 11:50am

Last modified on {$LastModified} (see [[http://www.cs.cofc.edu/~manaris/?n=Spring2011.CSCI340_Homework5?action=diff&source=n&minor=n | updates]])

[--'''NOTE:''' This homework is an extension of [[Spring2011.CSCI340Homework3 | homework 3]]. Verbiage from homework 3 is included here to make this assignment self-contained. The extension involves adding memory management and page replacement algorithms. It also changes the format of the input data.--]

This is a '''pair-programming''' assignment (i.e., you may work with '''one''' partner). '''You may discuss the assignment only with your partner or the instructor/grader.'''

!!Purpose

This assignment focuses on Memory Management with C, and in particular:

* To gain experience with virtual memory and memory management.
* To gain experience with page faults and paging algorithms.

!!Assignment

Create a memory management simulation in C that implements a '''xxxx''', '''xxxx''', and '''xxxx''' page replacement algorithms.

Read in process information from an ASCII file. The name of the file will be provided as input to your
program, using C command-line arguments.

(:source lang=c tabwidth=3 -trim:)
int main(int argc, char *argv[])
(
/* argc equals the number of arguments received
argv is an array containing all command line arguments
argv[0] is set to the name of the program */
}
(:sourcend:)

For example, see [1].

!!!Input

The first line of the input file will contain 1 integer, 1 character, and 1 integer values:
* The first value will be used as a seed to the random number generator @@srand()@@ (so results can be reproduced),
* the second value will define which scheduling algorithm should be used (FCFS = @@'f'@@, Priority = @@'p'@@, RR = @@'r'@@), and
* the third will be the quantum (time-slice) value to use for the preemptive algorithms.

You may assume that the first and second values are separated by a single space character.

On each additional line, the input file will contain 4 integers describing a single process to be run:
* The first integer is the process ID,
* the second integer is the arrival time of the process,
* the third integer is the required execution time of the process (remember, we are simulating execution), and
* the forth integer is the probability the process will block for IO.

You should ignore anything past the forth integer on each line. The file may contain an arbitrary number of processes.

Example file contents:

(:source lang=c tabwidth=3 -trim:)
12345 r 5 # seed the random number generator with 12345, and run the RR scheduler with a 5-sec quantum
0 1 4 30 # process ID is 0, arrives at sec 1, will execute in 4 secs, has 30% chance to block for IO
1 3 2 5 # ...
2 6 7 80
(:sourcend:)

You may only assume that processes are sorted by arrival time.

!!!Details

In addition to your C program file, also create a C header (.h) file with all data type definitions and function prototypes. This file should be included in your C program.

Processes and their related information should be stored in ProcessBlockRecords (PBR) organized as a
queue in order of their arrival time. The PBRs should be represented as C structs, and the queue as a linked list.

Below is an example struct for the PBR. Depending on the scheduling algorithm, your struct may require additional fields (e.g. priority) - be sure to document the rationale for your changes/additions. The same data structure should be used for all three algorithms.

(:source lang=c tabwidth=3 -trim:)
struct PBR
{
int processID;
int processArrivalTime;
int remainingRunTime;
struct PBR *next; /* a pointer to the next PBR in the queue (i.e. linked list) */
};
(:sourcend:)

To allocate space for the C structs use @@malloc()@@. For example:

(:source lang=c tabwidth=3 -trim:)
struct PBR *head = (struct PBR *)malloc(sizeof(struct PBR));
(:sourcend:)

To deallocate the space use @@free()@@. For example:

(:source lang=c tabwidth=3 -trim:)
free(head);
(:sourcend:)

Your program should deallocate all the space it allocated. A good strategy is to deallocate the PBR of any process that has completed. Also, depending on how you implement your linked list, you may also use a function called @@cleanUp()@@, which takes as argument(s) the program's dynamic data structure(s). It should be called before the program exits.

Instead of maintaining actual time in your program, you should use a counter and treat every increment
made as the passing of 1 second.

In a real system, each process would perform some sort of work while executing, but, for simplicity,
this simulation will omit this detail.

To simulate IO- and CPU-bound processes, every process is provided with a probability of blocking for IO in the input file. For each unit of time a process is running, a check must be made to see if the process should block.

Again, in a real system, a process that blocks for IO would normally be blocked for some duration while the IO occurs. However, for this assignment, we are concerned only with simulating the blocking of each process. So, for this assignment, you can assume that once a process blocks it can be immediately rescheduled.

To check if a process will block, use the C @@rand()@@ function for every unit time that the process is running. For example:

(:source lang=c tabwidth=3 -trim:)
/* map random range to 0 through 99 */
int result = rand() % 100;

/* assuming an IO chance of 30% */
if (result < 30)
/* process blocks and is rescheduled */
else
/* process keeps running */

/* time is advanced by 1 */
/* ... */
(:sourcend:)

To make sure all executions of your code can be reproduced, make a call to the @srand(seed)@ function near the beginning of your program, where @@seed@@ is provided in the input file.

Lastly, '''you have two options on how to handle arriving processes''':

# Either read and schedule processes from the input file one line at a time. That is, once your code has read the first process from the input, do not read in the next process until the current process is ready to be scheduled (i.e., its arrival time <= current time).

# Or, read all the processes from the input file and place them in a temporary queue (ordered by time of arrival). Move processes from the temporary to the ready queue when they are ready to be scheduled (i.e., their arrival time <= current time).

Modularize your design using meaningfully named functions.

!!!Scheduling

For this assignment, you will be implementing three separate scheduling algorithms. The algorithm to be used is indicated by the second integer on the first line of the input file.

Implement the following scheduling algorithms:

* '''First Come First Serve (FCFS)''': There will be no time quantum/slice, therefore the implemented algorithm will be non-preemptive.

* '''Priority Scheduling''': The priority for each process will be defined as @1/f@, where @f@ is the fraction of the previous quantum used by that process. For example, assuming a time quantum of @50@, if a process runs for @25@ time units, then its fraction of used time is @25/50 = 1/2@. Hence, the priority of that process becomes @1/(1/2) = 2@ ('''Note:''' You should initialize all incoming processes to the highest possible priority, so that every process will run at least once initially.)

* '''Round Robin''': Using the quantum value provided via the input file, implement the Round Robin algorithm.

!!!Output

Upon completion of the simulation, i.e., when all processes have finished executing, your program should output the following statistics:

(:source lang=c tabwidth=3 -trim:)
average wait time: x

average turnaround time: y

average execution time: z
(:sourcend:)

where @@x@@, @@y@@, @@z@@ are float values.

'''Average wait time:''' Average (across all processes) of elapsed time between a process' arrival time and the moment it is allocated the CPU.

'''Average turnaround time:''' Average (across all processes) of elapsed time between a process' arrival time and its completion.

'''Average execution time:''' Average of all the processes' run times.

!!Documentation

Follow the Golden Rule of Style: "A program should be as easy for a human being to read and understand as it is for a computer to execute." [2]

In general, you should comment any variable, obscure statement, block of code, etc. you create.

Also, you should comment '''why''' something is being done, e.g.,

(:source lang=C tabwidth=3 -trim :)
numStudents += 1; /* we have processed one more student */
(:sourcend:)

as opposed to '''how''' it is done, e.g.,

(:source lang=C tabwidth=3 -trim :)
numStudents += 1; /* increment numStudents by one */
(:sourcend:)

Finally, your code should always include opening comments as follows.

(''NOTE:'' Angle brackets signify information that needs to be filled out. '''Remove''' the angle brackets!)

(:source lang=C tabwidth=3 -trim :)
/*
Author: <Your Name(s)>
Email: <Your email address(es)>
Class: CSCI 340, Section 1
Assignment: HMWK4
Due Date: <The assignment's due date>

Certification of Authenticity <remove one of the following>:

I certify that this lab is entirely my own work.

I certify that this lab is my own work, but I received
some assistance from: <Name(s)>

TASK: <Provide a simple, yet complete description of the task being
performed by this program. It may be several sentences long.>

INPUT: <Describe the input to this program. Be thorough.>

OUTPUT: <Describe the output to this program. Be thorough.>

*/
(:sourcend:)

!!Submissions

You will submit your assignment via the stono @@submit@@ command, as follows:

% submit csci340 hmwk4 processScheduler.c

No other submission mechanism will be accepted (e.g., email).

!!Grading

Your assignment will be graded based on the documentation, formatting, and correctness of your source code. Also the completeness / thoroughness of your work, and how well you followed the homework instructions.

!!Reference

# Cprogramming.com, [[http://www.cprogramming.com/tutorial/c/lesson14.html | Accepting command line arguments]], accessed on-line, March 20, 2011.

# Cooper, D. and Clancy, M. (1985) "Oh! Pascal", 2nd ed., W.W. Norton & Company, New York, p. 42.