The address translation component implements virtual address to physical address translation using a page replacement algorithm (select a page replacement algorithm). This component reads the next virtual address from inBuffer and translates that address to a physical address. It prints the virtual address and corresponding physical address in a file. It also increments an integer variable (numberOfPageFaults) on every page fault. Use appropriate bit operations (<<, >>, ~, |, &, etc.) to implement this address translation. Feel free to implement a separate version of this component for every page replacement algorithm you want to experiment with. You may use FIFO for the page replacement algorithm. The statistics reporting component prints the total number of page faults (numberOfPageFaults) at the end.

Basically do the translateAddress function within the code and have it do FIFO or whatever and increment numberOfPageFaults

#include #include #include #include #include #include #include

using namespace std;

#define NUM_ADDRESSES_TO_GENERATE 10000 #define IN_BUFFER_SIZE 10 #define PAGE_SIZE 2048 #define MAIN_MEMORY_SIZE 16384 #define VIRTUAL_MEMORY_SIZE 65536 #define NUM_PAGES MAIN_MEMORY_SIZE / PAGE_SIZE

// Shared buffer to write/read virtual addresses. int inBuffer[IN_BUFFER_SIZE];

// Number of virtual addresses in the shared buffer. int inBufferCount;

// Mutex used to synchronize access to the inBuffer. pthread_mutex_t inBufferMutex;

// Counter for the number of page faults. int numberOfPageFaults;

// Flag used to indicate the address generation is done. bool addressGenerationDone;

// TODO: You'll probably need some structures and variables to store information // needed for page replacement and address translation.

int getNextVirtualAddress(int addr) { srand(time(NULL)); addr = rand() % 65536 +1; } // TODO: Replace below with your own method of generating virtual addresses. // You can just generate a random address if you want, which is probably the // easiest thing to do. void* doAddressGeneration(void* pArg) { int addr = -1; int addressCount = NUM_ADDRESSES_TO_GENERATE;

while (addressCount != 0) { if (inBufferCount < IN_BUFFER_SIZE) { addr = getNextVirtualAddress(addr); // Write the next virtual address. Be careful to synchronize // appropriately with the address translation thread.

pthread_mutex_lock(&inBufferMutex); inBuffer[inBufferCount] = addr; inBufferCount++; pthread_mutex_unlock(&inBufferMutex);

addressCount--; } else { // The buffer is full. Yield to wait for it to empty. sched_yield(); } }

// Mark that address generation is done. addressGenerationDone = true;

pthread_exit(NULL); }

int translateAddress(int addr) { int pageNumber = VIRTUAL_MEMORY_SIZE / PAGE_SIZE; int baseVirtualAddress = pageNumber * PAGE_SIZE; int pageOffset = VIRTUAL_MEMORY_SIZE % PAGE_SIZE; int basePhysicalAddress = pageNumber * PAGE_SIZE; int physAddr = basePhysicalAddress + 4; struct PageTableEntry { int pageFrameNumber; bool isPresent; }; // TODO: See page 189 in the text for info about paging. You will need a page // table. I found Figure 3-10 useful. This figure shows how to translate a // virtual address to a physical address.

// TODO: If the page table does not contain a mapping for to a page frame, a // page fault occurs. In this case, you will have to choose a page frame // (and possibly evict an old page if all page frames are in use). I would // recommend FIFO as the easiest to implement (see page 204). FIFO would // require a queue of page frames.

return 0; }

void* doAddressTranslation(void* pArg) { int addr; int physAddr; ofstream outputFile; ostream* pOutput; outputFile.open("ilab6_output.txt");

if (outputFile.is_open()) { pOutput = &outputFile; } else { cout << "Error opening ilab6_output.txt, using standard output" << endl; outputFile.close(); pOutput = &cout; }

*pOutput << "Virtual -> Physical" << endl << "--------------------" << endl;

// Keep translating addresses until none are left.

while (!addressGenerationDone) { if (inBufferCount <= 0) { // There are no addresses to read. Yield to wait for more. sched_yield(); }

while (inBufferCount > 0) { // Read the next virtual address. Be careful to synchronize // appropriately with the address generation thread.

pthread_mutex_lock(&inBufferMutex); inBufferCount--; addr = inBuffer[inBufferCount]; pthread_mutex_unlock(&inBufferMutex);

// Translate the virtual address.

physAddr = translateAddress(addr); *pOutput << "0x" << hex << setfill('0') << setw(4) << addr << " -> 0x" << hex << setfill('0') << setw(4) << physAddr << endl; } }

if (outputFile.is_open()) { outputFile.close(); }

pthread_exit(NULL); }

void* doStatistics(void* pArg) { pthread_t* pAddrTranThread = (pthread_t*)pArg;

// Wait until address translation thread exits. pthread_join(*pAddrTranThread, NULL);

cout << "Total Number of Page Faults = " << numberOfPageFaults << endl;

pthread_exit(NULL); }

int main(int argc, char* argv[]) { pthread_attr_t attrs; pthread_t addrGenThread; pthread_t addrTranThread; pthread_t statsThread;

// TODO: Seed random number generator. If your getNextVirtualAddress // function does not generate random numbers, the following line can be // removed. srand(time(NULL));

pthread_mutex_init(&inBufferMutex, NULL);

pthread_attr_init(&attrs); pthread_attr_setdetachstate(&attrs, PTHREAD_CREATE_JOINABLE);

// Create three joinable threads, one for each component of the iLab.

pthread_create(&addrGenThread, &attrs, doAddressGeneration, NULL); pthread_create(&addrTranThread, &attrs, doAddressTranslation, NULL); pthread_create(&statsThread, &attrs, doStatistics, &addrTranThread);

pthread_attr_destroy(&attrs);

pthread_join(addrGenThread, NULL); pthread_join(addrTranThread, NULL);

pthread_mutex_destroy(&inBufferMutex);

pthread_join(statsThread, NULL);

// Once all the component threads have exited, the program can exit.

return 0; }