Give an example of how to fix emptyListInsert (pfte_t *head, pfte_t *frame) so i
ID: 655734 • Letter: G
Question
Give an example of how to fix emptyListInsert (pfte_t *head, pfte_t *frame) so it will work.
#include <iostream>
#include <exception>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include "memory_manager.h"
#include "process.h"
#include "simulator.h"
#include "disk.h"
#include "debug.h"
using namespace std;
pfte_t *Memory_Manager::page_frame_table = NULL;
struct mm_private_data {
page_table_entry *page_table;
Process *owner;
int frame_count; /* the number currently in use by this process */
pfte_t *frames;
pfte_t *head;
};
void Memory_Manager::init_per_process_data (
struct mm_private_data,**data, Process *proc) {
const int size = Memory_Model::vmem_pages;
(*data) = (struct mm_private_data *) malloc
(sizeof (structmm_private_data));
(*data)->page_table = (page_t *) malloc (size * sizeof (page_t));
for (int i = 0; i < size; i++) {
(*data)->page_table[i].valid = 0;
}
(*data)->owner = proc;
(*data)->head = NULL;
(*data)->frame_count = 0;
(*data)->frames = NULL;
}
void emptyListInsert(pfte_t *head, pfte_t *frame){
head->next = frame;
frame->prev = NULL;
frame->next = NULL;
head->prev = frame;
}
void insertAfter(pfte_t *head, pfte_t *newFrame){
newFrame->next = head->next;
head->next->prev = newFrame;
head->next = newFrame;
newFrame->prev = NULL;
}
void insertBefore(pfte_t *head, pfte_t *newFrame){
head->prev->next = newFrame;
newFrame->prev = head->prev;
head->prev = newFrame;
}
void removeFrame(pfte_t *head){
head->next = head->next->next;
head->next->prev->next = NULL;
head->next->prev = NULL;
}
int Memory_Manager::frame_limit () {
return Memory_Model::real_pages / Process::resident_process_limit;
}
void Memory_Manager::dump_process_frame_list (Process *proc) {
pfte_t *t = proc->mm_data->frames;
std::cerr << "FRAMQ: ";
if (t)
do {
assert (t->owner == proc);
assert (t->page >= 0);
std::cerr << std::setw (1) << t->page << " ";
t = t->next;
} while (t != proc->mm_data->frames);
std::cerr << std::endl;
}
void Memory_Manager::end_of_process_cleanup (Process *proc) {
assert (proc->mm_data != NULL);
FTRACE ("->Memory_Manager::end_of_process_cleanup", proc->id, "m");
if (proc->mm_data->frames) {
pfte_t *t = proc->mm_data->frames;
do {
assert (t->owner == proc);
t->owner = NULL;
t->page = -1;
t = t->next;
} while (t != proc->mm_data->frames);
proc->mm_data->frames = NULL;
}
free (proc->mm_data->page_table);
free (proc->mm_data);
proc->mm_data = NULL;
TRACE ("<-Memory_Manager::end_of_process_cleanup", proc->id, 4, "m");
}
int Memory_Manager::reference (int page, Process *proc) {
int i;
pfte_t * frame;
std::cout << "The page is " << page << std::endl;
if (page_frame_table == NULL) {
page_frame_table = (pfte_t *) malloc
(Memory_Model::real_pages * sizeof (pfte_t));
memset ((void *) page_frame_table, 0,
Memory_Model::real_pages * sizeof (pfte_t));
for (i = 0; i < Memory_Model::real_pages; i++)
page_frame_table [i] = page_frame_table_entry (NULL, -1);
}
proc->page_reference_count++;
if (proc->mm_data->page_table [page].valid) {
FTRACE ("page is resident", page, "m");
return 0;
}
proc->page_fault_count++;
FTRACE ("page fault", page, "m");
proc->mm_data->head = frame;
if (proc->mm_data->frame_count < frame_limit ()) {
for (i = 0; i != Memory_Model::real_pages; i++) {
std::cout << "first for" << std::endl;
if (page_frame_table [i].owner == NULL) {
proc->mm_data->frame_count++;
frame = &page_frame_table [i];
frame->owner = proc;
if (proc->mm_data->frames == NULL) { /* create the frame list */
FTRACE ("creating new frame list", i, "m");
proc->mm_data->head->next = frame;
proc->mm_data->frames = frame;
emptyListInsert(proc->mm_data->head, frame);
if (proc->mm_data->frames == NULL)
std::cout << "still null frames(normal)" << std::endl;
else
std::cout << "frame no longer null" << std::endl;
} else { /* insert new frame at the tail of the list */
FTRACE ("adding to existing frame list", i, "m");
pfte_t *h = proc->mm_data->head;
insertAfter(h, frame);
proc->mm_data->frames = frame;
}
std::cout << "going to load_page" << std::endl;
goto load_page;
}
}
throw new std::logic_error ("failed to find page frame");
} else {
std::cout << "second else" << std::endl;
//removes the first element
removeFrame(proc->mm_data->head, frame);
std::cout <<"removeFrame successfully finished and page is "
<< page <<std::endl;
}
load_page:
std::cout << "arrived at load_page:" << std::endl;
if (frame->page != -1) {
std::cout << "if(frame->page != -1) - step 1" << std::endl;
std::cout << "frame page is " << (frame->page) << std::endl;
frame->owner->mm_data->page_table [frame->page].valid = 0;
Disk1.request (proc, disk_write_request);
}
Disk1.request (proc, disk_read_request);
frame->page = page;
proc->mm_data->page_table [frame->page].valid = 1;
{ int i = frame - page_frame_table;
assert (frame == &page_frame_table [i]);
proc->mm_data->page_table [frame->page].frame = i;
}
return 1;
} /*.........resource .....*/
Explanation / Answer
It's a lru and fifo issue for the memory assignment :
if we have to fix the problem of emptyListInsert (pfte_t *head, pfte_t *frame) we should provide the memory block in memory queue in the data .
the data node from the head to job queue .
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.