src/Testcases/BlackParrot/bp_common/software/py/tracediff.py

import argparse
import sys

class SpikeLogEntry:
  def __init__(self, string_entry):
    instr_string = string_entry.split('\n')[0].replace(':','').split()
    commit_string = string_entry.split('\n')[1].replace('x ', 'x').split()

    self.core = int(instr_string[0], 16)
    self.pc = int(instr_string[1], 16)
    self.instr = int(instr_string[2].replace('(','').replace(')',''), 16)
    self.dasm = ' '.join(instr_string[3:])

    if len(commit_string) > 0:
      self.priv = int(commit_string[0], 16)
    if len(commit_string) > 3:
      self.rd_addr = int(commit_string[3].replace('x',''), 10)
      self.rf_instr = (self.rd_addr > 0)
    else:
      self.rf_instr = False
    if len(commit_string) > 4 and self.rf_instr:
      self.rd_data = int(commit_string[4], 16)

  def __eq__(self, rhs):
    pc_match = self.pc == rhs.pc
    rd_match = not self.rf_instr or ((self.rd_addr == rhs.rd_addr) and (self.rd_data == rhs.rd_data))

    return pc_match and rd_match

  def __ne__(self, rhs):
    return not self.__eq__(rhs)

  def __str__(self):
    display = "core: {} pc: {} instr: {} dasm: {}\n".format(hex(self.core), hex(self.pc),hex(self.instr), self.dasm)
    if self.rf_instr:
      display += "\t{} <- {}".format(hex(self.rd_addr), hex(self.rd_data))

    return display

class SimLogEntry:
  def __init__(self, string_entry):
    commit_string = string_entry.split('\n')[0].split()
    
    if len(commit_string) > 0:
      self.core = int(commit_string[0], 16)
    if len(commit_string) > 1:
      self.pc = int(commit_string[1], 16)
    if len(commit_string) > 2:
      self.instr = int(commit_string[2], 16)
    if len(commit_string) > 3:
      self.itag = int(commit_string[3], 16)
    if len(commit_string) > 4:
      self.rd_addr = int(commit_string[4], 16)
      self.rf_instr = (self.rd_addr > 0)
    else:
      self.rf_instr = False
    if len(commit_string) > 5 and self.rf_instr:
      try:
        self.rd_data = int(commit_string[5], 16)
      except:
        self.rd_data = 0

  def __eq__(self, rhs):
    pc_match = self.pc == rhs.pc
    rd_match = not self.rf_instr or ((self.rd_addr == rhs.rd_addr) and (self.rd_data == rhs.rd_data))

    return pc_match and rd_match

  def __ne__(self, rhs):
    return not self.__eq__(rhs)

  def __str__(self):
    display = "core: {} pc: {} instr: {}\n".format(hex(self.core), hex(self.pc), hex(self.instr))
    if self.rf_instr:
      display += "\t{} <- {}".format(hex(self.rd_addr), hex(self.rd_data))

    return display


def compare_trace(spike_entries, sim_entries, start_pc):
  mismatches = 0
  spike_index = 0
  sim_index = 0

  # Fast-forward to start PC
  while True:
    if spike_index >= len(spike_entries):
      print("Start PC not found in spike trace!")
      return False
    if spike_entries[spike_index].pc == start_pc:
      break
    spike_index += 1

  # Fast-forward to start PC
  while True:
    if sim_index >= len(sim_entries):
      print("Start PC not found in sim trace!")
      return False
    if sim_entries[sim_index].pc == start_pc:
      break
    sim_index += 1

  while True:
    if sim_index >= len(sim_entries):
      print("Sim trace finished!")
      break
    if spike_index >= len(spike_entries):
      print("Spike trace finished!")
      break

    if spike_entries[spike_index] != sim_entries[sim_index]:
      mismatches += 1
      print("Mismatch! PC: {} ITAG: {} DASM: {}".format(
        hex(spike_entries[spike_index].pc),
        hex(sim_entries[sim_index].itag),
        spike_entries[spike_index].dasm))

    sim_index += 1
    spike_index += 1

  return mismatches


if __name__ == "__main__":
  parser = argparse.ArgumentParser(description='Diff traces between spike and sim')
  parser.add_argument('spike_log')
  parser.add_argument('sim_log')
  parser.add_argument('start_pc')
  parser.add_argument('--tolerance', nargs='?', default=0)

  args = parser.parse_args()
  spike_log = args.spike_log
  sim_log = args.sim_log
  start_pc = int(args.start_pc, 16)
  tolerance = int(args.tolerance)

  spike_entries = []
  with open(spike_log, 'r') as f:
    entries = f.read().split("core  ")[1:]

    for entry in entries:
      spike_entries.append(SpikeLogEntry(entry))

  sim_entries = []
  with open(sim_log, 'r') as f:
    entries = f.readlines()

    for entry in entries:
      sim_entries.append(SimLogEntry(entry))

  mismatches = compare_trace(spike_entries, sim_entries, start_pc)
  if mismatches > tolerance:
    print("Mismatch! {} errors, tolerance={}".format(mismatches, tolerance))
    exit(1)
  else:
    print("MATCH")
    print("# spike instrs: {}".format(len(spike_entries)))
    print("# sim   instrs: {}".format(len(sim_entries)))
    print("# mismatch    : {}".format(mismatches))
    print("tolerance     : {}".format(tolerance))
    exit(0)