Example #1
0
    def synthesize(self, code):
        old_code = spu.get_active_code()
        spu.set_active_code(code)

        # Reserve two variable registers
        count = code.acquire_register()
        result = code.acquire_register()

        # 'Load' the input vector x from register 5
        x = code.acquire_register()
        spu.ai(x, 5, 0)

        # Zero count and result
        spu.xor(count, count, count)
        spu.xor(result, result, result)

        # Inline the popc and reduce operations
        self.popc(count, x)
        self.reduce_word(result, count)

        # Send the result to the caller
        spu.wrch(result, dma.SPU_WrOutMbox)

        code.release_register(x)
        spu.set_active_code(old_code)
        return
Example #2
0
def TestSetSlotValue():
  import corepy.arch.spu.platform as synspu
  import corepy.arch.spu.types.spu_types as var
  import corepy.arch.spu.lib.dma as dma

  prgm = synspu.Program()
  code = prgm.get_stream()
  proc = synspu.Processor()
  spu.set_active_code(code)
  a = var.SignedWord(0x11)
  b = var.SignedWord(0x13)
  r = var.SignedWord(0xFFFFFFFF)

  set_slot_value(code, r, 0, 0x10)
  set_slot_value(code, r, 1, a)
  set_slot_value(code, r, 2, 0x12)
  set_slot_value(code, r, 3, b)

  for i in range(4):
    spu.wrch(r, dma.SPU_WrOutMbox)
    spu.rotqbyi(r, r, 4)

  prgm.add(code)
  spe_id = proc.execute(prgm, async = True)

  for i in range(4):
    while synspu.spu_exec.stat_out_mbox(spe_id) == 0: pass
    result = synspu.spu_exec.read_out_mbox(spe_id)
    assert(result == (i + 0x10))

  proc.join(spe_id)

  return
Example #3
0
  def synthesize(self, code):
    old_code = spu.get_active_code()
    spu.set_active_code(code)


    stream = spuiter.stream_buffer(code, self.stream_addr, self.stream_size * 4,
                                   self.buffer_size, self.lsa)
    ls_data = spuiter.memory_desc('I', self.lsa, self.buffer_size / 4)
    popc = syn_popc_var()

    x = var.Word(0)
    count = var.Word(0)
    total = var.Word(0)

    for buffer in stream:
      for x in spuiter.spu_vec_iter(code, ls_data, addr_reg = buffer):
        popc.popc(count, x)

    popc.reduce_word(total, count)

    # Send the result to the caller
    spu.wrch(total, dma.SPU_WrOutMbox)    

    spu.set_active_code(old_code)
    return
Example #4
0
def TestSetSlotValue():
    import corepy.arch.spu.platform as synspu
    import corepy.arch.spu.types.spu_types as var
    import corepy.arch.spu.lib.dma as dma

    prgm = synspu.Program()
    code = prgm.get_stream()
    proc = synspu.Processor()
    spu.set_active_code(code)
    a = var.SignedWord(0x11)
    b = var.SignedWord(0x13)
    r = var.SignedWord(0xFFFFFFFF)

    set_slot_value(code, r, 0, 0x10)
    set_slot_value(code, r, 1, a)
    set_slot_value(code, r, 2, 0x12)
    set_slot_value(code, r, 3, b)

    for i in range(4):
        spu.wrch(r, dma.SPU_WrOutMbox)
        spu.rotqbyi(r, r, 4)

    prgm.add(code)
    spe_id = proc.execute(prgm, async=True)

    for i in range(4):
        while synspu.spu_exec.stat_out_mbox(spe_id) == 0:
            pass
        result = synspu.spu_exec.read_out_mbox(spe_id)
        assert (result == (i + 0x10))

    proc.join(spe_id)

    return
