#! /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 == 'k') or (lastchar == 'K'):
m = 1024
nsize = int(size[0:length-1]) * m
elif (lastchar == 'm') or (lastchar == 'M'):
m = 1024*1024
nsize = int(size[0:length-1]) * m
elif (lastchar == 'g') or (lastchar == 'G'):
m = 1024*1024*1024
nsize = int(size[0:length-1]) * m
else:
nsize = int(size)
return nsize
#
# main program
#
parser = OptionParser()
parser.add_option("-s", "--seed", default=0, help="the random seed",
action="store", type="int", dest="seed")
parser.add_option("-A", "--addresses", default="-1",
help="a set of comma-separated pages to access; -1 means randomly generate",
action="store", type="string", dest="addresses")
parser.add_option("-a", "--asize", default="1k",
help="address space size (e.g., 16, 64k, 32m, 1g)",
action="store", type="string", dest="asize")
parser.add_option("-p", "--physmem", default="16k",
help="physical memory size (e.g., 16, 64k, 32m, 1g)",
action="store", type="string", dest="psize")
parser.add_option("-n", "--numaddrs", default=5,
help="number of virtual addresses to generate",
action="store", type="int", dest="num")
parser.add_option("-b", "--b0", default="-1",
help="value of segment 0 base register",
action="store", type="string", dest="base0")
parser.add_option("-l", "--l0", default="-1",
help="value of segment 0 limit register",
action="store", type="string", dest="len0")
parser.add_option("-B", "--b1", default="-1",
help="value of segment 1 base register",
action="store", type="string", dest="base1")
parser.add_option("-L", "--l1", default="-1",
help="value of segment 1 limit register",
action="store", type="string", dest="len1")
parser.add_option("-c", help="compute answers for me",
action="store_true", default=False, dest="solve")
(options, args) = parser.parse_args()
print "ARG seed", options.seed
print "ARG address space size", options.asize
print "ARG phys mem size", options.psize
print ""
random.seed(options.seed)
asize = convert(options.asize)
psize = convert(options.psize)
addresses = str(options.addresses)
if psize <= 1:
print 'Error: must specify a non-zero physical memory size.'
exit(1)
if asize == 0:
print 'Error: must specify a non-zero address-space size.'
exit(1)
if psize <= asize:
print 'Error: physical memory size must be GREATER than address space size (for this simulation)'
exit(1)
#
# need to generate base, bounds for segment registers
#
len0 = convert(options.len0)
len1 = convert(options.len1)
base0 = convert(options.base0)
base1 = convert(options.base1)
if len0 == -1:
len0 = int(asize/4.0 + (asize/4.0 * random.random()))
if len1 == -1:
len1 = int(asize/4.0 + (asize/4.0 * random.random()))
# now have to find room for them
if base0 == -1:
done = 0
while done == 0:
base0 = int(psize * random.random())
if (base0 + len0) < psize:
done = 1
# internally, base1 points to the lower address, and base1+len1 the higher address
# (this differs from what the user would pass in, for example)
if base1 == -1:
done = 0
while done == 0:
base1 = int(psize * random.random())
if (base1 + len1) < psize:
if (base1 > (base0 + len0)) or ((base1 + len1) < base0):
done = 1
else:
base1 = base1 - len1
if len0 > asize/2.0 or len1 > asize/2.0:
print 'Error: length register is too large for this address space'
exit(1)
print 'Segment register information:'
print ''
print ' Segment 0 base (grows positive) : 0x%08x (decimal %d)' % (base0, base0)
print ' Segment 0 limit : %d' % (len0)
print ''
print ' Segment 1 base (grows negative) : 0x%08x (decimal %d)' % (base1+len1, base1+len1)
print ' Segment 1 limit : %d' % (len1)
print ''
nbase1 = base1 + len1
if (len0 + base0) > (base1) and (base1 > base0):
print 'Error: segments overlap in physical memory'
exit(1)
addrList = []
if addresses == '-1':
# need to generate addresses
for i in range(0, options.num):
n = int(asize * random.random())
addrList.append(n)
else:
addrList = addresses.split(',')
#
# now, need to generate virtual address trace
#
print 'Virtual Address Trace'
i = 0
for vStr in addrList:
# vaddr = int(asize * random.random())
vaddr = int(vStr)
if vaddr < 0 or vaddr >= asize:
print 'Error: virtual address %d cannot be generated in an address space of size %d' % (vaddr, asize)
exit(1)
if options.solve == False:
print ' VA %2d: 0x%08x (decimal: %4d) --> PA or segmentation violation?' % (i, vaddr, vaddr)
else:
paddr = 0
if (vaddr >= (asize / 2)):
# seg 1
paddr = nbase1 + (vaddr - asize)
if paddr < base1:
print ' VA %2d: 0x%08x (decimal: %4d) --> SEGMENTATION VIOLATION (SEG1)' % (i, vaddr, vaddr)
else:
print ' VA %2d: 0x%08x (decimal: %4d) --> VALID in SEG1: 0x%08x (decimal: %4d)' % (i, vaddr, vaddr, paddr, paddr)
else:
# seg 0
if (vaddr >= len0):
print ' VA %2d: 0x%08x (decimal: %4d) --> SEGMENTATION VIOLATION (SEG0)' % (i, vaddr, vaddr)
else:
paddr = vaddr + base0
print ' VA %2d: 0x%08x (decimal: %4d) --> VALID in SEG0: 0x%08x (decimal: %4d)' % (i, vaddr, vaddr, paddr, paddr)
i += 1
print ''
if options.solve == False:
print 'For each virtual address, either write down the physical address it translates to'
print 'OR write down that it is an out-of-bounds address (a segmentation violation). For'
print 'this problem, you should assume a simple address space with two segments: the top'
print 'bit of the virtual address can thus be used to check whether the virtual address'
print 'is in segment 0 (topbit=0) or segment 1 (topbit=1). Note that the base/limit pairs'
print 'given to you grow in different directions, depending on the segment, i.e., segment 0'
print 'grows in the positive direction, whereas segment 1 in the negative. '
print ''