def main():
options, args = parser.parse_args()
if options.model is None:
print('ERROR: no model specified')
sys.exit(-1)
with open(options.model) as f:
m = model.parse_model(lex.Lexer(f))
# Divide up the address space.
total_size = 1 << m.machine.addr_bits
fifo_size = sum(map(lambda f: f.total_size(), m.fifos))
proc_size = total_size - fifo_size
size = proc_size // len(m.benchmarks)
dists = []
ml = memory.MemoryList(m.memory)
for b in m.benchmarks:
dist = memdist.MemoryDistribution(1)
dists.append(dist)
ml.add_memory(stats.Stats(dist, m.memory))
evaluate(m, ml, options.directory)
for d in dists:
min_addr = d.get_min_address()
max_addr = d.get_max_address()
size = d.get_size()
access_count = d.get_access_count()
print("{} accesses; [{}:{}): {}"
.format(access_count, min_addr, max_addr, size))
def dump_spec(db, experiments):
names = get_name_map(db, experiments)
for mname, _, _ in db.get_status():
key = db.get_hash(mname)
if key in names:
bname, _, _ = db.get_best(mname)
m = model.parse_model(lex.Lexer(StringIO(mname)))
m.memory = memlist.parse_memory_list(lex.Lexer(StringIO(bname)))
print(m)
def test_parse(self):
to_parse = '(machine)'
to_parse += '(memory (main (memory (ram))))'
to_parse += '(benchmarks (mm) (heap))'
l = Lexer(StringIO(to_parse))
m = parse_model(l)
self.assertIsInstance(m.memory.main_memory, RAM)
self.assertEqual(len(m.benchmarks), 2)
self.assertIsInstance(m.benchmarks[0], mm.MM)
self.assertIsInstance(m.benchmarks[1], heap.Heap)
def get_name_map(db, experiments):
names = dict()
for name in experiments:
try:
with open(name, 'r') as f:
m = model.parse_model(lex.Lexer(f))
key = db.get_hash(m)
names[key] = name
except:
pass
return names