Example #5
0
    def synthesize(self, code):
        old_code = spu.get_active_code()
        spu.set_active_code(code)

        stream = spuiter.stream_buffer(code, self.stream_addr,
                                       self.stream_size * 4, self.buffer_size,
                                       self.lsa)
        ls_data = spuiter.memory_desc('I', self.lsa, self.buffer_size / 4)
        popc = syn_popc_var()

        x = var.Word(0)
        count = var.Word(0)
        total = var.Word(0)

        for buffer in stream:
            for x in spuiter.spu_vec_iter(code, ls_data, addr_reg=buffer):
                popc.popc(count, x)

        popc.reduce_word(total, count)

        # Send the result to the caller
        spu.wrch(total, dma.SPU_WrOutMbox)

        spu.set_active_code(old_code)
        return
Example #6
0
  def synthesize(self, code):
    old_code = spu.get_active_code()
    spu.set_active_code(code)

    # Reserve two variable registers
    count  = code.acquire_register()
    result = code.acquire_register()
    
    # 'Load' the input vector x from register 5
    x = code.acquire_register() 
    spu.ai(x, 5, 0)

    # Zero count and result
    spu.xor(count, count, count)
    spu.xor(result, result, result)
    
    # Inline the popc and reduce operations
    self.popc(count, x)
    self.reduce_word(result, count)

    # Send the result to the caller
    spu.wrch(result, dma.SPU_WrOutMbox)    

    code.release_register(x)
    spu.set_active_code(old_code)
    return
Example #7
0
    def synthesize(self, code):
        old_code = spu.get_active_code()
        spu.set_active_code(code)

        if self.result is None: raise Exception('Please set result')

        spu.wrch(self.result, dma.SPU_WrOutMbox)

        spu.set_active_code(old_code)
        return
Example #8
0
  def synthesize(self, code):
    old_code = spu.get_active_code()
    spu.set_active_code(code)

    if self.result is None: raise Exception('Please set result')

    spu.wrch(self.result, dma.SPU_WrOutMbox)

    spu.set_active_code(old_code)
    return
Example #9
0
def spu_writech(code, ch, msg):
  # msg may be either a literal value, or a register containing the value
  if isinstance(msg, (spe.Register, spe.Variable)):
    last = code.add(spu.wrch(msg, ch))
  else:
    r_msg = code.prgm.acquire_register()
    util.load_word(code, r_msg, msg)
    last = code.add(spu.wrch(r_msg, ch))
    code.prgm.release_register(r_msg)

  return last
Example #10
0
def spu_writech(code, ch, msg):
    # msg may be either a literal value, or a register containing the value
    if isinstance(msg, (spe.Register, spe.Variable)):
        last = code.add(spu.wrch(msg, ch))
    else:
        r_msg = code.acquire_register()
        util.load_word(code, r_msg, msg)
        last = code.add(spu.wrch(r_msg, ch))
        code.release_register(r_msg)

    return last
Example #11
0
def spu_mfcdma32(code, r_ls, r_ea, r_size, r_tagid, cmd):
    r_cmd = code.acquire_register()
    util.load_word(code, r_cmd, cmd)

    code.add(spu.wrch(r_ls, MFC_LSA))
    code.add(spu.wrch(r_ea, MFC_EAL))
    code.add(spu.wrch(r_size, MFC_Size))
    code.add(spu.wrch(r_tagid, MFC_TagID))
    last = code.add(spu.wrch(r_cmd, MFC_Cmd))

    code.release_register(r_cmd)
    return last
Example #12
0
def TestFloats():
    import math

    code = synspu.InstructionStream()
    proc = synspu.Processor()

    spu.set_active_code(code)

    code.set_debug(True)

    # Create a simple SPU program that computes log for all values bettween
    # .01 and 10.0 with .01 increments

    start = .65
    stop = .75
    inc = .01

    sp_step = 0x3C23D70A
    # r_current = var.Word(0x3C23D70A) # .01 in single precision
    r_current = var.Word(0x3F266666)
    r_step = var.Word(sp_step)  # .01 in single precision
    result = var.Word(0)
    log = SPULog()

    log.setup(code)
    log.set_result(result)
    log.set_x(r_current)

    log_iter = syn_iter(code, int((stop - start) / inc))

    for i in log_iter:

        log.synthesize(code)
        spu.fa(r_current, r_current, r_step)
        spu.wrch(result, dma.SPU_WrOutMbox)

    # code.print_code()
    spe_id = proc.execute(code, mode='async')

    x = start
    for i in range(int((stop - start) / inc)):
        while synspu.spu_exec.stat_out_mbox(spe_id) == 0:
            pass
        slog = synspu.spu_exec.read_out_mbox(spe_id)
        print '%.3f 0x%08X  %.08f %.08f ' % (x, slog, _sp_to_float(slog),
                                             math.log(x, 2))
        x += inc

    proc.join(spe_id)

    return
