#$!/$usr$/$bin$/$env python

import sys

from optparse import OptionParser

import random

import math

def convert$($size$)$:

length $=$ len$($size$)$

lastchar $=$ size$[$length$-1]$

if $($lastchar $==\text{'}$k$\text{'})$ or $($lastchar $==\text{'}$K$\text{'})$:

m $=1024$

nsize $=$ int$($size$[0$:length$-1])*$ m

elif $($lastchar $==\text{'}$m$\text{'})$ or $($lastchar $==\text{'}$M$\text{'})$:

m $=1024*1024$

nsize $=$ int$($size$[0$:length$-1])*$ m

elif $($lastchar $==\text{'}$g$\text{'})$ or $($lastchar $==\text{'}$G$\text{'})$:

m $=1024*1024*1024$

nsize $=$ int$($size$[0$:length$-1])*$ m

else:

nsize $=$ int$($size$)$

return nsize

#

# main program

#

parser $=$ OptionParser$()$

parser.add$\_$option$(\text{'}-$s$\text{'},\text{'}--$seed', default$=0,$ help$=$'the random seed', action$=$'store', type$=$'int', dest$=$'seed'$)$

parser.add$\_$option$(\text{'}-$a$\text{'},\text{'}--$asize', default$=\text{'}1$k$\text{'},$ help$=$'address space size $($e$.$g$.,16,64$k$,32$m$,1$g$)\text{'},$ action$=$'store', type$=$'string', dest$=$'asize'$)$

parser.add$\_$option$(\text{'}-$p$\text{'},\text{'}--$physmem', default$=\text{'}16$k$\text{'},$ help$=$'physical memory size $($e$.$g$.,16,64$k$,32$m$,1$g$)\text{'},$ action$=$'store', type$=$'string', dest$=$'psize'$)$

parser.add$\_$option$(\text{'}-$n$\text{'},\text{'}--$addresses', default$=5,$ help$=$'number of virtual addresses to generate', action$=$'store', type$=$'int', dest$=$'num'$)$

parser.add$\_$option$(\text{'}-$b$\text{'},\text{'}--$b$\text{'},$ default$=\text{'}-1\text{'},$ help$=$'value of base register', action$=$'store', type$=$'string', dest$=$'base'$)$

parser.add$\_$option$(\text{'}-$l$\text{'},\text{'}--$l$\text{'},$ default$=\text{'}-1\text{'},$ help$=$'value of limit register', action$=$'store', type$=$'string', dest$=$'limit'$)$

parser.add$\_$option$(\text{'}-$c$\text{'},\text{'}--$compute', default$=$False, help$=$'compute answers for me$\text{'},$ action$=$'store$\_$true', dest$=$'solve'$)$

$($options$,$ args$)=$ parser.parse$\_$args$()$

print$(\text{'}\text{'})$

print$($ 'ARG seed', options.seed $)$

print$($ 'ARG address space size', options.asize $)$

print$($ 'ARG phys mem size', options.psize $)$

print$(\text{'}\text{'})$

random.seed$($options$.$seed$)$

asize $=$ convert$($options$.$asize$)$

psize $=$ convert$($options$.$psize$)$

if psize $<=1$:

print$($ 'Error: must specify a non$-$zero physical memory size.$\text{'})$

exit$(1)$

if asize $==0$:

print$($ 'Error: must specify a non$-$zero address$-$space size.$\text{'})$

exit$(1)$

if psize $<=$ asize:

print$($ 'Error: physical memory size must be GREATER than address space size $($for this simulation$)\text{'})$

exit$(1)$

#

# need to generate base, bounds for segment registers

#

limit $=$ convert$($options$.$limit$)$

base $=$ convert$($options$.$base$)$

if limit $==-1$:

limit $=$ int$($asize$/4\mathrm{.}0+($asize$/4\mathrm{.}0*$ random.random$()))$

# now have to find room for them

if base $==-1$:

done $=0$

while done $==0$:

base $=$ int$($psize $*$ random.random$())$

if $($base $+$ limit$)<$ psize:

done $=1$

print$($ 'Base$-$and$-$Bounds register information:$\text{'})$

print$(\text{'}\text{'})$

print$(\text{'}$ Base : $0$x$\%08$x $($decimal $\%$d$)\text{'}\%($base$,$ base$))$

print$(\text{'}$ Limit : $\%$d$\text{'}\%($limit$))$

print$(\text{'}\text{'})$

if base $+$ limit $>$ psize:

print$($ 'Error: address space does not fit into physical memory with those base$/$bounds values.$\text{'})$

print$($ 'Base $+$ Limit:$\text{'},$ base $+$ limit$,\text{'}$ Psize:$\text{'},$ psize $)$

exit$(1)$

#

# now, need to generate virtual address trace

#

print$($ 'Virtual Address Trace' $)$

for i in range$(0,$options.num$)$:

vaddr $=$ int$($asize $*$ random.random$())$

if options.solve $==$ False:

print$(\text{'}$ VA $\%2$d: $0$x$\%08$x $($decimal: $\%4$d$)-->$ PA or segmentation violation?$\text{'}\%($i$,$ vaddr, vaddr$))$

else:

paddr $=0$

if $($vaddr $>=$ limit$)$:

print$(\text{'}$ VA $\%2$d: $0$x$\%08$x $($decimal: $\%4$d$)-->$ SEGMENTATION VIOLATION' $\%($i$,$ vaddr, vaddr$))$

else:

paddr $=$ vaddr $+$ base

print$(\text{'}$ VA $\%2$d: $0$x$\%08$x $($decimal: $\%4$d$)-->$ VALID: $0$x$\%08$x $($decimal: $\%4$d$)\text{'}\%($i$,$ vaddr, vaddr, paddr, paddr$))$

print$(\text{'}\text{'})$

if options.solve $==$ False:

print$($ 'For each virtual address, either write down the physical address it translates to$\text{'})$

print$(\text{'}$OR write down that it is an out$-$of$-$bounds address $($a segmentation violation$).$ For' $)$

print$($ 'this problem, you should assume a simple virtual address space of a given size.$\text{'})$

print$(\text{'}\text{'})$

Exercise $3$ Run the simulation with these flags: $-$s $1-$n $10-$l $100.$ What is the maximum value that base can be set to$,$ such that the address space still fits into physical memory in its entirety?