#linux #operation system #c The program memory $($also called virtual memory$)$ is divided into pages which are brought to the main memory as needed.

We will implement virtual memory of a computer with one program. The memory mapping system in the exercise is demonstrated in the figure below:

The main function of the exercise will consist of a sequence of load and store commands $($random$)$ according to the example at the end of the exercise. The heart of the exercise will deal with

In the implementation a page table that maps the logical to physical pages

The load function:

Receives a logical address that must be accessed for reading. The function ensures that the relevant page of the address is in memory. if the address

that the load function received is invalid, print an error message to stderr and continue the simulation.

The store function:

Receives an address to which one must access for writing. Here too, as in load, you must make sure that the page of the address in question is in memory. in any case of

Error An error message should be printed to stderr and return from the function and continue the simulation.

The flow chart of the program:

Explain the diagram

$$ For each address we receive, first check in the page table if the page to which the address belongs is in the main memory.

$$ If the page is already in the main memory, a conversion from a virtual address to a physical address must be made: it must be done only with the help of actions

binaries

o A virtual address consists of the page number $+$ the offset within the page, so given a virtual address we would like to identify it first

All to which page the address belongs and what is the offset.

o The page table will return to us for the page we found what the appropriate frame is and thus we can access the appropriate frame in memory

the main one and advance in it according to the offset for reading or writing.

$$ If the page is not in the main memory, it must be fetched from the appropriate place. There are several options here:

$$ right$-$Access: check if this is a page with read$-$only permissions $($text$)$ or if it can be written $($heap$+$stack$+$bss$+$data$)$

o In case there are no write permissions, then the page is in the executable file. $($Why$?)$

o In case there are write permissions, i$.$e$.$ it is a page of type stack$\_$heap, bss$,$ data then check:

o If the page is "dirty", that means things have been written on it and changes have been made to it $($in other words, there was already a call with store to this page$)$

$$ If so$,$ then the page is in the swap file.

$$ If not, check if it is a stack$\_$heap, bss or data page

$$ If stack$\_$heap, bss we will allocate a new and empty page. $($here a situation of malloc or a call to a function is simulated$)$

$$ Otherwise, address data is read from the file

The data structures of the system

$1)$ database$\_$sim struct: the main data structure of the program. Will be defined in the c file of your program. Contains the following fields:

$$ table$\_$page $$ the page table of the system. A pointer to an array of

$.)$ struct page$\_$descriptor is defined later

$$ fd$\_$swap $$ the descriptor file of the swap file, to which we will refer pages from the main memory $($received by open of

the file$(.$

$$ fd$\_$program $$ the descriptor file of the program file that we "run" in the system and where the data resides $($received on

by opening the file $(..$

$$ memory$\_$main $-$ we will implement it as an array of characters of size $40$

struct sim$\_$database

$\{$

page$\_$descriptor page$\_$table$[$NUM$\_$OF$\_$PAGES$]$; $//$pointer to page table

int swapfile$\_$fd; $//$swap file fd

int program$\_$fd; $//$executable file fd

char main$\_$memory$[$MEMORY$\_$SIZE$]$;

int text$\_$size;

int data$\_$size;

int bss$\_$heap$\_$stack$\_$size;

$\}$;

The table of pages $($table$\_$page$)$ will be realized as an array of type descriptor$\_$page with size PAGES$\_$OF$\_$NUM as follows:

typedef struct page$\_$descriptor

$\{$

unsigned int V; $//$ valid

unsigned int D; $//$ dirty

unsigned int P; $//$ permission

unsigned int frame$\_$swap; $//$the number of a frame$/$swap if in case it is page$-$mapped

$\}$ page$\_$descriptor;

We initialize the sizes of the arrays like this:

#define PAGE$\_$SIZE $8$

#define NUM$\_$OF$\_$PAGES $25$

#define MEMORY$\_$SIZE $40$

# define SWAP$\_$SIZE $200$

The functions you are required to write

$1)$ system$\_$init $$ initializes the work environment

sim$\_$database $*$ sim$\_$db $=$ init$\_$system$($char exe$\_$file$\_$name$[],$ char swap$\_$file$\_$name$[],$ int text$\_$size, int data$\_$size, int

bss$\_$heap$\_$stack$\_$size $)$

The function accepts

$1.$ Executable file name

$2.$ swap file name

$3.$ The size of the size$\_$text in bytes

$4.$ The size of the size$\_$ data in bytes

In bytes bss$\_$heap$\_$stack$\_$size e size $5.$ void print$\_$swap $($struct sim$\_$database $*$ mem$\_$sim$)$;

$6)$ Printing the table$\_$page $-$

void print$\_$page$\_$table$($struct sim$\_$database $*$ mem$\_$sim$)$;

clear$\_$system $)$

$7.$void clear$\_$system$($struct sim$\_$database $*$ mem$\_$sim$)$;

Closes the open files and frees dynamic memory