Example #13
0
def TestFloats():
  import math
  
  code = synspu.InstructionStream()
  proc = synspu.Processor()

  spu.set_active_code(code)

  code.set_debug(True)
  
  # Create a simple SPU program that computes log for all values bettween
  # .01 and 10.0 with .01 increments

  start = .65
  stop  = .75
  inc   = .01

  sp_step = 0x3C23D70A
  # r_current = var.Word(0x3C23D70A) # .01 in single precision
  r_current = var.Word(0x3F266666)
  r_step  = var.Word(sp_step)    # .01 in single precision
  result  = var.Word(0)
  log = SPULog()

  log.setup(code)
  log.set_result(result)
  log.set_x(r_current)
  
  log_iter = syn_iter(code, int((stop - start) / inc))

  for i in log_iter:
    
    log.synthesize(code)
    spu.fa(r_current, r_current, r_step)
    spu.wrch(result, dma.SPU_WrOutMbox)

  # code.print_code()
  spe_id = proc.execute(code, mode = 'async')

  x = start
  for i in range(int((stop - start) / inc)):
    while synspu.spu_exec.stat_out_mbox(spe_id) == 0: pass
    slog = synspu.spu_exec.read_out_mbox(spe_id)
    print '%.3f 0x%08X  %.08f %.08f ' % (x, slog, _sp_to_float(slog), math.log(x, 2))
    x += inc

  proc.join(spe_id)

  return
Example #14
0
def TestMbox():
  import corepy.arch.spu.platform as synspu 

  code = synspu.InstructionStream()

  # Send a message to the PPU
  spu_write_out_mbox(code, 0xDEADBEEFl)

  # Get a message from the PPU
  reg = spu_read_in_mbox(code)

  # And send it back
  code.add(spu.wrch(reg, SPU_WrOutMbox))
  
  proc = synspu.Processor()

  spe_id = proc.execute(code, async=True)
  synspu.spu_exec.write_in_mbox(spe_id, 0x88CAFE)

  while synspu.spu_exec.stat_out_mbox(spe_id) == 0: pass
  print 'spe said: 0x%X' % (synspu.spu_exec.read_out_mbox(spe_id))
  while synspu.spu_exec.stat_out_mbox(spe_id) == 0: pass
  print 'spe said: 0x%X' % (synspu.spu_exec.read_out_mbox(spe_id))

  proc.join(spe_id)
  
  return
Example #15
0
def TestMbox():

    code = synspu.InstructionStream()

    # Send a message to the PPU
    spu_write_out_mbox(code, 0xDEADBEEFl)

    # Get a message from the PPU
    reg = spu_read_in_mbox(code)

    # And send it back
    code.add(spu.wrch(reg, SPU_WrOutMbox))

    proc = synspu.Processor()

    spe_id = proc.execute(code, async=True)
    synspu.spu_exec.write_in_mbox(spe_id, 0x88CAFE)

    while synspu.spu_exec.stat_out_mbox(spe_id) == 0:
        pass
    print 'spe said: 0x%X' % (synspu.spu_exec.read_out_mbox(spe_id))
    while synspu.spu_exec.stat_out_mbox(spe_id) == 0:
        pass
    print 'spe said: 0x%X' % (synspu.spu_exec.read_out_mbox(spe_id))

    proc.join(spe_id)

    return
