diff --git a/libraries/base/reorder/tb/python/tc_reorder_transpose.py b/libraries/base/reorder/tb/python/tc_reorder_transpose.py
index d5ebd7e144b399a4cc16a41fa7054020c6569cc1..e6ebdfe64bd987a0c2e7c3b782b624d8c95910ad 100644
--- a/libraries/base/reorder/tb/python/tc_reorder_transpose.py
+++ b/libraries/base/reorder/tb/python/tc_reorder_transpose.py
@@ -60,29 +60,31 @@ tc = test_case.Testcase('TB - ', '')
# Constants/Generics that are shared between VHDL and Python
# Name Value Default Description
# START_VHDL_GENERICS
-g_wr_chunksize = 64
+g_wr_chunksize = 16
g_wr_nof_chunks = 1
-g_rd_chunksize = 16
-g_rd_nof_chunks = 4
+g_rd_chunksize = 4
+g_rd_nof_chunks = 4
+g_rd_interval = 4
g_gapsize = 0
-g_nof_blocks = 4
-g_nof_blk_per_sync = 64
+g_nof_blocks = 32
+g_nof_blk_per_sync = 32
# END_VHDL_GENERICS
# Overwrite generics with argumented generics from autoscript or command line.
if tc.generics != None:
g_wr_chunksize = tc.generics['g_wr_chunksize']
- g_wr_nof_chunks = tc.generics['g_wr_nof_chunks']
g_rd_chunksize = tc.generics['g_rd_chunksize']
g_rd_nof_chunks = tc.generics['g_rd_nof_chunks']
+ g_rd_interval = tc.generics['g_rd_interval']
g_gapsize = tc.generics['g_gapsize']
g_nof_blocks = tc.generics['g_nof_blocks']
g_nof_blk_per_sync = tc.generics['g_nof_blk_per_sync']
-c_blocksize = (g_wr_chunksize + g_gapsize) * g_wr_nof_chunks
+c_blocksize = (g_wr_chunksize + g_gapsize)
c_pagesize = c_blocksize * g_nof_blocks
+c_rd_increment = g_rd_interval * c_blocksize
c_bg_nof_streams = 4
-c_bg_ram_size = g_wr_chunksize * g_wr_nof_chunks * g_rd_chunksize
+c_bg_ram_size = g_wr_chunksize * g_nof_blocks
c_in_dat_w = 8
c_db_nof_streams = c_bg_nof_streams
c_db_ram_size = c_bg_ram_size #g_rd_chunksize * g_rd_nof_chunks * g_nof_blocks
@@ -117,20 +119,36 @@ ss = pi_ss_ss_wide.PiSsSsWide (tc, io, c_frame_size*g_rd_chunksize, c_nof_int_st
dsp_test_bg = dsp_test.DspTest(inDatW=c_in_dat_w)
# Function for generating stimuli and generating hex files.
-def gen_bg_hex_files(c_nof_values = 1024, c_nof_streams = 4):
+#def gen_bg_hex_files(c_nof_values = 1024, c_nof_streams = 4):
+# data = []
+# for i in range(c_nof_streams):
+# stream_re = []
+# stream_im = []
+# for j in range(c_nof_values):
+# stream_re.append(j)
+# stream_im.append(i)
+# data_concat = dsp_test_bg.concatenate_two_lists(stream_re, stream_im, c_in_dat_w)
+# data.append(data_concat)
+# filename = "../../src/hex/tb_bg_dat_" + str(i) + ".hex"
+# mem_init_file.list_to_hex(list_in=data_concat, filename=filename, mem_width=c_nof_complex*c_in_dat_w, mem_depth=2**(ceil_log2(c_bg_ram_size)))
+# return data
+
+def gen_bg_hex_files(c_framesize = 64, c_nof_frames = 32, c_nof_streams = 4):
data = []
for i in range(c_nof_streams):
stream_re = []
stream_im = []
- for j in range(c_nof_values):
- stream_re.append(j)
- stream_im.append(i)
+ for j in range(c_nof_frames):
+ for k in range(c_framesize):
+ stream_re.append(k)
+ stream_im.append(j)
data_concat = dsp_test_bg.concatenate_two_lists(stream_re, stream_im, c_in_dat_w)
data.append(data_concat)
filename = "../../src/hex/tb_bg_dat_" + str(i) + ".hex"
mem_init_file.list_to_hex(list_in=data_concat, filename=filename, mem_width=c_nof_complex*c_in_dat_w, mem_depth=2**(ceil_log2(c_bg_ram_size)))
return data
+
if __name__ == "__main__":
###############################################################################
#
@@ -153,7 +171,7 @@ if __name__ == "__main__":
#
###############################################################################
# Prepare x stimuli for block generator
- bg_data = gen_bg_hex_files(c_bg_ram_size, c_bg_nof_streams)
+ bg_data = gen_bg_hex_files(c_frame_size, g_nof_blocks, c_bg_nof_streams)
################################################################################
##
@@ -191,14 +209,6 @@ if __name__ == "__main__":
do_until_gt(io.simIO.getSimTime, ms_retry=1000, val=180000, s_timeout=13600) # 110000
bg.write_block_gen_settings(samplesPerPacket=c_frame_size, blocksPerSync=g_nof_blk_per_sync-1, gapSize=c_gap_size, memLowAddr=0, memHighAddr=c_bg_ram_size-1, BSNInit=10)
- #do_until_gt(io.simIO.getSimTime, ms_retry=1000, val=182000, s_timeout=13600) # 110000
- #bg.write_enable()
- #
- #do_until_gt(io.simIO.getSimTime, ms_retry=1000, val=120000, s_timeout=13600) # 110000
- #bg.write_disable()
- #do_until_gt(io.simIO.getSimTime, ms_retry=1000, val=140000, s_timeout=13600) # 110000
- #bg.write_enable()
-
###############################################################################
#
# Calculate reference data
@@ -206,34 +216,35 @@ if __name__ == "__main__":
###############################################################################
# Subband Select pre-transpose
if c_ena_pre_transpose:
- bg_data = ss.subband_select(bg_data, ss_list)
+ bg_data_ss =[]
+ for i in range(len(bg_data)/len(ss_list)):
+ bg_data_ss.append(ss.subband_select(bg_data[i*len(ss_list):(i+1)*len(ss_list)], ss_list))
+ bg_data = bg_data_ss
+ bg_data = flatten(bg_data)
ref_data_total = []
- # Check how many data there is and how many pages will be used:
+ # Check how many data there is and how many pages will be used:
for t in range(len(bg_data)/c_pagesize):
bg_data_single_page = bg_data[t*c_pagesize:(t+1)*c_pagesize]
# Write to memory
mem_page = [0] * c_pagesize
for i in range(g_nof_blocks):
- for j in range(g_wr_nof_chunks):
- for k in range(g_wr_chunksize):
- mem_page[i*c_blocksize*g_wr_nof_chunks + j*c_blocksize + k] = bg_data_single_page[i*g_wr_chunksize*g_wr_nof_chunks + j*g_wr_chunksize + k]
+ for j in range(g_wr_chunksize):
+ mem_page[i*c_blocksize + j] = bg_data_single_page[i*g_wr_chunksize + j]
# Read from memory
ref_data = [0] * g_nof_blocks * g_rd_nof_chunks * g_rd_chunksize
- chunk_cnt = 0
- chunk_offset = 0
- for i in range(g_nof_blocks):
- for j in range(g_rd_nof_chunks):
- if chunk_cnt == g_nof_blocks:
- chunk_cnt = 0
- chunk_offset = chunk_offset + 1
- for k in range(g_rd_chunksize):
- #ref_data[chunk_cnt*(g_rd_chunksize*g_rd_nof_chunks)+ chunk_offset*g_rd_chunksize + k] = mem_page[chunk_cnt*(g_rd_chunksize*g_rd_nof_chunks+g_gapsize)+ chunk_offset*g_rd_chunksize + k]
- ref_data[i*(g_rd_chunksize*g_rd_nof_chunks)+j*g_rd_chunksize + k] = mem_page[chunk_cnt*(g_rd_chunksize*g_rd_nof_chunks+g_gapsize)+ chunk_offset*g_rd_chunksize + k]
- chunk_cnt = chunk_cnt + 1
+ rd_block_offset = 0
+ rd_chunk_offset = 0
+ for i in range(g_nof_blocks*g_rd_nof_chunks):
+ rd_offset = rd_block_offset + rd_chunk_offset
+ for k in range(g_rd_chunksize):
+ ref_data[i*g_rd_chunksize + k] = mem_page[rd_offset + k]
+ rd_block_offset = rd_block_offset + c_rd_increment
+ if(rd_block_offset >= c_pagesize):
+ rd_chunk_offset = rd_chunk_offset + g_rd_chunksize
+ rd_block_offset = rd_block_offset - c_pagesize
ref_data_total.append(ref_data)
-
ref_data_total=flatten(ref_data_total)
# Split the data again in individual channels
@@ -303,3 +314,5 @@ if __name__ == "__main__":
sys.exit(tc.get_result())
+
+