draw the flow diagram:

Process class:$\backslash \{$

Public variables: int pid, int arrivaltime, int lifetime, int addressspace, int remaining lifetime, int completionTime

Process constructor: pid $=$ p$,$ arrival$\_$time $=$ a$,$ lifetime $=$ I, address$\_$space $=$ aspace, remaining$\_$life $\backslash (=\backslash$mathrm$\{$I$\}\backslash ),$ completion$\_$time $\backslash (=0\backslash )$

$\backslash \}$

Create PagingSimulator class: with attributes memorysize, page size, vector of frames, time, last$\_$printed$\_$time, vector input queue, vector running$\_$processes, output$\_$file, and vector of the turnaround times. Constructor: memory$\_$size $=$ mem$\_$size, page$\_$size $\backslash (=$p g $\backslash \_\backslash )$size$,$ time $\backslash (=0\backslash ),$ last$\_$printed$\_$time $\backslash (=-1\backslash ),$ output$\_$file $=$ output$\_$filename.

Frames.resize$($memorysize $/$ pagesize, $-1)$

Load$\_$workload function which takes in a pointer to string called file$\_$path:

Open the file at the file path

If you cannot open file:

Print that there's an error and file doesn't exist and terminate program exit$(1)$

String line;

Get line in the file

Process$\_$count $=$ convert line to int

While there are available lines in the file:

If line is empty then continue to next iteration

Change line to an int and put it into pid

Get line from file

Look at line to get arrival$\_$time, lifetime

Get next line

Get num of pieces

Total$\_$address$\_$space $\backslash (=0\backslash )$

For loop iteration from $0$ to pieces$-1$:

Add next value in line into space

Total$\_$address$\_$space $+=$ space

Make a process object that has pid, arrivaltime, lifetime, totaladdressspace

Add this object to all$\_$processes which is a list

Simulate function:

While time is less than or equal to $100,000$ AND all the processes are not empty or input queue is not empty or running process is not empty:

Use process$\_$arrivals function

Use check completions function Use admit processes function

Increment time by $1$

Use calculate$\_$average$\_$turnaround$\_$time function

Process arrivals function:

For a process in all$\_$processes:

If the process arrival time equals the current time:

Insert process to back of input queue

Print the current time

Write process pid arrives to the output file

Write input queue: $[$ to the output file

For the proc in the input$\_$queue:

Write pid of proc to the output file

Write $]$ to the output file to close the bracket

Take out the process from all$\_$processes

Else go on to the next process in all$\_$processes

Check$\_$completions function:

For the process in running$\_$processes:

Process's remaining$\_$lifetime $-=1$

If the process's remaining lifetime is less than or equal to $0$ then

Print the current time

Complete the process and then take out the process from runningProcesses

Else: go on to the next process in the running$\_$processesb

Complete$\_$process function that takes in a process:

Process's completion time $=$ current time

Turnaround time is process's complete time $-$ the arrival time of the process

Turnaround times list gets turnaround time

Write that process pid completes to the output file

For the frame in frames:

Extract process id from the frame and frame $/1000$

If processes$\_$id equals to process.pid then set the frace to $-1$

Use display$\_$memory$\_$map function

Admitprocesses function:

For the processes in the input queue

If the process fits in the memory then print the time right now, get the process into the memory, and take out the process from the input queue

Else: go on to the next process in the input queue

Can fit in memory function that takes in a process: Required frames is $($process$\text{'}$s address space $+$ size of page $-1)/$ size of the page Free frames is the count of all frames that has $-1$

Return true or false on freeframes at least required frames

Admit process function that takes in a process:

Required frames is $($process$\text{'}$s address space $+$ page size $-1)/$ size of page Allocated frames $\backslash (=0\backslash )$

For the frame in memory $($frames$)$:

If frame is empty then

Assign the frame $\backslash (=\backslash )$ process's pid $*\backslash (1000+\backslash )$ frames allocated

Increment the number of allocated frames

If frames allocated equals to the required frames then

Exit the loop

Write that memory manager moves the process $($pid$)$ to the memory to the output file Use display memory map function

Add the process to the list of running processes

Display memory map function:

Write memory map: to the output file

Start $=-1$

For i from $0$ to size of frames:

If $\backslash ($ i $\backslash )$ is within frames size and if frames$[$i$]$ is $-1$ then

If start is $-1$ then start $\backslash (=\backslash$mathrm$\{$i$\}\backslash )*$ page$\_$size

Else:

If the start does not equal to $-1$ then:

Write $[$start$]$ to $[($i $*$ pagesize $-1)]$: free frames to the output file

Start $=-1$

If $\backslash ($ i $\backslash )$ is within the frames size and frames$[$i$]$ does not equal to $-1$ then

Process id is frames$[$i$]/1000$

Page num is frames$[$i$]\backslash \%1000$

Write $[$i $*$ page size$]$ to $[($i$+1)*$ pagesize $-1]$: Process the pid, page number

$+1$ to the output file

Print time function:

If the time does not equal to the last printed time then

Write to output file: $\backslash ($ t$=\backslash )$ time

Last printed time $=$ time

Calculate average turnaround time function:

If the turnaround times is not empty then

Total $=$ sum of every value in the turnaround$\_$times

Avg $=$ total $/$ num of elems in turnaround times Write that the average turnaround time is $($insert average here$)$ units to output file Else: write that no processes were completed to the output file

Int main$()$:

Initialize memory size and pageSizeOption which are i