Memory Management

1. (75 pts) Write a memory manager that supports contiguous memory allocation. Implement both first-fit and best-fit policies in your memory manager. For simplicity, assume that processes do not grow or shrink, and that no compaction is performed by the memory manager. You should consider the following issues while designing your memory manager:
   • Efficiency of your search algorithms: Both first-fit and best-fit will require you to search for an appropriate hole to accommodate the new process. You should pay careful attention to your data structures and search algorithms. For instance, keeping the list of holes sorted by size and using binary search to search for a hole might improve efficiency of your best-fit algorithms. We do not require you to use a specific algorithm/data structure to implement best-fit and first-fit; you have the flexibility of using any search algorithm/data structure that is efficient. We'll give you 20 points for any design that is more efficient that a brute-force linear search through an unsorted list of holes. Similarly, use an efficient search algorithm when deallocating a process from the processList. Explain all design decisions, the data structures and search algorithms used clearly in the README file.

   • Free block coalescing: When a process terminates, the memory allocated to that process is returned to the list of holes. You should take care to combine (coalesce) holes that are adjacent to each other and form an larger contiguous hole. This will reduce the degree of fragmentation incurred by your memory manager

2. (25 pts) Implement compaction in your memory manager. It is sufficient to implement compaction for the best-fit policy. Your memory manager should compact memory every time it sees external fragmentation (this will occur when a new process asks for memory and your memory manager is unable to allocate it due to fragmentation). A simple compaction policy that moves all currently running processes to the start of main memory and creating one hole at the high region of memory will get you full credit.

Getting Started

Unlike Lab 2, this assignment does not require you to use any special (e.g., synchronization) features of Java. Use the following template as a starting point:

class MemoryManager
{

public MemoryManager(int bytes, int policy)
{  // intialize memory with these many bytes.
    // Use first-fit if policy==0, best-fit if policy ==1

}

public int allocate(int bytes, int pid)
{ // allocate these many bytes to the process with this id
  //  assume that each pid is unique to a process
  // return 1 if successful
  // return -1 if unsuccessful; print an error indicating
  // whether there wasn't sufficient memory or whether 
  // there you ran into external fragmentation

}

public int deallocate(int pid)
{ //deallocate memory allocated to this process
  // return 1 if successful, -1 otherwise with an error message

}


public void printMemoryState()
{ // print out current state of memory 
  // Example: 
  // Memory size = 1024 bytes, allocated bytes = 24, free = 1000
  // There are currently 10 holes and 3 active process
  // Hole list:
  // hole 1: start location = 0, size = 202
  // ...
  // Process list:
  // process  id=34, start location=203, size=35
  // ...

}

}

Data structures

Input file

memorySize policy    //initialize memory to this size and use this policy
A  size pid          // allocate so much memory to this process
D   pid                // deallocate memory for this process
P                        // print current state of memory

An actual file may look as follows

8192 1
A 234 1
A 458 2
A 30  3
D 1
P
A 890 4
D 3
P
A 70 5
D 2
D 5
D 4
P

How to Turn in Lab 3

1. Create a directory in your course directory called ~/cs377/lab3. Make the directory group writable (chmod g+rwx ~/cs377/lab3) and put all files in this directory.
2. Important:All files for the first and second parts of this lab should be distinct from one another. Feel free to keep them in separate sub-directories. This will allow us to grade each part separately.
3. Hand in a hard copy of all the files you created.
4. Hand in a hard copy of a README file identifying your lab partner (if you have one) and containing an outline of what you did for the assignment. It should also explain and motivate your design choices. Keep it short and to the point. Your ~/cs377/lab3 directory should also contain this file.

If your implementation does not work, you should also document the problems in the README, preferably with your explanation of why it does not work and how you would solve it if you had more time. Of course, you should also comment your code. We can't give you credit for something we don't understand!
Remember to explain your design decisions, data structures and algorithm in the README file.
5. Hand in a hard copy showing sample output from your programs.
6. Individual Group Assessment (for students working in groups only)

10 percent of your lab grade will come from your participation in this project as a member of your two person group.

What you need to turn in (each person individually):

Turn in a hard copy of your assessment of the division of labor in the group in the format shown below.  If you give yourself a 50% and your partner gives you a 50%, you will get the whole 10 points.  If you give your partner a 40% and your partner gives himself or herself a 40%, he or she will get 8 points.  And so on...

7. Note: We will strictly enforce policies on cheating. Remember that we routinely run similarity checking programs on your solutions to detect cheating. Please make sure you turn in your own work.