Example #16
0
def TestLog():
    code = synspu.InstructionStream()
    proc = synspu.Processor()

    spu.set_active_code(code)
    # Create a simple SPU program that computes log for 10 values and
    # sends the result back using the mailbox

    log = SPULog()

    values = []
    result = code.acquire_register()

    N = 10

    x = 1
    for i in range(N):
        val = var.Word(x)
        spu.cuflt(val, val, 155)
        values.append(val)
        x = x * 10

    log.setup(code)
    log.set_result(result)

    for i in range(N):

        log.set_x(values[i])
        log.synthesize(code)

        spu.wrch(result, dma.SPU_WrOutMbox)

    spe_id = proc.execute(code, mode='async')

    x = 1
    for i in range(N):
        while synspu.spu_exec.stat_out_mbox(spe_id) == 0:
            pass
        print 'log said: 0x%08X  (%d)' % (
            synspu.spu_exec.read_out_mbox(spe_id), x)
        x = x * 10

    proc.join(spe_id)

    return
Example #17
0
def TestLog():
  code = synspu.InstructionStream()
  proc = synspu.Processor()

  spu.set_active_code(code)
  # Create a simple SPU program that computes log for 10 values and
  # sends the result back using the mailbox

  log = SPULog()
  
  values = []
  result = code.acquire_register()

  N = 10
  
  x = 1
  for i in range(N):
    val = var.Word(x)
    spu.cuflt(val, val, 155)
    values.append(val)
    x = x * 10
    
  log.setup(code)
  log.set_result(result)

  for i in range(N):

    log.set_x(values[i])
    log.synthesize(code)

    spu.wrch(result, dma.SPU_WrOutMbox)
    
  spe_id = proc.execute(code, mode = 'async')

  x = 1
  for i in range(N):
    while synspu.spu_exec.stat_out_mbox(spe_id) == 0: pass
    print 'log said: 0x%08X  (%d)' %(synspu.spu_exec.read_out_mbox(spe_id), x)
    x = x * 10

  proc.join(spe_id)

  return
Example #18
0
def spu_mfcdma32(code, r_ls, r_ea, r_size, r_tagid, cmd):
#  print "spu_mfcdma32 cmd", cmd, str(cmd)
#  ref = "__spu_mfcdma32_cmd_%s" % str(cmd)
#  r_cmd = code.prgm.get_storage(ref)
#  if not isinstance(r_cmd, spu.Register):
#    r_cmd = code.acquire_register()
#    util.load_word(code, r_cmd, cmd)
#    code.prgm.add_storage(ref, r_cmd)
  
  r_cmd = code.prgm.acquire_register()
  util.load_word(code, r_cmd, cmd)

  code.add(spu.wrch(r_ls, MFC_LSA))
  code.add(spu.wrch(r_ea, MFC_EAL))
  code.add(spu.wrch(r_size, MFC_Size))
  code.add(spu.wrch(r_tagid, MFC_TagID))
  last = code.add(spu.wrch(r_cmd, MFC_Cmd))

  code.prgm.release_register(r_cmd)
  return last
Example #19
0
    def synthesize(self, code):
        old_code = spu.get_active_code()
        spu.set_active_code(code)

        # Create and initialize the variables
        count = var.Word(0)
        result = var.Word(0)
        x = var.Word(0)

        # 'Load' the input vector x from register 5
        x.v = spu.ai.ex(5, 0)

        # Inline the popc and reduce operations
        self.popc(count, x)
        self.reduce_word(result, count)

        # Send the result to the caller
        spu.wrch(result, dma.SPU_WrOutMbox)

        spu.set_active_code(old_code)
        return
Example #20
0
  def synthesize(self, code):
    old_code = spu.get_active_code()
    spu.set_active_code(code)

    # Create and initialize the variables
    count  = var.Word(0)
    result = var.Word(0)
    x = var.Word(0)    

    # 'Load' the input vector x from register 5
    x.v = spu.ai.ex(5, 0)
    
    # Inline the popc and reduce operations
    self.popc(count, x)
    self.reduce_word(result, count)

    # Send the result to the caller
    spu.wrch(result, dma.SPU_WrOutMbox)    

    spu.set_active_code(old_code)
    return
