Data Structures and Algorithms with Object-Oriented Design Patterns in C#

Projects

Devise and conduct a set of experiments to measure garbage collection overhead. For example, write a program that creates a specified number of garbage objects as quickly as possible. Determine the number of objects needed to trigger garbage collection. Measure the running time of your program when no garbage collection is performed and compare it to the running time observed when garbage collection is invoked.
C# provides the means for accessing memory directly by using pointers and unsafe blocks. Therefore, we can simulate a heap using a C# array of ints. Write a C# class that manages an array of ints. Your class should implement the following interface:
```
public interface Heap
{
    int Acquire(int size);
    int Release(int offset);
    int this[int offset] { get; set; }
}
```
The Acquire method allocates a region of size consecutive ints in the array and returns the offset of the first int in the region. The Release method release a region of ints at the specified offset which was obtained previously using Acquire. The indexer this[] provides get and set accessors to access a value in the array at a given offset.
Using an array of ints simulate the mark-and-sweep garbage collection as follows:
1. Write a class that implements the Handle interface given below:
```
public interface Handle
{
    int Size { get; }
    int GetInt(int offset);
    Handle GetReference(int offset);
    SetInt(int offset, int value);
    SetReference(int offset, Handle h);
}
```
  A handle refers to an object that contains either ints or other handles. The size of an object is total the number of ints and handles it contains. The various store and fetch methods are used to insert and remove items from the object to which this handle refers.
2. Write a class that implements the Heap interface given below
```
public interface Heap
{
    Handle Acquire(int size);
    void Release(Handle h);
    void CollectGarbage();
}
```
  The Acquire method allocates a handle and space in the heap for an object of the given size. The Release method releases the given handle but does not reclaim the associated heap space. The CollectGarbage method performs the actual garbage collection operation.
Using the approach described in Project , implement a simulation of mark-and-compact garbage collection.
Using the approach described in Project implement a simulation of reference-counting garbage collection.