You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
193 lines
6.5 KiB
193 lines
6.5 KiB
#! /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 ''
|
|
|
|
|
|
|
|
|
|
|