Example #21
0
  def save_register(self, reg): # , branch_to_save = False):
    code = spu.get_active_code()

    offset = code.acquire_register()
    size = code.acquire_register()
    test = code.acquire_register()
    regs = [offset, size, test]
    
    spu.rotqbyi(offset, self.ls_buffer, 4)
    spu.rotqbyi(size,   self.ls_buffer, 8)

    spu.stqx(reg, self.ls_buffer, offset)
    
    spu.ai(offset, offset, 16)
    spu.ceq(test,  offset, size)

    spu.wrch(size, dma.SPU_WrOutMbox)
    spu.wrch(offset, dma.SPU_WrOutMbox)
    spu.wrch(test, dma.SPU_WrOutMbox)
    # !!! STOPPED HERE !!! THESE VALUES ARE WRONG !!!
    lbl_ls_full = code.size()
    spu.stop(0xB)
    self.save_ls_buffer(ls_size = size)

    spu.nop(0)
    code[lbl_ls_full] = spu.brz(test, (code.size() - lbl_ls_full), ignore_active = True)

    code.release_registers(regs)
    return
Example #22
0
    def save_register(self, reg):  # , branch_to_save = False):
        code = spu.get_active_code()

        offset = code.acquire_register()
        size = code.acquire_register()
        test = code.acquire_register()
        regs = [offset, size, test]

        spu.rotqbyi(offset, self.ls_buffer, 4)
        spu.rotqbyi(size, self.ls_buffer, 8)

        spu.stqx(reg, self.ls_buffer, offset)

        spu.ai(offset, offset, 16)
        spu.ceq(test, offset, size)

        spu.wrch(size, dma.SPU_WrOutMbox)
        spu.wrch(offset, dma.SPU_WrOutMbox)
        spu.wrch(test, dma.SPU_WrOutMbox)
        # !!! STOPPED HERE !!! THESE VALUES ARE WRONG !!!
        lbl_ls_full = code.size()
        spu.stop(0xB)
        self.save_ls_buffer(ls_size=size)

        spu.nop(0)
        code[lbl_ls_full] = spu.brz(test, (code.size() - lbl_ls_full),
                                    ignore_active=True)

        code.release_registers(regs)
        return
Example #23
0
def spu_mfcdma64(code, r_ls, r_eah, r_eal, r_size, r_tagid, cmd):
  r_cmd = code.prgm.acquire_register()
  util.load_word(code, r_cmd, cmd)

  code.add(spu.wrch(r_ls, MFC_LSA))
  code.add(spu.wrch(r_eah, MFC_EAH))
  code.add(spu.wrch(r_eal, MFC_EAL))
  code.add(spu.wrch(r_size, MFC_Size))
  code.add(spu.wrch(r_tagid, MFC_TagID))
  last = code.add(spu.wrch(r_cmd, MFC_Cmd))

  code.release_register(r_cmd)
  return last
Example #24
0
def TestSignal():
  import corepy.arch.spu.platform as synspu 

  code = synspu.InstructionStream()

  # Get a signal from the PPU
  reg = spu_read_signal1(code)

  # And send it back
  code.add(spu.wrch(reg, SPU_WrOutMbox))
  
  proc = synspu.Processor()

  spe_id = proc.execute(code, async=True)
  synspu.spu_exec.write_signal(spe_id, 1, 0xCAFEBABEl)
  
  while synspu.spu_exec.stat_out_mbox(spe_id) == 0: pass

  print 'sig said: 0x%X' % (synspu.spu_exec.read_out_mbox(spe_id))

  proc.join(spe_id)
  
  return
Example #25
0
def TestSignal():

    code = synspu.InstructionStream()

    # Get a signal from the PPU
    reg = spu_read_signal1(code)

    # And send it back
    code.add(spu.wrch(reg, SPU_WrOutMbox))

    proc = synspu.Processor()

    spe_id = proc.execute(code, async=True)
    synspu.spu_exec.write_signal(spe_id, 1, 0xCAFEBABEl)

    while synspu.spu_exec.stat_out_mbox(spe_id) == 0:
        pass

    print 'sig said: 0x%X' % (synspu.spu_exec.read_out_mbox(spe_id))

    proc.join(spe_id)

    return
Example #26
0
  def dump_regs(self):
    mbox   = 28 # write out mbox channel

    # Pseudo-code:
    #  1) Save code is: (do this as an array, not an instruction stream)
    save_size = 128 * 2 + 4
    save_code = extarray.extarray('I', range(save_size))
    
    for i in range(0, 128 * 2, 2):
      save_code[i] = spu.wrch(i / 2, mbox, ignore_active = True).render()
      save_code[i + 1] = spu.stop(0x6, ignore_active = True).render()

    # branch back to the debug stop
    save_code[128 * 2] = spu.stop(0x7, ignore_active = True).render()
    ret = spu.bra(self.debug_lsa, ignore_active = True)
    save_code[128 * 2 + 1] = ret.render()

    #aligned_save_code = aligned_memory(save_size, typecode = 'I')
    #aligned_save_code.copy_to(save_code.buffer_info()[0], len(save_code))

    #  2) Save lsa[0:len(save_code)]
    # TODO: do this with putb

    #  3) Push save code to lsa[0:]
    tag = 2
    spu_exec.spu_getb(self.spe_id, 0, save_code.buffer_info()[0], save_size * 4, tag, 0, 0)
    spu_exec.read_tag_status_all(self.spe_id, 1 << tag);
    
    #  3) Replace the debug branch with a branch to 0
    self.replace(self.debug_branch, spu.bra(0, ignore_active = True))
    self.get_instructions()

    #  4) Resume
    self.resume(self.spe_id)    

    #  5) Read the register values and send the ok signal
    regs = []
    for i in range(128):
      while spu_exec.stat_out_mbox(self.spe_id) == 0: pass
      value = spu_exec.read_out_mbox(self.spe_id)
      regs.append(value)

      r = spu_exec.wait_stop_event(self.spe_id)
      self.resume(self.spe_id)

    r = spu_exec.wait_stop_event(self.spe_id)
    print 'next stop', r
    #  6) Restore code at original pc
    self.restore(self.debug_branch)
    self.get_instructions()

    #  7) Restore lsa[0:len(save_code)]
    # TODO: do this with putb

    #  8) Resume
    # self.resume(self.spe_id)    
    # r = spu_exec.wait_stop_event(self.spe_id)
    self.resume(self.spe_id)
    r = self.wait_debug()

    return regs
