def main(): tracer = TraceGen(39, 28, 32) file = open("test_load.tr", "w") file.write(tracer.print_header()) file.write( tracer.print_comment( "Load from address - 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60" )) for i in range(0, 64, 4): temp_vaddr = (1 << 31) | i temp_ptag = (1 << 19) file.write(tracer.send_load(temp_vaddr, temp_ptag, False)) file.write(tracer.nop()) file.write(tracer.recv_data(i)) file.write(tracer.nop()) file.write(tracer.test_finish()) file.close() file = open("test_uncached_load.tr", "w") file.write(tracer.print_header()) file.write(tracer.print_comment("Uncached Load from address 36")) temp_vaddr = (1 << 31) | 36 temp_ptag = (1 << 19) file.write(tracer.send_load(temp_vaddr, temp_ptag, True)) file.write(tracer.nop()) file.write(tracer.recv_data(36)) file.write(tracer.test_finish()) file.close()
from trace_gen import TraceGen from npa_addr_gen import NPAAddrGen tg = TraceGen(addr_width_p=39, data_width_p=64) npa = NPAAddrGen(y_cord_width_p=1, x_cord_width_p=2, epa_addr_width_p=10) tg.print_header() # wait for CCE to do initialization sequence tg.wait(5000) npa_addr = npa.get_npa_addr(y=1,x=0,epa_addr=0) tg.send_store(size=8, addr=(npa_addr | (1 << 38)), data=1234567890) tg.recv_data(data=0) tg.send_load(size=8, addr=(npa_addr | (1 << 38)), signed=0) tg.recv_data(data=1234567890) npa_addr = npa.get_npa_addr(y=1,x=0,epa_addr=2) tg.send_store(size=8, addr=(npa_addr | (1 << 38)), data=0x1133557722446688) tg.recv_data(data=0) tg.send_load(size=1, addr=(npa_addr | (1 << 38))+0, signed=0) tg.recv_data(data=0x88) tg.send_load(size=1, addr=(npa_addr | (1 << 38))+1, signed=0) tg.recv_data(data=0x66) tg.send_load(size=1, addr=(npa_addr | (1 << 38))+2, signed=0) tg.recv_data(data=0x44) tg.send_load(size=1, addr=(npa_addr | (1 << 38))+3, signed=0) tg.recv_data(data=0x22) tg.send_load(size=1, addr=(npa_addr | (1 << 38))+4, signed=0) tg.recv_data(data=0x77)
# determine type of request (cached or uncached) uncached_req = 0 if lce_mixed: uncached_req = random.choice([0, 1]) elif lce_uncached: uncached_req = 1 # adjust request address depending on CCE mode # normal CCE mode expects memory requests to DRAM region of memory if not skip_init: addr = addr + mem_base check_valid_addr(addr) if load: tg.send_load(signed=0, size=size, addr=addr, uc=uncached_req) val = read_memory(byte_memory, addr, size) #eprint(str(i) + ': mem[{0}:{1}] == {2}'.format(addr, size, val)) tg.recv_data(addr=addr, data=val, uc=uncached_req) else: # NOTE: the value being stored will be truncated to size number of bytes store_val_trunc = store_val if (size < 8): store_val_trunc = store_val_trunc & ~(~0 << (size * 8)) tg.send_store(size=size, addr=addr, data=store_val_trunc, uc=uncached_req) write_memory(byte_memory, addr, store_val_trunc, size) #eprint(str(i) + ': mem[{0}:{1}] := {2}'.format(addr, size, store_val_trunc)) tg.recv_data(addr=addr, data=0, uc=uncached_req)
# # bsg_trace_rom_2.py # # rom for icache1 # import sys sys.path.append("../py/") from trace_gen import TraceGen tg = TraceGen(addr_width_p=22, data_width_p=64) # preamble tg.print_header() # test begin addr_offset = (1<<12) tg.wait(25000) for i in range(16): load_data = (i+1)*(i+1) tg.send_load(signed=0, size=4, addr=addr_offset+(i*8)) tg.recv_data(data=load_data) tg.send_load(signed=0, size=4, addr=addr_offset+(i*8)+4) tg.recv_data(data=load_data) # test end tg.test_done()
class TestGenerator(object): def __init__(self, paddr_width=40, data_width=64, debug=False): self.paddr_width = paddr_width self.data_width = data_width self.tg = TraceGen(addr_width_p=self.paddr_width, data_width_p=self.data_width) self.debug = debug def eprint(self, *args, **kwargs): print(*args, file=sys.stderr, **kwargs) # Write ops to file # ops is a dictionary, indexed by thread ID (integer) as key # the values are lists of command tuples def generateTrace(self, ops, out_dir, out_file_base): for lce in ops: file_name = '{0}_{1}.tr'.format(out_file_base, lce) with open(os.path.join(out_dir, file_name), 'w') as lce_trace_file: # preamble lce_trace_file.write(self.tg.print_header()) lce_trace_file.write(self.tg.wait(100)) # commands for (cmd, addr, size, uc, val) in ops[lce]: if cmd == 'store': lce_trace_file.write( self.tg.send_store(size=size, addr=addr, data=val, uc=uc)) lce_trace_file.write( self.tg.recv_store(size=size, addr=addr, uc=uc)) elif cmd == 'load': lce_trace_file.write( self.tg.send_load(signed=0, size=size, addr=addr, uc=uc)) lce_trace_file.write( self.tg.recv_load(signed=0, size=size, addr=addr, data=val, uc=uc)) elif cmd == 'wait': # addr is used as number of cycles lce_trace_file.write(self.tg.wait(addr)) # test end lce_trace_file.write(self.tg.test_done()) # read trace from file def readTrace(self, infile): ops = {} with open(infile, 'r') as trace_file: for raw_line in trace_file: trim_line = raw_line.strip() if not trim_line.startswith('#') and trim_line: # cmd = thread: load/store addr size uc value # cmd = thread: wait cycles line = [x.strip() for x in trim_line.split(':')] thread = int(line[0]) cmd = [x.strip() for x in line[1].split(' ')] if not thread in ops: ops[thread] = [] if cmd[0] == 'wait': cycles = int(cmd[1]) ops[thread].append(('wait', cycles, 0, 0, 0)) else: op = cmd[0] if not (op == 'store' or op == 'load'): self.eprint( '[ME TraceGen]: unrecognized op in trace file: {0}' .format(op)) return {} addr = int(cmd[1], 16) size = int(cmd[2]) uc = int(cmd[3]) if (cmd[4].startswith('0x')): value = int(cmd[4], 16) else: value = int(cmd[4]) ops[thread].append((op, addr, size, uc, value)) return ops # Random Test generator # N is number of operations # lce_mode = 0, 1, or 2 -> 0 = cached only, 1 = uncached only, 2 = mixed # cache_sets is number of sets in the cache # lce is number of LCEs to use (multi-LCE requires axe=True) # test_sets is number of cache sets to use in test # test_ways is number of cache ways per set to use in test def randomTest(self, N=16, mem_base=0, cache_sets=64, block_size=64, seed=0, lce_mode=0, lce=1, test_sets=64, test_ways=2, axe=False): random.seed(seed) ops = {i: [] for i in range(lce)} # test memory - large enough for full number of cache sets across test_ways number of ways mem_blocks = (cache_sets * test_ways) mem_bytes = (mem_blocks * block_size) mem = TestMemory(mem_base, mem_bytes, block_size, self.debug) # generate collection of block IDs that are used for testing # start with set 0 and use test_sets number of sets across test_ways number of ways test_blocks = [ s + w * cache_sets for s in range(test_sets) for w in range(test_ways) ] b = int(math.log(block_size, 2)) store_val = 1 for i in range(N): for l in range(lce): # pick access parameters store = random.choice([True, False]) # all accesses are size 8B for AXE tracing size = 8 if axe else random.choice([1, 2, 4, 8]) size_shift = int(math.log(size, 2)) # determine type of request (cached or uncached) uncached_req = 0 if lce_mode == 2: uncached_req = random.choice([0, 1]) elif lce_mode == 1: uncached_req = 1 # choose which cache block to access block = random.choice(test_blocks) # choose offset in cache block based on size of access ("word" size for this access) words = block_size / size word = random.randint(0, words - 1) # build the address addr = (block << b) + (word << size_shift) + mem_base mem.check_valid_addr(addr) val = 0 if store: # note: the value being stored will be truncated to size number of bytes store_val_trunc = store_val if (size < 8): store_val_trunc = store_val_trunc & ~(~0 << (size * 8)) if not axe: mem.write_memory(addr, store_val_trunc, size) val = store_val_trunc store_val += 1 elif not axe: val = mem.read_memory(addr, size) ops[l].append(('store' if store else 'load', addr, size, uncached_req, val)) # return the test operations return ops
for i in range(args.num_instr): load = random.choice([True, False]) #size = random.choice([1, 2, 4, 8]) size = 8 size_shift = int(math.log(size, 2)) # choose which cache block in memory to target block = random.randint(0, 128) #N_B_MEM-1) # choose offset in cache block based on size of access ("word" size for this access) words = B / size word = random.randint(0, words - 1) # build the address addr = (block << b) + (word << size_shift) check_valid_addr(addr) if load: tg.send_load(signed=0, size=size, addr=addr) #val = read_memory(byte_memory, addr, size) #eprint(str(i) + ': mem[{0}:{1}] == {2}'.format(addr, size, val)) tg.recv_data(data=0) else: # NOTE: the value being stored will be truncated to size number of bytes #store_val_trunc = store_val #if (size < 8): # store_val_trunc = store_val_trunc & ~(~0 << (size*8)) tg.send_store(size=size, addr=addr, data=store_val) #write_memory(byte_memory, addr, store_val_trunc, size) #eprint(str(i) + ': mem[{0}:{1}] := {2}'.format(addr, size, store_val_trunc)) tg.recv_data(data=0) store_val += args.num_lce # test end
uc_mask = (1 << (paddr_width - 1)) tg = TraceGen(addr_width_p=paddr_width, data_width_p=64) # TODO: the addressing below is a carryover from manycore-land. This generates valid addresses, # but is not exactly how BP works. This test will be changed to use direct assignment of addresses # in a future change, when we also change the use of the msb bit of the address to no longer rely # on it for cached/uncached determination. tg.print_header() # wait for CCE to do initialization sequence tg.wait(5000) base_addr = 0 tg.send_store(size=8, addr=(base_addr | uc_mask), data=1234567890) tg.recv_data(data=0) tg.send_load(size=8, addr=(base_addr | uc_mask), signed=0) tg.recv_data(data=1234567890) base_addr = 0 tg.send_store(size=8, addr=(base_addr | uc_mask), data=0x1133557722446688) tg.recv_data(data=0) tg.send_load(size=1, addr=(base_addr | uc_mask) + 0, signed=0) tg.recv_data(data=0x88) tg.send_load(size=1, addr=(base_addr | uc_mask) + 1, signed=0) tg.recv_data(data=0x66) tg.send_load(size=1, addr=(base_addr | uc_mask) + 2, signed=0) tg.recv_data(data=0x44) tg.send_load(size=1, addr=(base_addr | uc_mask) + 3, signed=0) tg.recv_data(data=0x22) tg.send_load(size=1, addr=(base_addr | uc_mask) + 4, signed=0) tg.recv_data(data=0x77)
# # rom for icache0 # import sys sys.path.append("../py/") from trace_gen import TraceGen tg = TraceGen(addr_width_p=22, data_width_p=64) # preamble tg.print_header() # test begin tg.wait(8) tg.send_load(signed=0, size=4, addr=0) tg.send_load(signed=0, size=4, addr=4) tg.recv_data(data=1) tg.recv_data(data=0) tg.wait(100) tg.send_load(signed=0, size=4, addr=0) tg.send_load(signed=0, size=4, addr=4) tg.recv_data(data=2) tg.recv_data(data=0) tg.wait(150) tg.send_load(signed=0, size=4, addr=0) tg.send_load(signed=0, size=4, addr=4) tg.recv_data(data=2) tg.recv_data(data=0)
def main(): tracer = TraceGen(28, 12, 6, 66) filepath = sys.argv[1] # Store/Load double word test filename = filepath + "double_word_test.tr" file = open(filename, "w") file.write(tracer.print_header()) file.write( tracer.print_comment( "Store to address - 0, 8, 16, 24, 32, 40, 48, 56")) for i in range(8, 72, 8): file.write(tracer.send_store(8, i - 8, 0, False, i)) for i in range(0, 8, 1): file.write(tracer.recv_data(0)) file.write( tracer.print_comment( "Load from address - 0, 8, 16, 24, 32, 40, 48, 56")) for i in range(8, 72, 8): file.write(tracer.send_load(True, 8, i - 8, 0, False)) for i in range(8, 72, 8): file.write(tracer.recv_data(i)) file.write(tracer.print_comment("Store/Load double word test done\n")) file.write(tracer.test_done()) file.close() # Store/Load byte test (signed and unsigned) filename = filepath + "byte_test.tr" file = open(filename, "w") file.write(tracer.print_header()) file.write(tracer.print_comment("Store byte to address 64")) file.write(tracer.send_store(1, 64, 0, False, 170)) file.write(tracer.recv_data(0)) file.write(tracer.print_comment("Load signed byte from address 64")) file.write(tracer.send_load(True, 1, 64, 0, False)) file.write(tracer.recv_data(-86)) file.write(tracer.print_comment("Load unsigned byte from address 64")) file.write(tracer.send_load(False, 1, 64, 0, False)) file.write(tracer.recv_data(170)) file.write( tracer.print_comment("Store/Load unsigned/signed byte test done\n")) file.write(tracer.test_done()) file.close() # Store/Load halfword test (signed and unsigned) filename = filepath + "half_word_test.tr" file = open(filename, "w") file = open(filename, "w") file.write(tracer.print_header()) file.write(tracer.print_comment("Store halfword to address 128")) file.write(tracer.send_store(2, 128, 0, False, 43690)) file.write(tracer.recv_data(0)) file.write(tracer.print_comment("Load signed halfword from address 128")) file.write(tracer.send_load(True, 2, 128, 0, False)) file.write(tracer.recv_data(-21846)) file.write(tracer.print_comment("Load unsigned halfword from address 128")) file.write(tracer.send_load(False, 2, 128, 0, False)) file.write(tracer.recv_data(43690)) file.write( tracer.print_comment( "Store/Load unsigned/signed halfword test done\n")) file.write(tracer.test_done()) file.close() # Store/Load word test (signed and unsigned) filename = filepath + "word_test.tr" file = open(filename, "w") file.write(tracer.print_header()) file.write(tracer.print_comment("Store word to address 192")) file.write(tracer.send_store(4, 192, 0, False, 2863311530)) file.write(tracer.recv_data(0)) file.write(tracer.print_comment("Load signed word from address 192")) file.write(tracer.send_load(True, 4, 192, 0, False)) file.write(tracer.recv_data(-1431655766)) file.write(tracer.print_comment("Load unsigned word from address 192")) file.write(tracer.send_load(False, 4, 192, 0, False)) file.write(tracer.recv_data(2863311530)) file.write( tracer.print_comment("Store/Load unsigned/signed word test done\n")) file.write(tracer.test_done()) file.close() # Store to same index with 9 different ptags (to verify writeback) filename = filepath + "writeback_test.tr" file = open(filename, "w") file.write(tracer.print_header()) file.write( tracer.print_comment( "Store to address - 256, 4352, 8448, 12544, 16640, 20736, 24832, 28928" )) for i in range(8, 72, 8): temp_ptag = ((i - 1) >> 3) file.write(tracer.send_store(8, 256, temp_ptag, False, i)) file.write(tracer.recv_data(0)) file.write( tracer.print_comment("Load from the above addresses to verify store.")) for i in range(8, 72, 8): temp_ptag = (i - 1) >> 3 file.write(tracer.send_load(True, 8, 256, temp_ptag, False)) file.write(tracer.recv_data(i)) file.write( tracer.print_comment( "Store to same cache index but different physical address - address 33024" )) file.write(tracer.send_store(8, 256, 8, False, 72)) file.write(tracer.print_comment("Receive zero (to dequeue fifo)")) file.write(tracer.recv_data(0)) file.write(tracer.print_comment("Load from address 33024")) file.write(tracer.send_load(True, 8, 256, 8, False)) file.write(tracer.recv_data(72)) file.write(tracer.print_comment("Load from address - 256")) file.write(tracer.send_load(True, 8, 256, 0, False)) file.write(tracer.recv_data(8)) file.write(tracer.print_comment("Load from address 33024")) file.write(tracer.send_load(True, 8, 256, 8, False)) file.write(tracer.recv_data(72)) file.write( tracer.print_comment( "Writeback, Eviction and Replacement successfully tested")) file.write(tracer.test_done()) file.close() # Uncached Store/Load filename = filepath + "uncached_test.tr" file = open(filename, "w") file.write(tracer.print_header()) file.write(tracer.print_comment("Store to address 320 in uncached mode")) file.write(tracer.send_store(8, 320, 0, True, 320)) file.write(tracer.recv_data(0)) file.write(tracer.print_comment("Load from address 320 in uncached mode")) file.write(tracer.send_load(True, 8, 320, 0, True)) file.write(tracer.recv_data(320)) file.write(tracer.test_done()) file.close() # Unaligned accesses filename = filepath + "unaligned_test.tr" file = open(filename, "w") file.write(tracer.print_header()) file.write(tracer.print_comment("Store byte to address - 7")) file.write(tracer.send_store(1, 7, 0, False, 255)) file.write(tracer.recv_data(0)) file.write(tracer.print_comment("Store halfword to address - 2")) file.write(tracer.send_store(2, 2, 0, False, 1010)) file.write(tracer.recv_data(0)) file.write(tracer.print_comment("Load byte from address - 7")) file.write(tracer.send_load(False, 1, 7, 0, False)) file.write(tracer.recv_data(255)) file.write(tracer.print_comment("Load halfword from address - 2")) file.write(tracer.send_load(False, 2, 2, 0, False)) file.write(tracer.recv_data(1010)) file.write(tracer.print_comment("Store word to address - 4")) file.write(tracer.send_store(4, 4, 0, False, 70000)) file.write(tracer.recv_data(0)) file.write(tracer.print_comment("Load word from address - 4")) file.write(tracer.send_load(False, 4, 4, 0, False)) file.write(tracer.recv_data(70000)) file.write(tracer.print_comment("Store \"byte\" to address - 1")) file.write(tracer.send_store(1, 1, 0, False, 256)) file.write(tracer.recv_data(0)) file.write(tracer.print_comment("Load byte from address - 1")) file.write(tracer.send_load(False, 1, 1, 0, False)) file.write(tracer.recv_data(0)) file.write(tracer.test_done()) file.close() # Directed test 1 filename = filepath + "wt_test_1.tr" file = open(filename, "w") file.write(tracer.print_header()) file.write(tracer.print_comment("Store double word to address - 0")) file.write(tracer.send_store(8, 0, 0, False, 64)) file.write(tracer.recv_data(0)) file.write(tracer.send_store(8, 0, 1, False, 128)) file.write(tracer.recv_data(0)) file.write(tracer.send_store(8, 0, 2, False, 256)) file.write(tracer.recv_data(0)) file.write(tracer.send_store(8, 64, 3, False, 512)) file.write(tracer.recv_data(0)) file.write(tracer.send_store(8, 64, 3, False, 1024)) file.write(tracer.send_store(8, 0, 1, False, 2048)) file.write(tracer.send_load(False, 8, 0, 0, False)) file.write(tracer.recv_data(0)) file.write(tracer.recv_data(0)) file.write(tracer.recv_data(64)) file.write(tracer.send_load(False, 8, 0, 1, False)) file.write(tracer.recv_data(2048)) file.write(tracer.test_done()) file.close() # Directed test 2 filename = filepath + "wt_test_2.tr" file = open(filename, "w") file.write(tracer.print_header()) file.write(tracer.print_comment("Store double word to address - 0")) file.write(tracer.send_store(8, 0, 0, False, 64)) file.write(tracer.recv_data(0)) file.write(tracer.send_store(8, 0, 1, False, 128)) file.write(tracer.recv_data(0)) file.write(tracer.send_store(8, 0, 2, False, 256)) file.write(tracer.recv_data(0)) file.write(tracer.send_store(8, 64, 3, False, 512)) file.write(tracer.recv_data(0)) file.write(tracer.send_store(8, 64, 3, False, 1024)) file.write(tracer.send_store(8, 0, 1, False, 2048)) file.write(tracer.send_load(False, 8, 0, 0, False)) file.write(tracer.send_load(False, 8, 0, 1, False)) file.write(tracer.recv_data(0)) file.write(tracer.recv_data(0)) file.write(tracer.recv_data(64)) file.write(tracer.recv_data(2048)) file.write(tracer.test_done()) file.close() # Directed test 3 filename = filepath + "wt_test_3.tr" file = open(filename, "w") file.write(tracer.print_header()) file.write(tracer.print_comment("Store double word to address - 0")) file.write(tracer.send_store(8, 0, 0, False, 64)) file.write(tracer.recv_data(0)) file.write(tracer.send_store(8, 0, 0, False, 128)) file.write(tracer.send_load(False, 8, 64, 0, False)) file.write(tracer.send_store(8, 0, 0, False, 256)) file.write(tracer.send_load(False, 8, 128, 0, False)) file.write(tracer.send_store(8, 0, 0, False, 512)) file.write(tracer.send_load(False, 8, 192, 0, False)) file.write(tracer.send_store(8, 0, 0, False, 1024)) file.write(tracer.send_load(False, 8, 256, 0, False)) for i in range(0, 8): file.write(tracer.recv_data(0)) file.write(tracer.test_done()) file.close() # Multi cycle fill directed test filename = filepath + "multicycle_fill_test.tr" file = open(filename, "w") file.write(tracer.print_header()) file.write(tracer.print_comment("Store byte to address - 0")) file.write(tracer.send_store(1, 0, 0, False, 152)) file.write(tracer.recv_data(0)) file.write(tracer.send_load(False, 1, 0, 0, False)) file.write(tracer.recv_data(152)) file.write(tracer.print_comment("Store byte to address - 73")) file.write(tracer.send_store(1, 73, 0, False, 152)) file.write(tracer.recv_data(0)) file.write(tracer.send_load(False, 1, 73, 0, False)) file.write(tracer.recv_data(152)) file.write(tracer.print_comment("Store byte to address - 146")) file.write(tracer.send_store(1, 146, 0, False, 152)) file.write(tracer.recv_data(0)) file.write(tracer.send_load(False, 1, 146, 0, False)) file.write(tracer.recv_data(152)) file.write(tracer.print_comment("Store byte to address - 219")) file.write(tracer.send_store(1, 219, 0, False, 152)) file.write(tracer.recv_data(0)) file.write(tracer.send_load(False, 1, 219, 0, False)) file.write(tracer.recv_data(152)) file.write(tracer.print_comment("Store byte to address - 292")) file.write(tracer.send_store(1, 292, 0, False, 152)) file.write(tracer.recv_data(0)) file.write(tracer.send_load(False, 1, 292, 0, False)) file.write(tracer.recv_data(152)) file.write(tracer.print_comment("Store byte to address - 365")) file.write(tracer.send_store(1, 365, 0, False, 152)) file.write(tracer.recv_data(0)) file.write(tracer.send_load(False, 1, 365, 0, False)) file.write(tracer.recv_data(152)) file.write(tracer.print_comment("Store byte to address - 438")) file.write(tracer.send_store(1, 438, 0, False, 152)) file.write(tracer.recv_data(0)) file.write(tracer.send_load(False, 1, 438, 0, False)) file.write(tracer.recv_data(152)) file.write(tracer.print_comment("Store byte to address - 511")) file.write(tracer.send_store(1, 511, 0, False, 152)) file.write(tracer.recv_data(0)) file.write(tracer.send_load(False, 1, 511, 0, False)) file.write(tracer.recv_data(152)) file.write(tracer.test_done()) file.close()
import sys sys.path.append("../py/") from trace_gen import TraceGen WAIT_TIME = 50 ways = 8 sets = 16 block_size_bytes = 64 cache_size = block_size_bytes * ways * sets tg = TraceGen(addr_width_p=20, data_width_p=block_size_bytes) # preamble tg.print_header() # test begin tg.wait(WAIT_TIME*100) tg.send_load(signed=0, size=8, addr=0) tg.recv_data(data=0x0000000F0000000F) tg.send_load(signed=0, size=8, addr=16) tg.recv_data(data=0x0000000F0000000F) # test end tg.test_done()
def main(): tracer = TraceGen(28, 12, 4, 64) # Store/Load double word test file = open("test_sd_ld.tr", "w") file.write(tracer.print_header()) file.write(tracer.print_comment("Wait for SYNC")) file.write(tracer.wait(65)) file.write(tracer.print_comment("Store to address - 0, 8, 16, 24, 32, 40, 48, 56")) for i in range(8, 72, 8): file.write(tracer.send_store(8, i-8, 0, False, i)) file.write(tracer.recv_data(0)) file.write(tracer.print_comment("Load from address - 0, 8, 16, 24, 32, 40, 48, 56")) for i in range(8, 72, 8): file.write(tracer.send_load(True, 8, i-8, 0, False)) file.write(tracer.recv_data(i)) file.write(tracer.print_comment("Store/Load double word test done\n")) file.write(tracer.test_finish()) file.close() # Store/Load byte test (signed and unsigned) file = open("test_sb_lb.tr", "w") file.write(tracer.print_header()) file.write(tracer.print_comment("Wait for SYNC")) file.write(tracer.wait(65)) file.write(tracer.print_comment("Store byte to address 64")) file.write(tracer.send_store(1, 64, 0, False, 170)) file.write(tracer.recv_data(0)) file.write(tracer.print_comment("Load signed byte from address 64")) file.write(tracer.send_load(True, 1, 64, 0, False)) file.write(tracer.recv_data(-86)) file.write(tracer.print_comment("Load unsigned byte from address 64")) file.write(tracer.send_load(False, 1, 64, 0, False)) file.write(tracer.recv_data(170)) file.write(tracer.print_comment("Store/Load unsigned/signed byte test done\n")) file.write(tracer.test_finish()) file.close() # Store/Load halfword test (signed and unsigned) file = open("test_sh_lh.tr", "w") file.write(tracer.print_header()) file.write(tracer.print_comment("Store halfword to address 128")) file.write(tracer.print_comment("Wait for SYNC")) file.write(tracer.wait(65)) file.write(tracer.send_store(2, 128, 0, False, 43690)) file.write(tracer.recv_data(0)) file.write(tracer.print_comment("Load signed halfword from address 128")) file.write(tracer.send_load(True, 2, 128, 0, False)) file.write(tracer.recv_data(-21846)) file.write(tracer.print_comment("Load unsigned halfword from address 128")) file.write(tracer.send_load(False, 2, 128, 0, False)) file.write(tracer.recv_data(43690)) file.write(tracer.print_comment("Store/Load unsigned/signed halfword test done\n")) file.write(tracer.test_finish()) file.close() # Store/Load word test (signed and unsigned) file = open("test_sw_lw.tr", "w") file.write(tracer.print_header()) file.write(tracer.print_comment("Wait for SYNC")) file.write(tracer.wait(65)) file.write(tracer.print_comment("Store word to address 192")) file.write(tracer.send_store(4, 192, 0, False, 2863311530)) file.write(tracer.recv_data(0)) file.write(tracer.print_comment("Load signed word from address 192")) file.write(tracer.send_load(True, 4, 192, 0, False)) file.write(tracer.recv_data(-1431655766)) file.write(tracer.print_comment("Load unsigned word from address 192")) file.write(tracer.send_load(False, 4, 192, 0, False)) file.write(tracer.recv_data(2863311530)) file.write(tracer.print_comment("Store/Load unsigned/signed word test done\n")) file.write(tracer.test_finish()) file.close() # Store to same index with 9 different ptags (to verify writeback) file = open("test_wb.tr", "w") file.write(tracer.print_header()) file.write(tracer.print_comment("Wait for SYNC")) file.write(tracer.wait(65)) file.write(tracer.print_comment("Store to address - 256, 4352, 8448, 12544, 16640, 20736, 24832, 28928")) for i in range(8, 72, 8): temp_ptag = ((i-1) >> 3) file.write(tracer.send_store(8, 256, temp_ptag, False, i)) file.write(tracer.recv_data(0)) file.write(tracer.print_comment("Load from the above addresses to verify store.")) for i in range(8, 72, 8): temp_ptag = (i-1) >> 3 file.write(tracer.send_load(True, 8, 256, temp_ptag, False)) file.write(tracer.recv_data(i)) file.write(tracer.print_comment("Store to same cache index but different physical address - address 33024")) file.write(tracer.send_store(8, 256, 8, False, 72)) file.write(tracer.print_comment("Receive zero (to dequeue fifo)")) file.write(tracer.recv_data(0)) file.write(tracer.print_comment("Load from address 33024")) file.write(tracer.send_load(True, 8, 256, 8, False)) file.write(tracer.recv_data(72)) file.write(tracer.print_comment("Load from address - 256")) file.write(tracer.send_load(True, 8, 256, 0, False)) file.write(tracer.recv_data(8)) file.write(tracer.print_comment("Load from address 33024")) file.write(tracer.send_load(True, 8, 256, 8, False)) file.write(tracer.recv_data(72)) file.write(tracer.print_comment("Writeback, Eviction and Replacement successfully tested")) file.write(tracer.test_finish()) file.close() # Uncached Store/Load file = open("test_uncached.tr", "w") file.write(tracer.print_header()) file.write(tracer.print_comment("Wait for SYNC")) file.write(tracer.wait(65)) file.write(tracer.print_comment("Store to address 320 in uncached mode")) file.write(tracer.send_store(8, 320, 0, True, 320)) file.write(tracer.recv_data(0)) file.write(tracer.print_comment("Load from address 320 in uncached mode")) file.write(tracer.send_load(True, 8, 320, 0, True)) file.write(tracer.recv_data(320)) file.write(tracer.test_finish()) file.close() # Unaligned accesses file = open("test_unaligned.tr", "w") file.write(tracer.print_header()) file.write(tracer.print_comment("Wait for SYNC")) file.write(tracer.wait(65)) file.write(tracer.print_comment("Store byte to address - 7")) file.write(tracer.send_store(1, 7, 0, False, 255)) file.write(tracer.recv_data(0)) file.write(tracer.print_comment("Store halfword to address - 2")) file.write(tracer.send_store(2, 2, 0, False, 1010)) file.write(tracer.recv_data(0)) file.write(tracer.print_comment("Load byte from address - 7")) file.write(tracer.send_load(False, 1, 7, 0, False)) file.write(tracer.recv_data(255)) file.write(tracer.print_comment("Load halfword from address - 2")) file.write(tracer.send_load(False, 2, 2, 0, False)) file.write(tracer.recv_data(1010)) file.write(tracer.print_comment("Store word to address - 4")) file.write(tracer.send_store(4, 4, 0, False, 70000)) file.write(tracer.recv_data(0)) file.write(tracer.print_comment("Load word from address - 4")) file.write(tracer.send_load(False, 4, 4, 0, False)) file.write(tracer.recv_data(70000)) file.write(tracer.print_comment("Store \"byte\" to address - 1")) file.write(tracer.send_store(1, 1, 0, False, 256)) file.write(tracer.recv_data(0)) file.write(tracer.print_comment("Load byte from address - 1")) file.write(tracer.send_load(False, 1, 1, 0, False)) file.write(tracer.recv_data(0)) file.write(tracer.test_finish()) file.close()
import sys sys.path.append("../py/") from trace_gen import TraceGen tg = TraceGen(addr_width_p=22, data_width_p=64) # preamble tg.print_header() # test begin N=64 for i in range(N): tg.send_store(size=8, addr=i*8, data=i+1) for i in range(N): tg.recv_data(0) for i in range(N): tg.send_load(signed=0, size=8, addr=i*8) for i in range(N): tg.recv_data(i+1) # test end tg.test_done()
import sys sys.path.append("../py") from trace_gen import TraceGen from npa_addr_gen import NPAAddrGen tg = TraceGen(addr_width_p=39, data_width_p=64) npa = NPAAddrGen(y_cord_width_p=1, x_cord_width_p=2, epa_addr_width_p=10) tg.print_header() npa_addr = npa.get_npa_addr(y=1, x=0, epa_addr=0) tg.send_store(size=8, addr=(npa_addr | (1 << 38)), data=1234567890) tg.send_load(size=8, addr=(npa_addr | (1 << 38)), signed=0) tg.recv_data(data=0) tg.recv_data(data=1234567890) npa_addr = npa.get_npa_addr(y=1, x=0, epa_addr=2) tg.send_store(size=8, addr=(npa_addr | (1 << 38)), data=0x1133557722446688) tg.send_load(size=1, addr=(npa_addr | (1 << 38)) + 0, signed=0) tg.send_load(size=1, addr=(npa_addr | (1 << 38)) + 1, signed=0) tg.send_load(size=1, addr=(npa_addr | (1 << 38)) + 2, signed=0) tg.send_load(size=1, addr=(npa_addr | (1 << 38)) + 3, signed=0) tg.send_load(size=1, addr=(npa_addr | (1 << 38)) + 4, signed=0) tg.send_load(size=1, addr=(npa_addr | (1 << 38)) + 5, signed=0) tg.send_load(size=1, addr=(npa_addr | (1 << 38)) + 6, signed=0) tg.send_load(size=1, addr=(npa_addr | (1 << 38)) + 7, signed=0) tg.recv_data(data=0) tg.recv_data(data=0x88) tg.recv_data(data=0x66)
import sys sys.path.append("../py") from trace_gen import TraceGen from npa_addr_gen import NPAAddrGen tg = TraceGen(addr_width_p=39, data_width_p=64) npa = NPAAddrGen(y_cord_width_p=1, x_cord_width_p=2, epa_addr_width_p=10) tg.print_header() tg.wait(100) npa_addr = npa.get_npa_addr(y=1, x=0, epa_addr=0) tg.send_store(size=8, addr=(npa_addr | (1 << 38)), data=1234567890) tg.recv_data(data=0) tg.send_load(size=8, addr=(npa_addr | (1 << 38)), signed=0) tg.recv_data(data=1234567890) npa_addr = npa.get_npa_addr(y=1, x=0, epa_addr=2) tg.send_store(size=8, addr=(npa_addr | (1 << 38)), data=0x1133557722446688) tg.recv_data(data=0) tg.send_load(size=1, addr=(npa_addr | (1 << 38)) + 0, signed=0) tg.recv_data(data=0x88) """ tg.send_load(size=1, addr=(npa_addr | (1 << 38))+1, signed=0) tg.recv_data(data=0x66) tg.send_load(size=1, addr=(npa_addr | (1 << 38))+2, signed=0) tg.recv_data(data=0x44) tg.send_load(size=1, addr=(npa_addr | (1 << 38))+3, signed=0) tg.recv_data(data=0x22) tg.send_load(size=1, addr=(npa_addr | (1 << 38))+4, signed=0) tg.recv_data(data=0x77)
if (len(line) != 0): if ("ecall" in line): break if (line[0] == "core" and line[2][:2] == "0x"): pc = line[2] instr = line[3][1:-1] if skip_unbooted and boot_pc != pc: continue skip_unbooted = False op_string = lines[i + 1].rstrip("\n\r").split()[0] # Send a fetch instruction tg.send_load(0, 15, int(pc, 16)) tg.recv_data(int(instr, 16)) if op_string not in [ "lb", "lbu", "lh", "lhu", "lw", "lwu", "ld", "sb", "sh", "sw", "sd" ]: tg.nop() continue addr = int(lines[i + 5].rstrip("\n\r").split()[1], 16) data = int(lines[i + 5].rstrip("\n\r").split()[3], 16) if op_string == "lb": signed = 1 size = 1
class TestGenerator(object): def __init__(self, paddr_width=40, data_width=64, debug=False): self.paddr_width = paddr_width self.data_width = data_width self.tg = TraceGen(addr_width_p=self.paddr_width, data_width_p=self.data_width) self.debug = debug def eprint(self, *args, **kwargs): print(*args, file=sys.stderr, **kwargs) def generateTrace(self, ops): # preamble self.tg.print_header() self.tg.wait(100) for (st, addr, size, uc, val) in ops: if st: self.tg.send_store(size=size, addr=addr, data=val, uc=uc) self.tg.recv_data(addr=addr, data=0, uc=uc) else: # TODO: signed operations self.tg.send_load(signed=0, size=size, addr=addr, uc=uc) self.tg.recv_data(addr=addr, data=val, uc=uc) # test end self.tg.test_done() # single cached store def storeTest(self, mem_base=0): addr = mem_base return [(True, addr, 8, 0, 1)] # cached store/load pair def loadTest(self, mem_base=0): addr = mem_base return [(True, addr, 8, 0, 1), (False, addr, 8, 0, 1)] # fill a cache set with stores # evict an entry # load back the entry def setTest(self, mem_base=0, assoc=8, sets=64, block_size=64): ops = [] addr = mem_base # blocks in same set are separated by (sets*block_size) in byte-addressable memory stride = sets * block_size store_val = 1 for i in range(assoc + 1): ops.append((True, addr, 8, 0, store_val)) addr += stride store_val += 1 ops.append((False, mem_base, 8, 0, 1)) return ops # Random loads and stores to a single set (set 0) def setHammerTest(self, N=16, mem_base=0, mem_bytes=1024, mem_block_size=64, mem_size=2, assoc=8, sets=64, seed=0, lce_mode=0): # test begin random.seed(seed) ops = [] mem = TestMemory(mem_base, mem_bytes, mem_block_size, self.debug) # compute block addresses for all blocks mapping to set 0 blocks = [i * sets * mem_block_size for i in range(assoc * mem_size)] store_val = 1 for i in range(N): # pick access parameters store = random.choice([True, False]) size = random.choice([1, 2, 4, 8]) size_shift = int(math.log(size, 2)) # determine type of request (cached or uncached) uncached_req = 0 if lce_mode == 2: uncached_req = random.choice([0, 1]) elif lce_mode == 1: uncached_req = 1 # choose which cache block in memory to target block = random.choice(blocks) # choose offset in cache block based on size of access ("word" size for this access) words = mem_block_size / size word = random.randint(0, words - 1) # build the address addr = block + (word << size_shift) + mem_base mem.check_valid_addr(addr) val = 0 if store: # NOTE: the value being stored will be truncated to size number of bytes store_val_trunc = store_val if (size < 8): store_val_trunc = store_val_trunc & ~(~0 << (size * 8)) mem.write_memory(addr, store_val_trunc, size) val = store_val_trunc store_val += 1 else: val = mem.read_memory(addr, size) ops.append((store, addr, size, uncached_req, val)) return ops # Random loads and stores to a single cache block def blockTest(self, N=16, mem_base=0, block_size=64, seed=0): return self.randomTest(N, mem_base, block_size, block_size, seed, 0) # Random Test generator # N is number of operations # lce_mode = 0, 1, or 2 -> 0 = cached only, 1 = uncached only, 2 = mixed def randomTest(self, N=16, mem_base=0, mem_bytes=1024, mem_block_size=64, seed=0, lce_mode=0): # test begin random.seed(seed) ops = [] mem = TestMemory(mem_base, mem_bytes, mem_block_size, self.debug) mem_blocks = mem_bytes / mem_block_size b = int(math.log(mem_block_size, 2)) store_val = 1 for i in range(N): # pick access parameters store = random.choice([True, False]) size = random.choice([1, 2, 4, 8]) size_shift = int(math.log(size, 2)) # determine type of request (cached or uncached) uncached_req = 0 if lce_mode == 2: uncached_req = random.choice([0, 1]) elif lce_mode == 1: uncached_req = 1 # choose which cache block in memory to target block = random.randint(0, mem_blocks - 1) # choose offset in cache block based on size of access ("word" size for this access) words = mem_block_size / size word = random.randint(0, words - 1) # build the address addr = (block << b) + (word << size_shift) + mem_base mem.check_valid_addr(addr) val = 0 if store: # NOTE: the value being stored will be truncated to size number of bytes store_val_trunc = store_val if (size < 8): store_val_trunc = store_val_trunc & ~(~0 << (size * 8)) mem.write_memory(addr, store_val_trunc, size) val = store_val_trunc store_val += 1 else: val = mem.read_memory(addr, size) ops.append((store, addr, size, uncached_req, val)) # return the test operations return ops
import sys import random sys.path.append("../py/") from trace_gen import TraceGen tg = TraceGen(addr_width_p=20, data_width_p=64) # preamble tg.print_header() # test begin random.seed(8) num_instr = 1024 store_val = 8 for i in range(num_instr): load_not_store = random.randint(0, 1) tag = random.randint(0, 15) << 10 block_offset = random.randint(0, 7) << 3 addr = tag + block_offset if (load_not_store): tg.send_load(size=8, addr=addr, signed=0) else: tg.send_store(size=8, addr=addr, data=store_val) store_val += 16 # test end tg.test_done()
from trace_gen import TraceGen tg = TraceGen(addr_width_p=22, data_width_p=64) # preamble tg.print_header() # test begin # store miss tg.send_store(size=8, addr=0x0000, data=1) tg.nop() tg.nop() tg.send_store(size=8, addr=0x0000, data=1) tg.send_load(signed=0, size=8, addr=0x0000) tg.recv_data(data=0) tg.recv_data(data=1) tg.send_store(size=8, addr=0x1000, data=2) tg.nop() tg.nop() tg.send_store(size=8, addr=0x1000, data=2) tg.send_load(signed=0, size=8, addr=0x1000) tg.recv_data(data=0) tg.recv_data(data=2) tg.send_store(size=8, addr=0x2000, data=3) tg.nop() tg.nop() tg.send_store(size=8, addr=0x2000, data=3)