def get_param_reg(code, param, dict, copy = True):
""" Take a parameter given to a function, which may be a value or a
register containing that value, and return a register containing the
value.
If copy is True, a new register is always returned. Otherwise if a
register was passed in, that register is returned unchanged.
dict is a dictionary used internally between get_param_reg() and
put_param_reg() to keep track of whether registers have been allocated for
parameters. A function should use one (initially empty) dictionary for
all of its parameters.
"""
reg = None
if isinstance(param, (spe.Register, spe.Variable)):
if copy == True:
# TODO - behave differently if at an even/odd spot
reg = code.prgm.acquire_register()
code.add(spu.ori(reg, param, 0))
dict[reg] = True
else:
reg = param
dict[reg] = False
else: # TODO - check types?
reg = code.prgm.acquire_register()
load_word(code, reg, param)
dict[reg] = True
return reg
def get_param_reg(code, param, dict, copy=True):
""" Take a parameter given to a function, which may be a value or a
register containing that value, and return a register containing the
value.
If copy is True, a new register is always returned. Otherwise if a
register was passed in, that register is returned unchanged.
dict is a dictionary used internally between get_param_reg() and
put_param_reg() to keep track of whether registers have been allocated for
parameters. A function should use one (initially empty) dictionary for
all of its parameters.
"""
reg = None
if isinstance(param, (spe.Register, spe.Variable)):
if copy == True:
# TODO - behave differently if at an even/odd spot
reg = code.prgm.acquire_register()
code.add(spu.ori(reg, param, 0))
dict[reg] = True
else:
reg = param
dict[reg] = False
else: # TODO - check types?
reg = code.prgm.acquire_register()
load_word(code, reg, param)
dict[reg] = True
return reg
lbl_loop = prgm.get_label("loop")
code.add(lbl_loop)
reg = dma.spu_read_in_mbox(code)
spu.ai(r_sum, r_sum, 1)
dma.spu_write_out_intr_mbox(code, r_sum)
#dma.spu_write_out_mbox(code, reg)
prgm.release_register(reg)
spu.ai(r_cnt, r_cnt, -1)
spu.brnz(r_cnt, lbl_loop)
reg = dma.spu_read_signal1(code)
spu.ori(code.gp_return, reg, 0)
spu.il(r_cnt, 0)
spu.il(r_sum, 16 * 4)
r_data = prgm.acquire_register()
r_cmp = prgm.acquire_register()
r_lsa = prgm.acquire_register()
spu.il(r_lsa, 0x1000)
lbl_incloop = prgm.get_label("incloop")
code.add(lbl_incloop)
spu.lqx(r_data, r_cnt, r_lsa)
lbl_loop = prgm.get_label("loop")
code.add(lbl_loop)
reg = dma.spu_read_in_mbox(code)
spu.ai(r_sum, r_sum, 1)
dma.spu_write_out_intr_mbox(code, r_sum)
#dma.spu_write_out_mbox(code, reg)
prgm.release_register(reg)
spu.ai(r_cnt, r_cnt, -1)
spu.brnz(r_cnt, lbl_loop)
reg = dma.spu_read_signal1(code)
spu.ori(code.gp_return, reg, 0)
spu.il(r_cnt, 0)
spu.il(r_sum, 16 * 4)
r_data = prgm.acquire_register()
r_cmp = prgm.acquire_register()
r_lsa = prgm.acquire_register()
spu.il(r_lsa, 0x1000)
lbl_incloop = prgm.get_label("incloop")
code.add(lbl_incloop)
spu.lqx(r_data, r_cnt, r_lsa)
spu.ai(r_data, r_data, 2)
def SimpleSPU():
"""
A very simple SPU that computes 11 + 31 and returns 0xA on success.
"""
code = InstructionStream()
proc = Processor()
spu.set_active_code(code)
# Acquire two registers
#x = code.acquire_register()
x = code.gp_return
test = code.acquire_register()
lbl_brz = code.get_label("BRZ")
lbl_skip = code.get_label("SKIP")
spu.hbrr(lbl_brz, lbl_skip)
spu.xor(x, x, x) # zero x
spu.ai(x, x, 11) # x = x + 11
spu.ai(x, x, 31) # x = x + 31
spu.ceqi(test, x, 42) # test = (x == 42)
# If test is false (all 0s), skip the stop(0x100A) instruction
code.add(lbl_brz)
spu.brz(test, lbl_skip)
spu.stop(0x100A)
code.add(lbl_skip)
spu.stop(0x100B)
code.print_code(hex=True, pro=True, epi=True)
r = proc.execute(code, mode='int', stop=True)
print "ret", r
assert (r[0] == 42)
assert (r[1] == 0x100A)
code = InstructionStream()
spu.set_active_code(code)
lbl_loop = code.get_label("LOOP")
lbl_break = code.get_label("BREAK")
r_cnt = code.acquire_register()
r_stop = code.acquire_register()
r_cmp = code.acquire_register()
r_foo = code.gp_return
spu.ori(r_foo, code.r_zero, 0)
spu.ori(r_cnt, code.r_zero, 0)
util.load_word(code, r_stop, 10)
code.add(lbl_loop)
spu.ceq(r_cmp, r_cnt, r_stop)
spu.brnz(r_cmp, lbl_break)
spu.ai(r_cnt, r_cnt, 1)
spu.a(r_foo, r_foo, r_cnt)
spu.br(lbl_loop)
code.add(lbl_break)
code.print_code()
r = proc.execute(code, mode='int', stop=True)
print "ret", r
assert (r[0] == 55)
return
def SimpleSPU():
"""
A very simple SPU that computes 11 + 31 and returns 0xA on success.
"""
prgm = env.Program()
code = prgm.get_stream()
proc = env.Processor()
spu.set_active_code(code)
# Acquire two registers
#x = code.acquire_register()
x = prgm.gp_return
test = prgm.acquire_register()
lbl_brz = prgm.get_label("BRZ")
lbl_skip = prgm.get_label("SKIP")
spu.hbrr(lbl_brz, lbl_skip)
spu.xor(x, x, x) # zero x
spu.ai(x, x, 11) # x = x + 11
spu.ai(x, x, 31) # x = x + 31
spu.ceqi(test, x, 42) # test = (x == 42)
# If test is false (all 0s), skip the stop(0x100A) instruction
code.add(lbl_brz)
spu.brz(test, lbl_skip)
spu.stop(0x100A)
code.add(lbl_skip)
spu.stop(0x100B)
prgm.add(code)
prgm.print_code()
r = proc.execute(prgm, mode = 'int', stop = True)
print "ret", r
assert(r[0] == 42)
assert(r[1] == 0x100A)
prgm = env.Program()
code = prgm.get_stream()
spu.set_active_code(code)
lbl_loop = prgm.get_label("LOOP")
lbl_break = prgm.get_label("BREAK")
r_cnt = prgm.acquire_register()
r_stop = prgm.acquire_register()
r_cmp = prgm.acquire_register()
r_foo = prgm.gp_return
spu.ori(r_foo, prgm.r_zero, 0)
spu.ori(r_cnt, prgm.r_zero, 0)
util.load_word(code, r_stop, 10)
code.add(lbl_loop)
spu.ceq(r_cmp, r_cnt, r_stop)
spu.brnz(r_cmp, lbl_break)
spu.ai(r_cnt, r_cnt, 1)
spu.a(r_foo, r_foo, r_cnt)
spu.br(lbl_loop)
code.add(lbl_break)
prgm.add(code)
prgm.print_code()
r = proc.execute(prgm, mode = 'int', stop = True)
print "ret", r
assert(r[0] == 55)
return
prgm = env.Program()
code = prgm.get_stream()
reg = prgm.acquire_register()
foo = prgm.acquire_register(reg_name=5)
code.add(prgm.get_label("FOO"))
code.add(spu.il(foo, 0xCAFE))
code.add(spu.ilhu(reg, 0xDEAD))
code.add(spu.iohl(reg, 0xBEEF))
code.add(spu.stqd(reg, code.r_zero, 4))
lbl_loop = prgm.get_label("LOOP")
lbl_break = prgm.get_label("BREAK")
r_cnt = code.gp_return
r_stop = prgm.acquire_register(reg_name=9)
r_cmp = prgm.acquire_register()
code.add(spu.ori(r_cnt, code.r_zero, 0))
code.add(spu.il(r_stop, 5))
code.add(lbl_loop)
code.add(spu.ceq(r_cmp, r_cnt, r_stop))
code.add(spu.brnz(r_cmp, prgm.get_label("BREAK")))
code.add(spu.ai(r_cnt, r_cnt, 1))
code.add(spu.br(prgm.get_label("LOOP")))
code.add(lbl_break)
app = SPUApp(code)
app.MainLoop()
code = prgm.get_stream()
reg = prgm.acquire_register()
foo = prgm.acquire_register(reg_name = 5)
code.add(prgm.get_label("FOO"))
code.add(spu.il(foo, 0xCAFE))
code.add(spu.ilhu(reg, 0xDEAD))
code.add(spu.iohl(reg, 0xBEEF))
code.add(spu.stqd(reg, code.r_zero, 4))
lbl_loop = prgm.get_label("LOOP")
lbl_break = prgm.get_label("BREAK")
r_cnt = code.gp_return
r_stop = prgm.acquire_register(reg_name = 9)
r_cmp = prgm.acquire_register()
code.add(spu.ori(r_cnt, code.r_zero, 0))
code.add(spu.il(r_stop, 5))
code.add(lbl_loop)
code.add(spu.ceq(r_cmp, r_cnt, r_stop))
code.add(spu.brnz(r_cmp, prgm.get_label("BREAK")))
code.add(spu.ai(r_cnt, r_cnt, 1))
code.add(spu.br(prgm.get_label("LOOP")))
code.add(lbl_break)
app = SPUApp(code)
app.MainLoop()