Example #27
0
def TestTanimotoBlock(n_vecs = 4):
  code = synspu.InstructionStream()
  proc = synspu.Processor()

  code.set_debug(True)
  spu.set_active_code(code)
  
  tb = TanimotoBlock()
  ls_save = LocalSave()
  mm_save = MemorySave()

  code.set_debug(True)

  # Input block parameters
  m = 128
  n = 64
  # n_vecs = 9
  n_bits = 128 * n_vecs

  # Main memory results buffer
  # max_results = 2**16
  max_results = 16384
  words_per_result = 4

  mm_results_data = array.array('I', [12 for i in range(max_results * words_per_result)])
  #mm_results_buffer = synspu.aligned_memory(max_results * words_per_result, typecode = 'I')
  # mm_results_buffer.copy_to(mm_results_data.buffer_info()[0], len(mm_results_data))

  mm_results = spuiter.memory_desc('I')
  #mm_results.from_array(mm_results_buffer)
  mm_results.from_array(mm_results_data)

  mm_save.set_md_save_buffer(mm_results)
    
  # Local Results buffer
  buffer_size = var.SignedWord(16384)
  buffer_addr = var.SignedWord(m * n * n_vecs * 4)
  ls_results = spuiter.memory_desc('B')
  ls_results.set_size_reg(buffer_size)
  ls_results.set_addr_reg(buffer_addr)

  ls_save.set_md_results(ls_results)
  ls_save.set_mm_save_op(mm_save)

  # Setup the TanimotoBlock class
  tb.set_n_bits(n_bits)
  tb.set_block_size(m, n)

  tb.set_x_addr(0)
  tb.set_y_addr(m * n_vecs * 16)
  tb.set_save_op(ls_save)

  # Main test loop
  n_samples = 10000
  for samples in spuiter.syn_iter(code, n_samples):
    tb.synthesize(code)

  spu.wrch(buffer_size, dma.SPU_WrOutMbox)
  
  spu.stop(0x2000) 

  # "Function" Calls
  ls_save.block()
  mm_save.block()

  # code.print_code()
  start = time.time()
  spe_id = proc.execute(code, async=True)
  
  while synspu.spu_exec.stat_out_mbox(spe_id) == 0: pass
  # print 'tb said: 0x%X' % (synspu.spu_exec.read_out_mbox(spe_id))
  stop = time.time()

  # mm_results_buffer.copy_from(mm_results_data.buffer_info()[0], len(mm_results_data))
  
  proc.join(spe_id)
  total = stop - start
  bits_sec = (m * n * n_bits * n_samples) / total / 1e9
  ops_per_compare = 48 * 4 + 8  # 48 SIMD instructions, 8 scalar
  insts_per_compare = 56
  gops = (m * n * n_vecs * n_samples * ops_per_compare ) / total / 1e9
  ginsts = (m * n * n_vecs * n_samples * insts_per_compare ) / total / 1e9  
  print '%.6f sec, %.2f Gbits/sec, %.2f GOps, %.2f GInsts, %d insts' % (
    total, bits_sec, gops, ginsts, code.size())
  return
Example #28
0
 def post_cleanup(self, code):
   spu.wrch(self._count, dma.SPU_WrOutMbox)
   return
Example #29
0
    def dump_regs(self):
        mbox = 28  # write out mbox channel

        # Pseudo-code:
        #  1) Save code is: (do this as an array, not an instruction stream)
        save_size = 128 * 2 + 4
        save_code = extarray.extarray('I', range(save_size))

        for i in range(0, 128 * 2, 2):
            save_code[i] = spu.wrch(i / 2, mbox, ignore_active=True).render()
            save_code[i + 1] = spu.stop(0x6, ignore_active=True).render()

        # branch back to the debug stop
        save_code[128 * 2] = spu.stop(0x7, ignore_active=True).render()
        ret = spu.bra(self.debug_lsa, ignore_active=True)
        save_code[128 * 2 + 1] = ret.render()

        #aligned_save_code = aligned_memory(save_size, typecode = 'I')
        #aligned_save_code.copy_to(save_code.buffer_info()[0], len(save_code))

        #  2) Save lsa[0:len(save_code)]
        # TODO: do this with putb

        #  3) Push save code to lsa[0:]
        tag = 2
        spu_exec.spu_getb(self.spe_id, 0,
                          save_code.buffer_info()[0], save_size * 4, tag, 0, 0)
        spu_exec.read_tag_status_all(self.spe_id, 1 << tag)

        #  3) Replace the debug branch with a branch to 0
        self.replace(self.debug_branch, spu.bra(0, ignore_active=True))
        self.get_instructions()

        #  4) Resume
        self.resume(self.spe_id)

        #  5) Read the register values and send the ok signal
        regs = []
        for i in range(128):
            while spu_exec.stat_out_mbox(self.spe_id) == 0:
                pass
            value = spu_exec.read_out_mbox(self.spe_id)
            regs.append(value)

            r = spu_exec.wait_stop_event(self.spe_id)
            self.resume(self.spe_id)

        r = spu_exec.wait_stop_event(self.spe_id)
        print 'next stop', r
        #  6) Restore code at original pc
        self.restore(self.debug_branch)
        self.get_instructions()

        #  7) Restore lsa[0:len(save_code)]
        # TODO: do this with putb

        #  8) Resume
        # self.resume(self.spe_id)
        # r = spu_exec.wait_stop_event(self.spe_id)
        self.resume(self.spe_id)
        r = self.wait_debug()

        return regs