Question

The goal is to simulate the C heap manager in C++ use -std=c++11 to compile

ONLY EDIT THE MemoryManager.cpp file in the sections marked in bold please and thank you

• A runtime module used to allocate and de-allocate dynamic memory

. • The "heap" is a large "pool" of memory set aside by the runtime system

• The two main functions are

– malloc, used to satisfy a request for a specific number of consecutive blocks;

– free, used to make allocated blocks available f

//blockdata.cpp do not edit this file

#include "dlUtils.h"
#include "blockdata.h"
#include
using namespace std;

blockdata::blockdata(unsigned int s, bool f, unsigned char *p)
{
blocksize = s;
free = f;
blockptr = p;
}

ostream &operator << (ostream &out, const blockdata &B)
{
out << "[" << B.blocksize << ",";
if (B.free)
out << "free";
else
out << "allocated";
out << "]";
return out;
}

//blockdata.h do not edit this file

#ifndef _BLOCKDATA_

#define _BLOCKDATA_

#include

using namespace std;

class blockdata {
friend ostream& operator << (ostream&, const blockdata &);

public:
blockdata(unsigned int s, bool f, unsigned char *p);
unsigned int blocksize;
bool free;
unsigned char *blockptr;
};

#endif

//dlUtils.h do not edit this file

#ifndef __DLNODE__

#define __DLNODE__

#include
#include

template
class dlNode {
public:
T info;
dlNode *prev;
dlNode *next;
dlNode(T val, dlNode *p, dlNode *n):info(val),prev(p),next(n){};
};

template
void printDlList(dlNode* header,dlNode *trailer,const char *sep)
{
assert(header != NULL && trailer != NULL);
dlNode *cursor = header->next;
while(cursor->next != trailer) {
std::cout << cursor->info << sep;
cursor = cursor->next;
}
if (cursor->next == trailer)
std::cout << cursor->info << std::endl;
}

template
void insertAfter(dlNode *trailer, dlNode *current, T newval)
{
assert(current != trailer);
current->next = new dlNode(newval,current,current->next);
current = current->next;
current->next->prev = current;
}

template
void deleteNode(dlNode* header, dlNode* trailer, dlNode* current)
{
assert(current!= header && current != trailer);
dlNode *hold = current;
current->prev->next = current->next;
current->next->prev = current->prev;
delete hold;
}

template
void deleteNext(dlNode* header, dlNode* trailer, dlNode *current)
{
assert(current != trailer && current->next != trailer);
deleteNode(header,trailer, current->next);
}

template
void deletePrevious(dlNode * header,dlNode * trailer,dlNode *current)
{
   assert(current != header && current->prev != header);
   deleteNode(header, trailer,current->prev);
}

template
void clearList(dlNode *p)
{
dlNode *hold = p;
while(p != NULL) {
p = p->next;
delete hold;
hold = p;
}
}

#endif

// MemoryManager.h do not edit this file

#ifndef __MM__

#define __MM__

#include
#include
#include "blockdata.h"
#include "dlUtils.h"

using namespace std;

class MemoryManager
{
public:
MemoryManager(unsigned int memsize);
~MemoryManager();
unsigned char * malloc(unsigned int request);
void free(unsigned char * ptr2block);
void showBlockList();

private:
unsigned int memsize;
unsigned char *baseptr;
dlNode* header;
dlNode* trailer;

void mergeForward(dlNode *p);
void mergeBackward(dlNode *p);
void splitBlock(dlNode *p,unsigned int chunksize);
};
  
   #endif

//MemoryManager.cpp must complete the commented in sections

#include

#include

#include "dlUtils.h"
#include "MemoryManager.h"

MemoryManager::MemoryManager(unsigned int memtotal): memsize(memtotal)
{
baseptr = new unsigned char[memsize];
blockdata dummyBlock(0,false,0);
blockdata originalBlock(memsize,true,baseptr);
header = new dlNode(dummyBlock,nullptr,nullptr);
trailer = new dlNode(dummyBlock,nullptr,nullptr);
header->next = new dlNode(originalBlock,header,trailer);
trailer->prev = header->next;
}

MemoryManager::~MemoryManager()
{
delete [] baseptr;
clearList(header);
}

void MemoryManager::showBlockList()
{
printDlList(header,trailer,"->");
}

void MemoryManager::splitBlock(dlNode *p, unsigned int chunksize)
{
// Complete the code for this method
  
}

unsigned char * MemoryManager::malloc(unsigned int request)
{
// Complete the code for this method

}

void MemoryManager::mergeForward(dlNode *p)
{
// Complete the code for this method

}

void MemoryManager::mergeBackward(dlNode *p)
{
// Complete the code for this method

}

void MemoryManager::free(unsigned char *ptr2block)
{
// Complete the code for this method

}

//testMemMgr.cpp

#include
#include "MemoryManager.h"
using namespace std;

int main()
{
MemoryManager heaper(50);
cout << "\nheap initialized\n";
cout << "\n-------------BlockList start------------------\n";
heaper.showBlockList();
cout << "-------------BlockList end------------------\n\n";
cout << "Doing first malloc:\n";
unsigned char * p1 = heaper.malloc(10);

cout << "malloc done\n";
cout << "\n-------------BlockList start------------------\n";
heaper.showBlockList();
cout << "-------------BlockList end------------------\n\n";

cout << "On to the second malloc\n";
unsigned char *p2 = heaper.malloc(20);
cout << "malloc done\n";
cout << "\n-------------BlockList start------------------\n";
heaper.showBlockList();
cout << "-------------BlockList end------------------\n\n";

cout << "Now let's ask for an un-allocatable block\n";
unsigned char *p8 = heaper.malloc(30);
if (p8 == 0)
cout << "Good. The call to malloc returned NULL\n";
else
cout << "Uh-oh. Call to malloc did not return NULL as it should have\n";

cout << "Next free the first pointer\n";
heaper.free(p1);
cout << "\n-------------BlockList start------------------\n";
heaper.showBlockList();
cout << "-------------BlockList end------------------\n\n";

cout << "Now do a malloc for a block too big for the initial open block\n";
p1 = heaper.malloc(15);
cout << "malloc done\n";
cout << "\n-------------BlockList start------------------\n";
heaper.showBlockList();
cout << "-------------BlockList end------------------\n\n";

cout << "Next free the most recently allocated pointer\n";
heaper.free(p1);
cout << "Here is the block list\n";
cout << "\n-------------BlockList start------------------\n";
heaper.showBlockList();
cout << "-------------BlockList end------------------\n\n";

cout << "Next free the middle pointer\n";
heaper.free(p2);
cout << "Here is the block list\n";
cout << "-------------BlockList start------------------\n";
heaper.showBlockList();
cout << "\n-------------BlockList end------------------\n\n";

return 0;
}

// Makefile

main: MemoryManager.o blockdata.o testMemMgr.o
   g++ -std=c++11 blockdata.o MemoryManager.o testMemMgr.o -o main

testMemMgr.o: testMemMgr.cpp
   g++ -std=c++11 -c testMemMgr.cpp

blockdata.o: blockdata.h blockdata.cpp dlUtils.h
   g++ -std=c++11 -c blockdata.cpp

MemoryManager.o: MemoryManager.cpp MemoryManager.h
   g++ -std=c++11 -c MemoryManager.cpp

clean:
   rm *.o

Answer 1

etse es

cntinue es memPoo