Assignment 3 – Memory Management

mangledcobwebSoftware and s/w Development

Dec 14, 2013 (3 years and 5 months ago)

71 views

Assignment 2


Memory Management

Steps To Do

1
.

Keep

a

check

on

whether

the

supplied

input

is

of

required

format

or

not


2
.

Simulate

a

paging

system

with

user

defined

page

size


3
.

Access

the

memory

locations

as

described

in

programtrace


4
.

Implement

demand

paging

and

prepaging


5
.

Implement

three

different

page

replacement

algorithms


6
.

Output


7
.

Write

report




1. Check the Input format


A typical input would be:


./
memorysimulator

programlist

programtrace

2
lru

0



arg0 : program name


arg1:
programlist

file


arg2:
programtracefile



arg3: page size


arg4: page replacement algorithm selected


arg5:
prepaging
=1 / demand
-
paging=0



In case of error in input, print an error message


2 . Simulate a Paging System



Main memory is 512 locations




Store page size: one of the inputs provided by the user




Read the
programlist

file and parse the values :


Assign a unique number to each virtual page (Process# + VP#)



To maintain unique number for each page, after you finish parsing program 0 which has
pages 1...n, don't restart your number. Program1 should have pages n+1.....m , program
2 should have m+1....o.. etc. Store all these pages for each program in a vector or an
array of arrays.




Store each program size which is read from
programlist

file




Implement page tables for each program




Default load memory initially


Programlist

file

Program

No.

Program Size

Page Size

Pages Needed

Unique
Identity

No.

0

501

2

251

0~250

1

251

2

126

251~376

2

401

2

201

377~577

3

301

2





4

㘰6

2





5

㌵3

2





6

㐳4

2





7

㘵6

2





8

㌴3

2





9

㔵5

2





Page Table Implementation



Maintain

separate

page

table

for

each

program



Maintain

Page

table

for

main

memory

which

makes

it

easier

to

keep

track

of

the

pages

which

are

in

main

memory
.




The

concept

of

maintaining

page

table

is

helpful

in

real

time

systems

since

it

helps

in

searching

which

pages

are

in

memory

very

fast
.




With

each

page

replacement,

the

page

table

for

main

memory

should

be

updated
.

Unique Identity of Each Page


Already Assign each page of program with a unique number (with respect
to
all

pages in
all

page tables), so you can quickly determine if it is present
in main memory or not.



Page table for each program can use two variables:


Relative Page No.


Absolute (Physical) Page No.: unique identity No.


For example,

Relative Page No. R= (the location of the program you want to access)/
pagesize

Absolute Page No. A= the
Rth

page of the current program in page table



Page table for main memory only has Absolute Page No.

Default Load Memory


Each program will be allocated (Total no. of page frames / no. of programs)
number of pages initially. Thus each program gets a contiguous chunk of
memory.



For example, if there are 10 programs and page size=1, each program will
get 512/10


51 pages.



Load pages of each program in the fixed chunk starting from the first page
of the program.



If a program’s size is less than the chunk it is allocated, leave a blank spot in
the extra space it is allocated.

3. Access Memory Locations as Described in
Programtrace


Read the
programtrace

file and parse the values:


Each entry says the program number and the memory location it wants to
access, parse that value to an absolute page no.


Increase a
global counter
(
TimeStamp
) with each page access



If the page that contains the required location is in main memory (resident),
access it.



If LRU, assign
global counter
to that page’s timestamp



If Clock, used bit = 1 (or true)



Else a page fault occurs .


Handle page fault



Demand/
prepaging

to bring the page to memory


Use the appropriate
Page
R
eplacement algorithm (FIFO, LRU, Clock)
to pick a page for
replacement

4. Implement Demand &
Prepaging


User chooses either
demand (0)

or
prepaging

(1)



If demand paging, just bring the requested page to memory



If
prepaging
, also bring 2 pages (the faulted page + the next page)


However, count it as only 1
pagefault
.



Note
:



If the requested page is the last page of the program, bring only that page



For the correct implementation of the Page Replacement Algorithms, you
need to check if the second page is already resident. If so, you need to
update the LRU and Clock information accordingly.

5. Implement different Page Replacement algorithms



Maintain

a

global

counter

(
TimeStamp
)
:


increment

it

with

each

page

access,

(irrespective

of

which

page

is

being

accessed)

to

keep

track

of

the

oldest

memory

location

accessed
.





FIFO
:

Maintain

a

timestamp

array

associated

with

each

page

frame

in

memory
.



CLOCK
:

Maintain

an

array

(
used

bit
)

for

each

page

frame

in

memory



when

a

page

in

memory

is

accessed,

used

bit

=

1

(or

true)



LRU
:

Maintain

a

timestamp

array

and

when

a

page

is

accessed,



save

the

current

global

counter

value

as

its

timestamp
.

LRU




LRU

works

on

the

idea

that

pages

that

have

been

used

recently

are

most

likely

to

be

used

in

the

near

future
.




If

a

page

is

needed

to

be

swapped

out,

it

chooses

the



Least

Recently

Used

page

for

replacement
.




Main

idea
:

find

the

page

with

the

smallest

timestamp
.




FIFO


low
-
overhead algorithm that requires little
bookkeeping on the part of the OS



When a page needs to be replaced, the oldest page
(in terms of its stay in main memory) is selected.



FIFO is cheap and intuitive, but it performs poorly in
practical applications.

LRU VS. FIFO


Similarity: find the oldest timestamp page of main memory



Difference: if LRU is used, when a page in main memory is
accessed, the current program counter will be assigned to
timestamp of the page; while FIFO doesn’t do anything when
a page in main memory is accessed.

CLOCK


The clock algorithm keeps a circular list of pages in memory



"hand" (
iterator
) points to the oldest page (smallest timestamp) in the list
(similar part with LRU and FIFO)



When a page fault occurs and no empty frames exist, then the used bit is
inspected at the hand's location



If used bit is 0, the new page is put in place of the page the "hand" points to


Else, the used bit is cleared and the clock hand is incremented



and the process is repeated until a page is found for replacement.


6. Output


Record the number of page faults.



Number of page faults is the main output.



Don’t forget to print error messages for inappropriate inputs.



It is a good idea to also print the program sizes and the page replacement
policy selected.



The output format recommended for your program is:



/**************************************************


Page Size:

8


Replacement Algorithm:

Clock Based Policy


Paging Policy:


Demand Paging


Total Page faults: 78400

/**************************************************


You may
test

the correctness of your implementation

by checking if your results are close to the following:


Pagesize

= 2


LRU (
prepaging

disabled)


=

87211


page faults

CLOCK (
prepaging

disabled
) = 90282

FIFO (
prepaging

disabled) = 92441


Pagesize

= 2


LRU
(
prepaging

enabled)


=

62207


page faults

CLOCK (
prepaging

enabled
) = 67601

FIFO (
prepaging

enabled)

= 67115



Pagesize

= 8

LRU (
prepaging

disabled)


=

65212


page faults

CLOCK (
prepaging

disabled) =
76401

FIFO (
prepaging

disabled) =
77530


Pagesize

=
8


LRU (
prepaging

enabled)


=

60417


page faults

CLOCK (
prepaging

enabled) =
82960

FIFO (
prepaging

enabled) =
82812

7. Report Writing



After successful implementation, try running each algorithm
(clock, LRU, FIFO) with page sizes 1,2,4,8, and 16.




Obtain simulation results for both demand paging and
prepaging
.




Thus obtain 10 measurements (runs) for each page
replacement policy (LRU, clock, FIFO) .

10 Runs for LRU

LRU

1

2

Prepaging

Demand
Paging

4

8

16



Plot all these results on a graph (x:page size, y: page faults).




It will have 6 curves altogether (each with a different legend).




Write a 1
-
2 page report detailing your findings, including a
discussion of complexity of each algorithm vs. its
performance. Also, explain how
prepaging

affects the
performance.


Discussion in Report


Discuss what you expected to see vs. what you actually
saw.




If the results do not mirror your expectations / textbooks
claims, discuss why.



Discuss the relative complexity of programming each
algorithm.



Discuss how the data might have changed if a completely
random memory access trace had been supplied.


Start

Check input format: arguments<6, instructions pos up

Read program list file: # of program and size

Make page table for each program: Relative page and Absolute page

Combine all page tables to a vector (array of array)

Default load main memory with each program equally

Default assign timestamp array to each page in main memory
based on LRU, FIFO and Clock (clock array for used bit)

Read program trace file: # of program and location

Increase program counter with each page access

Calculate relative page, refer to page table, get absolute page

Find in Main
Mem
?

Pagefault processing

If LRU, assign program counter to that page’s
timestamp

If clock, assign true or 1 to used bit in clock array

Program Flow Chart

Page fault processing:

Page fault number ++

LRU: (when page is
found in main, time
stamp = program
clock)

Find the smallest
timestamp (oldest) in
main and replace

If Demand, 1 page
brings in; if prepage,
2 pages bring in

FIFO:

Find the smallest
timestamp(oldest)
in main and replace

If Demand, 1 page
brings in; if prepage,
2 pages bring in


CLOCK:

Find the smallest
timestamp(oldest) in
main, check used bit
in clock array in a
cycle way, if true,
assign false; else find
and replace

If Demand, 1 page
brings in; if prepage,
2 pages bring in