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) spu.stqx(r_data, r_cnt, r_lsa) spu.ai(r_cnt, r_cnt, 16) spu.ceq(r_cmp, r_cnt, r_sum) spu.brz(r_cmp, lbl_incloop) dma.spu_write_out_mbox(code, code.r_zero) prgm += code t3 = time.time() id = proc.execute(prgm, async = True, mode = 'int') t1 = time.time() for i in xrange(0, ITERS): #env.spu_exec.write_in_mbox(id, 1) #env.spu_exec.write_in_mbox(id, 1) env.spu_exec.write_in_mbox(id, i) #cnt = env.spu_exec.stat_in_mbox(id) #print "cnt %x" % cnt
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) spu.stqx(r_data, r_cnt, r_lsa) spu.ai(r_cnt, r_cnt, 16) spu.ceq(r_cmp, r_cnt, r_sum) spu.brz(r_cmp, lbl_incloop) dma.spu_write_out_mbox(code, code.r_zero) prgm += code t3 = time.time() id = proc.execute(prgm, async=True, mode='int') t1 = time.time() for i in xrange(0, ITERS): #env.spu_exec.write_in_mbox(id, 1) #env.spu_exec.write_in_mbox(id, 1) env.spu_exec.write_in_mbox(id, i) #cnt = env.spu_exec.stat_in_mbox(id) #print "cnt %x" % cnt #cnt = env.spu_exec.stat_out_mbox(id)
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. import corepy.arch.spu.isa as spu import corepy.arch.spu.platform as env import corepy.arch.spu.lib.dma as dma from corepy.arch.spu.lib.util import load_word code = env.InstructionStream() proc = env.Processor() # Grab a register and initialize it reg = code.acquire_register() load_word(code, reg, 0xCAFEBABE) # Write the value to the outbound mailbox dma.spu_write_out_mbox(code, reg) # Wait for a signal sig = dma.spu_read_signal1(code) code.release_register(sig) code.release_register(reg) # Start the synthesized SPU program id = proc.execute(code, async=True) # Spin until the mailbox can be read while env.spu_exec.stat_out_mbox(id) == 0: pass value = env.spu_exec.read_out_mbox(id)
import corepy.arch.spu.isa as spu import corepy.arch.spu.platform as env import corepy.arch.spu.lib.dma as dma from corepy.arch.spu.lib.util import load_word prgm = env.Program() code = prgm.get_stream() proc = env.Processor() # Grab a register and initialize it reg = prgm.acquire_register() load_word(code, reg, 0xCAFEBABE) # Write the value to the outbound mailbox dma.spu_write_out_mbox(code, reg) # Wait for a signal sig = dma.spu_read_signal1(code) prgm.release_register(sig) prgm.release_register(reg) prgm.add(code) # Start the synthesized SPU program id = proc.execute(prgm, async = True) # Spin until the mailbox can be read while env.spu_exec.stat_out_mbox(id) == 0: pass
def MemoryDescExample(data_size=20000): """ This example uses a memory descriptor to move 20k integers back and forth between main memory and the SPU local store. Each value is incremented by 1 while on the SPU. Memory descriptors are a general purpose method for describing a region of memory. Memory is described by a typecode, address, and size. Memory descriptors can be initialized by hand or from an array or buffer object. For main memory, memory descriptors are useful for transfering data between main memory and an SPU's local store. The get/put methods on a memory descriptor generate the SPU code to move data of any size between main memory and local store. Memory descriptors can also be used with spu_vec_iters to describe the region of memory to iterate over. The typecode in the memory descriptor is used to determine the type for the loop induction variable. Note that there is currently no difference between memory descriptors for main memory and local store. It's up to the user to make sure the memory descriptor settings make sense in the current context. (this will probably change in the near future) Note: get/put currently use loops rather than display lists for transferring data over 16k. """ code = InstructionStream() proc = Processor() code.debug = True spu.set_active_code(code) # Create a python array data = extarray.extarray('I', range(data_size)) # Align the data in the array #a_data = aligned_memory(data_size, typecode = 'I') #a_data.copy_to(data.buffer_info()[0], data_size) # Create memory descriptor for the data in main memory data_desc = memory_desc('I') #data_desc.from_array(a_data) data_desc.from_array(data) # Transfer the data to 0x0 in the local store data_desc.get(code, 0) # Create memory descriptor for the data in the local store for use # in the iterator lsa_data = memory_desc('i', 0, data_size) # Add one to each value for x in spu_vec_iter(code, lsa_data): x.v = x + 1 # Transfer the data back to main memory data_desc.put(code, 0) dma.spu_write_out_mbox(code, 0xCAFE) # Execute the synthetic program # code.print_code() spe_id = proc.execute(code, async=True) proc.join(spe_id) # Copy it back to the Python array #a_data.copy_from(data.buffer_info()[0], data_size) for i in xrange(data_size): assert (data[i] == i + 1) return
def MemoryDescExample(data_size = 20000): """ This example uses a memory descriptor to move 20k integers back and forth between main memory and the SPU local store. Each value is incremented by 1 while on the SPU. Memory descriptors are a general purpose method for describing a region of memory. Memory is described by a typecode, address, and size. Memory descriptors can be initialized by hand or from an array or buffer object. For main memory, memory descriptors are useful for transfering data between main memory and an SPU's local store. The get/put methods on a memory descriptor generate the SPU code to move data of any size between main memory and local store. Memory descriptors can also be used with spu_vec_iters to describe the region of memory to iterate over. The typecode in the memory descriptor is used to determine the type for the loop induction variable. Note that there is currently no difference between memory descriptors for main memory and local store. It's up to the user to make sure the memory descriptor settings make sense in the current context. (this will probably change in the near future) Note: get/put currently use loops rather than display lists for transferring data over 16k. """ code = env.InstructionStream() proc = env.Processor() code.debug = True spu.set_active_code(code) # Create a python array data = extarray.extarray('I', range(data_size)) # Align the data in the array #a_data = aligned_memory(data_size, typecode = 'I') #a_data.copy_to(data.buffer_info()[0], data_size) # Create memory descriptor for the data in main memory data_desc = memory_desc('I') #data_desc.from_array(a_data) data_desc.from_array(data) # Transfer the data to 0x0 in the local store data_desc.get(code, 0) # Create memory descriptor for the data in the local store for use # in the iterator lsa_data = memory_desc('i', 0, data_size) # Add one to each value for x in spu_vec_iter(code, lsa_data): x.v = x + 1 # Transfer the data back to main memory data_desc.put(code, 0) dma.spu_write_out_mbox(code, 0xCAFE) # Execute the synthetic program # code.print_code() spe_id = proc.execute(code, async=True) proc.join(spe_id) # Copy it back to the Python array #a_data.copy_from(data.buffer_info()[0], data_size) for i in xrange(data_size): assert(data[i] == i + 1) return