fixed a leak

.gitignore

@@ -5,4 +5,5 @@ __pycache__
 *.#*
 #*#
 *.pyc
+*.pyo
 .spyproject

components/tupleconv.py

@@ -4,6 +4,7 @@ Created on Wed May  2 15:57:55 2018
 
 @author: Magnus Rentsch Ersdal (magnus.ersdal@uib.no)
 """
+
 def foo2(tuples):
     '''make a list of tuples of (int, length) into a list of 32 bit integers [1,2,3]'''
 #    binarylist = "".join([np.binary_repr(a, b) for a, b in inp]) # bin(a)[2:].rjust(b, '0')
@@ -26,37 +27,69 @@ def tpli_2_32ili(tuples):
         size = size + remlen
         remn = 0
         remlen = 0
-    #    if size%32 == 0 and size > 0:
-    #        n32 = int (size/32)
-    #        # easy case.
-    #        [liol.append((num >> (i*32) & 0xffffffff)) for i in reversed(range(n32))]
-    ##        [liol.append(((num >> (i*32) & 0xffffffff), 32)) for i in reversed(range(n32))]
-    #            
+      
         if size > 32:
             n32 = int(size/32)
-            # size is larger than 32... where is the carry?
             remlen = size - (n32*32)
-    #        print(remlen)
             if remlen:
                 remn = num & int("1"*remlen,2)
             tnum = num >> remlen
             
-#            [liol.append(tnum >> (i*32) & 0xffffffff) for i in reversed(range(n32))]
             for i in reversed(range(n32)):
                 liol.append(tnum >> (i*32) & 0xffffffff)
                 
-    #        liol.append((remn,remlen))
         else:
             remn = num
             remlen = size
-    #        liol.append((remn,remlen))
     return liol, remn, remlen
 
-#if __name__== '__main__':
-#    foo = tpli_2_32ili
-##    tv = [(0,128),(1,12),(0,32),(0xFF,8),(1,32),(1,32)]
-##    tv = [(0,32),(0xff,8),(1,32)]
-##    tv = [(0xff,128),(1,12),(0,32),(0xFF,8),(2,32),(5,32)]
+
+def listof32s_append_tuplelist(liol,tuples):
+    """make a list (liol) of 32 bit integers (implicit), from the explicit tuples [(number,binlength)]"""
+    remn = 0
+    remlen = 0
+#    print(tuples)
+    for num, size in tuples:
+        if size == 0:
+            pass
+        else:
+            num = (remn << size) | num
+            size = size + remlen
+            remn = 0
+            remlen = 0
+          
+            if size > 32:
+                n32 = int(size/32)
+                remlen = size - (n32*32)
+                if remlen:
+                    remn = num & int("1"*remlen,2)
+                tnum = num >> remlen
+                
+                for i in reversed(range(n32)):
+                    liol.append(tnum >> (i*32) & 0xffffffff)
+                    
+            else:
+                remn = num
+                remlen = size
+    if remlen:
+        tuples = [(remn,remlen)]
+    else:
+        tuples = []
+    
+#    print("gave")
+#    print(liol)
+    return tuples
+#    return liol, remn, remlen
+
+
+if __name__== '__main__':
+    import cProfile
+    import pstats
+    foo = tpli_2_32ili
+#    tv = [(0,128),(1,12),(0,32),(0xFF,8),(1,32),(1,32)]
+#    tv = [(0,32),(0xff,8),(1,32)]
+    tv = [(0xff,128),(1,12),(0,32),(0xFF,8),(2,32),(5,32)]
 #    tv = [(1,12),(0,32)]
-#    print("test:",foo(tv))
-#    print("ref: ",foo2(tv))
\ No newline at end of file
+    print("test:",foo(tv))
+    print("ref: ",foo2(tv))
+    cProfile.run('for i in range(50000): foo(tv)',sort='tottime')
\ No newline at end of file

hwdriver/SCA.py

@@ -65,7 +65,7 @@ class Sca (Utils, Roc):
         
         time = self.rocRd(self.rd_add_mon, debug)
         time = time & 0xffff
-        #print('WR - DATA %10s CH %4s TR %4s CMD %4s TIME %d' % (hex(data), hex(self.cmd >> 24),  hex((self.cmd >> 16) & 0xff), hex(self.cmd & 0xff), time))
+#        print('WR - DATA %10s CH %4s TR %4s CMD %4s TIME %d' % (hex(data), hex(self.cmd >> 24),  hex((self.cmd >> 16) & 0xff), hex(self.cmd & 0xff), time))
     #--------------------------------------------------------------------------------
     def wr_fast(self, cmd, data, trid):
         self.cmd = (cmd & 0xff00ffff) | (trid << 16)

jtag_if/jtag_io.py

@@ -41,21 +41,35 @@ def read128(sca):
     datastring = s.join(data)
     return datastring
 
+class trid():
+    def __init__(self):
+        self.trid = 1
+    def get(self):
+        tmp = self.trid
+        self.trid +=1
+        if self.trid == 0xff:
+            self.trid = 1
+        return tmp
+
+T = trid()
+
 def read_4_ints(sca):
     data=[]
+    tmp = T.get()
     for reg in settings.TDIregs: # naming of SCA regs is incoherent with the svf standard
-        sca.wr(cmd = reg, data = 0)
+        sca.wr(cmd = reg, data = 0, trid=tmp) # provide TRID
         data.append(sca.read_data())
     return data
 
 def write_4_ints(tms_list, tdi_list, sca):
+    tmp = T.get()
     for reg, data in zip(TMSregs,tms_list):
-        sca.wr(reg,data)
+        sca.wr(reg,data,tmp)
     for reg, data in zip(TDOregs,tdi_list):
-        sca.wr(reg,data)
+        sca.wr(reg,data,tmp)
 #    print("writing list {}".format(tms_list))
 #    emap(sca.wr, tms_tdi_list, tms_list + tdi_list) # did not play nice with C interface
 #    for tmsreg, tdireg, tmsdata, tdidata in zip(TMSregs,TDOregs,tms_list,tdi_list):
 #        sca.wr(tmsreg,tmsdata)
 #        sca.wr(tdireg,tdidata)
-    sca.wr(SCARegs['JTAG_GO'], 0)
+    sca.wr(SCARegs['JTAG_GO'], 0,tmp)

jtag_if/jtag_sequencer.py

@@ -7,7 +7,7 @@ Created on Fri Apr  6 11:28:43 2018
 
  
 from jtag_if.jtag_io import write128, read128, write_4_ints, read_4_ints
-from components.tupleconv import tpli_2_32ili
+from components.tupleconv import tpli_2_32ili, listof32s_append_tuplelist
  
 FIFOLEN = 128
 
@@ -38,13 +38,16 @@ class Seq():
 
     def check_t_run(self):
         if (len(self.tms_32ints) >= 4) or (self.qlength >= FIFOLEN):
-            tuple_list_to_32int_list(self.tms_32ints, self.tms_tuples)
+            self.tms_tuples = listof32s_append_tuplelist(self.tms_32ints, self.tms_tuples)
 #            tms_i32list, mri, mrl = tpli_2_32ili(self.tms_tuples) # factor out 32bit ints
 #            self.tms_tuples = [] # clear 
 #            self.tms_32ints += tms_i32list  # append the sorted 
 #            self.tms_tuples.append((mri,mrl))
-            tuple_list_to_32int_list(self.tdi_32ints, self.tdi_tuples)
-            
+#            print("tdi before:")
+#            print(self.tdi_tuples)
+#            tuple_list_to_32int_list(self.tdi_32ints, self.tdi_tuples)
+            self.tdi_tuples = listof32s_append_tuplelist(self.tdi_32ints, self.tdi_tuples)
+#            print("tdi after:")
             self.qlength = sum([i[1] for i in self.tms_tuples]) # needs update
 #            tdi_i32list, dri, drl = tpli_2_32ili(self.tdi_tuples)
 #            self.tdi_tuples= [] # clear
@@ -53,7 +56,7 @@ class Seq():
             # all our lists are now updated.
             l32len = len(self.tdi_32ints)
             l128 = int(l32len/4)
-            lrem = l128 * 4 - l32len
+#            lrem = l128 * 4 - l32len
             # right from left: a[:-10:-1] left from right : a[-9:]
             ### the loop starts here:
             rangesel = 4
@@ -108,24 +111,26 @@ class Seq():
         
     def end_clean(self):
         """write out any remaining bits"""
-        self.check_to_run(len(self.tms_bits))
-        length = len(self.tms_bits) # guaranteed to be between 0 and FIFOLEN-1
-        if length > 0: # fill with zeros
-            self.tms_bits += "0" * (FIFOLEN - length)
-            self.tdi_bits += "0" * (FIFOLEN - length)
-            self.check_to_run(len(self.tms_bits))
-        else:
-            pass
+        self.flush_tqueue()
+#        self.check_to_run(len(self.tms_bits))
+#        length = len(self.tms_bits) # guaranteed to be between 0 and FIFOLEN-1
+#        if length > 0: # fill with zeros
+#            self.tms_bits += "0" * (FIFOLEN - length)
+#            self.tdi_bits += "0" * (FIFOLEN - length)
+#            self.check_to_run(len(self.tms_bits))
+#        else:
+#            pass
         print("sequencer complete")
         
 def andlist(list1, list2): 
     return list(map(lambda x,y: x & y, list1, list2))
 
-def tuple_list_to_32int_list(list_32i, tuplelist):
-    tmp_32list, tmp_remi, temp_reml = tpli_2_32ili(tuplelist) #sort
-    tuplelist = [] # clear
-    list_32i += tmp_32list # append items
-    tuplelist.append((tmp_remi, temp_reml)) # append item
+#def tuple_list_to_32int_list(list_32i, tuplelist):
+#    list_32i, tuplelist = listof32s_append_tuplelist(list_32i, tuplelist)
+#    tmp_32list, tmp_remi, temp_reml = tpli_2_32ili(tuplelist) #sort
+#    tuplelist = [] # clear
+#    list_32i += tmp_32list # append items
+#    tuplelist.append((tmp_remi, temp_reml)) # append item
 
 #def tpli_2_32ili(tuples):
 #    '''make a list of tuples of (int, length) into a list of 32 bit integers [1,2,3]'''

test_whole_list_with_logging.py

@@ -29,13 +29,9 @@ import svf_intepreter as interpreter
 from stopwatch import Stopwatch
 from svf_separate_commands import read_svf
 from hwdriver.SCA import Sca
-from jtag_if.jtag_io import read128
 import copy
-import settings
-import jtag_if.jtag_ctrl
 import sys
 
-sys.setrecursionlimit(int(10e6))
 
 #settings.init()
 def space():
@@ -45,12 +41,12 @@ def space():
 def littlespace():
     print("------")
 
-li = read_svf("p_reduced.svf") #("idcode.svf")#("../p_400klines.svf")#("../p_reduced.svf")
+listone = read_svf("p.svf") #("idcode.svf")#("../p_400klines.svf")#("../p_reduced.svf")
 # operation completed in 4 minutes 27.190409 seconds for 200klines with delays. 
 # operation completed in 4 minutes 56.811993 seconds for 400klines with delays.
 # operation completed in 8 minutes 8.541882 seconds
 # operation completed in 2 minutes 30.999758 seconds with no delays.. .
-listone = copy.deepcopy(li)
+#listone = copy.deepcopy(li)
 totlen = len(listone)
 totpc = totlen / 100
 if totpc < 1: