changed to integers

jtag_if/jtag_ctrl.py

@@ -13,6 +13,7 @@ from settings import FIFOLEN, FREQUENCY, highTMS_bin_zip
 #sca = settings.sca
 #jtg_seq
 
+
 class Control():
     def __init__(self,logger, sca):
         global z
@@ -69,9 +70,13 @@ class Control():
         #        print("GO!")
         # check this with version number and sca manual
         self.sca.wr(SCARegs['JTAG_GO'], 0)
-        
+    
+    waitcounter = 0
+    waitcycles_total = 0      
+  
     def wait(self, duration, tckorsec: str = "TCK", waitstate = 'IDLE'):
         """Wait for n clock cycles"""
+        waitcounter += 1
         n_clk_waits = 0
         if tckorsec == 'SEC':
             n_clk_waits = int(duration * FREQUENCY)
@@ -83,10 +88,24 @@ class Control():
 #        print("length is  {}".format(self.fifo_len))o
 #        if n_clk_waits > 3000000000 :
 #            n_clk_waits = 3000000000
+        waitcycles_total += n_clk_waits
+        print("waiting, tot:",waitcounter ,":", waitcycles_total)
+        n_32s = int(n_clk_waits/32)
+        remwaits = n_clk_waits%32
         if waitstate == 'RESET':
-            self.wait_tms_high(n_clk_waits)
+            tmstuples = [(0xFFFFFFFF, 32)] * n_32s
+            tdituples = [(0,32)] * n_32s
+            if remwaits:
+                tmstuples.append((int("1"*remwaits, 2), remwaits))
+                tdituples.append((0, remwaits))
+            self.jtg_seq.tqueue(tmstuples, tdituples)
+#            self.wait_tms_high(n_clk_waits)
         else:
-            self.wait_all_low(n_clk_waits)
+            tuples = [(0,32)] * n_32s
+            if remwaits:
+                tuples.append((0, remwaits))
+            self.jtg_seq.tqueue(tuples, tuples)
+#            self.wait_all_low(n_clk_waits)
 #max = 300 -> peration completed in 0 minutes 11.914192 seconds
 #max = 3000 -> operation completed in 0 minutes 12.363895 seconds
 #max = 300_000 -> operation completed in 0 minutes 32.411803 seconds
@@ -95,14 +114,18 @@ class Control():
 # unlimited -> 
 
     def wait_all_low(self,n_clk_waits):
-        n_runs = int(n_clk_waits / FIFOLEN)
+        n_runs = int(n_clk_waits / (FIFOLEN*10))
+        remainder = n_clk_waits % (FIFOLEN*10)
         for i in range(n_runs):
-            self.jtg_seq.queue("0"*FIFOLEN,"0"*FIFOLEN)
+            self.jtg_seq.queue("0"*(FIFOLEN*10),"0"*(FIFOLEN*10))
+        self.jtg_seq.queue("1"*remainder,"0"*remainder)
   
     def wait_tms_high(self,n_clk_waits):
-        n_runs = int(n_clk_waits / self.fifo_len)
+        n_runs = int(n_clk_waits / (FIFOLEN*10))
+        remainder = n_clk_waits % (FIFOLEN*10)
         for i in range(n_runs):
-            self.jtg_seq.queue("1"*FIFOLEN,"0"*FIFOLEN)
+            self.jtg_seq.queue("1"*(FIFOLEN*10),"0"*(FIFOLEN*10))
+        self.jtg_seq.queue("1"*remainder,"0"*remainder)
 #            for reg, data in highTMS_bin_zip:
 #                self.sca.wr(reg, data)
 #                self.jtg_seq.queue(reg, data)

jtag_if/jtag_io.py

@@ -10,32 +10,37 @@ from SCARegs import SCARegs
 from zmqsender_config import Errlvl
 import settings
 #z = settings.z
-
+TMSregs = settings.TMSregs
+TDOregs = settings.TDOregs
+TDIregs = settings.TDIregs
 
 zeros = "0" * 32
 
+myi = int # tiny speedup
+
+def b2i(bstring):
+    return int(bstring,2)
+def emap(func, *iterables):
+    return list(map(func, *iterables))
+
 def write128(tms_bits, tdi_bits, sca):
 #    print("writing tms:{} tdi:{}".format(tms_bits, tdi_bits))
-    tms_list = [tms_bits[0:32], tms_bits[32:64], tms_bits[64:96], tms_bits[96:128]]
-    tdi_list = [tdi_bits[0:32], tdi_bits[32:64], tdi_bits[64:96], tdi_bits[96:128]]
-    for reg,data in zip(settings.TMSregs, tms_list):
-        if data == zeros:
-            pass
-        else:
-            sca.wr(cmd=reg, data =int(data,2))
-    for reg,data in zip(settings.TDOregs, tdi_list):
-        if data == zeros:
-            ## performance optimization
-            pass
-        else:
-            sca.wr(cmd=reg, data =int(data,2))
+    tms_list = [b2i(tms_bits[0:32]), b2i(tms_bits[32:64]), b2i(tms_bits[64:96]), b2i(tms_bits[96:128])]
+    tdi_list = [b2i(tdi_bits[0:32]), b2i(tdi_bits[32:64]), b2i(tdi_bits[64:96]), b2i(tdi_bits[96:128])]
+    # map sca.wr to registers and data. ideally faster than a for loop. 
+    emap(sca.wr, TMSregs, tms_list)
+    emap(sca.wr, TDOregs, tdi_list)
+#    for reg,data in zip(TMSregs, tms_list):
+#        sca.wr(cmd=reg, data =int(data,2))
+#        sca.wr(cmd = reg, data = data)
+#    for reg,data in zip(TDOregs, tdi_list):
+#        sca.wr(cmd=reg, data = data)
             
     sca.wr(SCARegs['JTAG_GO'], 0)
-    pass
 
 def read128(sca):
     data=[]
-    for reg in settings.TDIregs: # naming of SCA regs is incoherent with the svf standard
+    for reg in TDIregs: # naming of SCA regs is incoherent with the svf standard
         sca.wr(cmd = reg, data = 0)
         data.append(sca.readbin())
     s=""
@@ -43,21 +48,27 @@ def read128(sca):
     return datastring
 #        data.append(sca.)
     
+def write_4_ints(tms_list, tdi_list, sca):
+    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)
+    
 def write_TMS_zeros(sca, length = 128):
     assert length == 128
-    for reg in settings.TMSregs:
+    for reg in TMSregs:
         sca.wr(cmd=reg, data=0)
         
 def write_128_TDI_zeros(sca):
     """write only TDI bits."""
-    for reg in settings.TDOregs:
+    for reg in TDOregs:
         sca.wr(cmd=reg, data=0)
     sca.wr(SCARegs['JTAG_GO'],0)
 
 def write_128_TDI(tdi_bits, sca):
     """Write only TDI"""
     tdi_list = [tdi_bits[0:32], tdi_bits[32:64], tdi_bits[64:96], tdi_bits[96:128]]
-    for reg, data in zip(settings.TDOregs, tdi_list):
+    for reg, data in zip(TDOregs, tdi_list):
         sca.wr(cmd=reg, data= int(data, 2))
     sca.wr(SCARegs['JTAG_GO'], 0)
     

jtag_if/jtag_sequencer.py

@@ -6,16 +6,25 @@ Created on Fri Apr  6 11:28:43 2018
 """
 
  
-from jtag_if.jtag_io import write128, read128, write_128_TDI
+from jtag_if.jtag_io import write128, read128, write_128_TDI, write_4_ints
  
 FIFOLEN = 128
 
+
 class Seq():
     def __init__(self,sca):
         self.tms_bits = ""
         self.tdi_bits = ""
         self.tdo_bits = [] # store of TDO bits.
         self.sca = sca
+        self.tms_tuples =[]
+        self.tdi_tuples =[]
+        self.tms_32ints =[]
+        self.tdi_32ints =[]
+        self.qlength = 0
+        
+    def w128(self, tms, tdi):
+        write128(tms, tdi, self.sca)
         
     def check_to_run(self,length):
         if length >= FIFOLEN:
@@ -26,14 +35,18 @@ class Seq():
             self.call_run_iter(tms_list, tdi_list)
             
     def call_run_iter(self,tms_list,tdi_list):
-        previous_tms = ""
-        for tms, tdi in zip(tms_list, tdi_list):
-            if tms != previous_tms:
-                write128(tms, tdi, self.sca)
-                previous_tms = tms # this will be loads of zeros in a long wait statement.
-            elif tms == previous_tms:# when tms finally is all zeros or equal the previous 128 bits
-                write_128_TDI(tdi, self.sca)
-            self.tdo_bits.append(read128(self.sca))
+        list(map(self.w128, tms_list, tdi_list))
+#        previous_tms = ""
+#        _ = [write128(tms, tdi, self.sca) for tms, tdi in zip(tms_list, tdi_list)]
+#        for tms, tdi in zip(tms_list, tdi_list):
+#            if tms != previous_tms:
+#                write128(tms, tdi, self.sca)
+#                previous_tms = tms # this will be loads of zeros in a long wait statement.
+#            elif tms == previous_tms:# when tms finally is all zeros or equal the previous 128 bits
+#                write_128_TDI(tdi, self.sca)
+        self.tdo_bits.append(read128(self.sca))
+#        tms_list = []
+#        tdi_list = []
 
     def call_run(self,length):# too long recusion- ! -
         write128(self.tms_bits[:FIFOLEN],self.tdi_bits[:FIFOLEN],self.sca) #write
@@ -41,6 +54,26 @@ class Seq():
         self.tms_bits = self.tms_bits[FIFOLEN:] 
         self.tdi_bits = self.tdi_bits[FIFOLEN:]
         self.check_to_run(length - FIFOLEN)
+        
+    def check_t_run(self):
+        if (len(self.tms_32ints) >= 4) or (self.qlength >= FIFOLEN):
+            tms_i32list, mri, mrl = tpli_2_32ili(self.tms_tuples) # factor out 32bit ints
+            self.tms_tuples = [] # clear 
+            self.tms_32ints.append(tms_i32list) # append the sorted to another list
+            self.tms_tuples.append((mri,mrl))
+            tdi_i32list, dri, drl = tpli_2_32ili(self.tdi_tuples)
+            self.tdi_tuples= []
+            self.tdi_32ints.append(tdi_i32list)
+            self.tdi_tuples.append((dri,drl))
+            # all our lists are now updated.
+            l32len = len(tms_i32list)
+            l128len = l32len/4
+            # right from left: a[:-10:-1] left from right : a[-9:]
+            write_4_ints(self.tms_32ints[-4:], self.tdi_32ints[-4:],sca)
+            self.tms_32ints[-4:] = []
+            self.tdi_32ints[-4:] = []
+            self.qlength -= 128
+
     
     def get_tdo_bits(self):
         m = self.tdo_bits
@@ -53,9 +86,18 @@ class Seq():
     def queue(self, tms_bits, tdi_bits):
         """fill a queue with bits for the JTAG"""
         self.tms_bits += tms_bits
+#        self.tms_bits = "".join([self.tms_bits,tms_bits])
         self.tdi_bits += tdi_bits
+#        self.tdi_bits = "".join([self.tdi_bits,tms_bits])
         self.check_to_run(len(self.tms_bits))
         
+    def tqueue(self, tms_tuples, tdi_tuples):
+        """fill a tuplequeue"""
+        self.tms_tuples.append(tms_tuples)
+        self.tdi_tuples.append(tdi_tuples)
+        self.qlength += sum([])
+        self.check_t_run()
+        
         
     def end_clean(self):
         """write out any remaining bits"""
@@ -77,4 +119,34 @@ def splitstring(string, length=128):
         remaining_string= list_of_strings.pop()
     else:
         remaining_string= ""
-    return list_of_strings, remaining_string
+    return list_of_strings, remaining_string
\ No newline at end of file
+
+def tpli_2_32ili(tuples):
+    prevN=0
+    length = 0
+    remlen = 0
+    remint = 0
+    i32list= []
+    for k in tuples:
+        n = (k[0] << (remlen)) | remint # r1:0, r2:prevN=4,remlen=4
+        print(hex(n))
+        prevN = k[1]
+        length += prevN
+        if length > 32:
+            len32 = int(floor(length/32))
+            for i in range(len32):
+                i32list.append((n >> i*32) & 0xFFFFFFFF)
+            remint = n >> (len32*32)
+            remlen = length - len32*32
+            length -= len32*32
+        elif length == 32:
+            appint = n & 0xFFFFFFFF
+            remint = 0
+            remlen = 0
+            length -= 32
+            i32list.append(appint)
+        else:
+            remint = n
+            remlen = length
+#    i32list.append(remint)
+    return i32list, remint, remlen
\ No newline at end of file

svf_intepreter.py

@@ -24,14 +24,19 @@ from settings import jtg_tp #jtg_seq
 #from jtag_if.jtag_
 #z = settings.z
 
+def get_int_and_b_len(binstring):
+    return int(binstring, 2), len(binstring)
 
-class jsignal(str):
+
+
+class jsignal():
     def __init__(self):
         self.D = ""
         self.MASK = ""
         self.SMASK = ""
         self.DO = ""
         self.ActualData = ""
+        self.length = 0
 
     def get(self):
         return self.D
@@ -68,48 +73,81 @@ class bussequencer():
     def clearbus(self):
         self.bus = jbus()
 
-    def scan_dr(self):
-#        self.jtg.scan_dr(self.bus.HDR.D, self.bus.SDR.D,
-#                         self.bus.TDR.D, self.ENDDR)
-        tdi_d_s = (self.bus.HDR.D 
-                 + self.bus.SDR.D
-                 + self.bus.TDR.D)
-        tms_s_a = jtg_tp.state_change('DRSHIFT')
-        tms_s_b = jtg_tp.state_change(self.ENDDR) # TODO  possible bug. we might want to continue to add data.
-#When the TAP controller is in SHIFT(DR/IR) state and a rising edge is applied to TCK, the controller either enters 
-#the Exit1-DR state if TMS is held at 1 or remains in the Shift-DR state if TMS is held at 0.
-# The last shift of the test data register occurs on this same rising edge.        
-        tms_s = (tms_s_a
-            + "0" * (len(tdi_d_s)-1)
-            + tms_s_b) # end-state
+#    def scan_dr(self):
+##        self.jtg.scan_dr(self.bus.HDR.D, self.bus.SDR.D,
+##                         self.bus.TDR.D, self.ENDDR)
+#        tdi_d_s = (self.bus.HDR.D 
+#                   + self.bus.SDR.D
+#                   + self.bus.TDR.D)
+#        tms_s_a = jtg_tp.state_change('DRSHIFT')
+#        tms_s_b = jtg_tp.state_change(self.ENDDR) # TODO  possible bug. we might want to continue to add data.
+##When the TAP controller is in SHIFT(DR/IR) state and a rising edge is applied to TCK, the controller either enters 
+##the Exit1-DR state if TMS is held at 1 or remains in the Shift-DR state if TMS is held at 0.
+## The last shift of the test data register occurs on this same rising edge.        
+#        tms_s = (tms_s_a
+#                 + "0" * (len(tdi_d_s)-1)
+#                 + tms_s_b) # end-state
+#        
+#        tdi_s = ("0" * len(tms_s_a)
+#                + tdi_d_s
+#                + "0" * (len(tms_s_b)-1)
+#                )
+#        
+#        self.jtg_seq.queue(tms_s, tdi_s) # queues bit sequence...
+    def scan_dr(self):        
+        tdi_d_a = (self.bus.HDR.D, self.bus.HDR.length)
+        tdi_d_b = (self.bus.SDR.D, self.bus.SDR.length)
+        tdi_d_c = (self.bus.TDR.D, self.bus.TDR.length)
+        tdi_d_len = self.bus.HDR.length + self.bus.SDR.length + self.bus.TDR.length
         
-        tdi_s = ("0" * len(tms_s_a)
-                + tdi_d_s
-                + "0" * (len(tms_s_b)-1)
-                )
+        tms_start, tms_start_l = get_int_and_b_len(jtg_tp.state_change('DRSHIFT'))
+        tms_end, tms_end_l = get_int_and_b_len(jtg_tp.state_change(self.ENDDR))
         
-        self.jtg_seq.queue(tms_s, tdi_s) # queues bit sequence...
-
+        # list of tuples with (data,length)
+        tms_tuples= [(tms_start,tms_start_l),(0,(tdi_d_len-1)),(tms_end,tms_end_l)]
+        tdi_tuples= [(0,tms_start_l), tdi_d_a, tdi_d_b, tdi_d_c, (0,(tms_end_l-1))]
+        
+        self.jtg_seq.tqueue(tms_tuples,tdi_tuples)
+
+#        tms32li, remainderd, remainderlen = tpli_2_32ili(tms_tuples)
+#        tdi32li, remtdi, remlentdi = tpli_2_32ili(tdi_tuples)
+
+#    def scan_ir(self):
+##        self.jtg.scan_ir(self.bus.HIR.D, self.bus.SIR.D,
+##                         self.bus.TIR.D, self.ENDIR)
+#        tdi_d_s = (self.bus.HIR.D 
+#                 + self.bus.SIR.D
+#                 + self.bus.TIR.D)
+#        tms_s_a = jtg_tp.state_change('IRSHIFT')
+#        tms_s_b = jtg_tp.state_change(self.ENDIR)
+#        
+#        tms_s = (tms_s_a
+#                 + "0" * (len(tdi_d_s)-1)
+#                 + tms_s_b) # end-state
+#        
+#        tdi_s = ("0" * len(tms_s_a)
+#                 + tdi_d_s
+#                 + "0" * (len(tms_s_b)-1)
+#                )
+#        
+#        self.jtg_seq.queue(tms_s, tdi_s)
     def scan_ir(self):
-#        self.jtg.scan_ir(self.bus.HIR.D, self.bus.SIR.D,
-#                         self.bus.TIR.D, self.ENDIR)
-        tdi_d_s = (self.bus.HIR.D 
-                 + self.bus.SIR.D
-                 + self.bus.TIR.D)
-        tms_s_a = jtg_tp.state_change('IRSHIFT')
-        tms_s_b = jtg_tp.state_change(self.ENDIR)
+        tdi_d_a = (self.bus.HIR.D, self.bus.HIR.length)
+        tdi_d_b = (self.bus.SIR.D, self.bus.SIR.length)
+        tdi_d_c = (self.bus.TIR.D, self.bus.TIR.length)
+        tdi_d_len = self.bus.HIR.length + self.bus.SIR.length + self.bus.TIR.length
+        
+        tms_start, tms_start_l = get_int_and_b_len(jtg_tp.state_change('IRSHIFT'))
+        tms_end, tms_end_l = get_int_and_b_len(jtg_tp.state_change(self.ENDIR))
+        
+        # list of tuples with (data,length)
+        tms_tuples= [(tms_start,tms_start_l),(0,(tdi_d_len-1)),(tms_end,tms_end_l)]
+        tdi_tuples= [(0,tms_start_l), tdi_d_a, tdi_d_b, tdi_d_c, (0,(tms_end_l-1))]
+        
+        self.jtg_seq.tqueue(tms_tuples,tdi_tuples)
         
-        tms_s = (tms_s_a
-            + "0" * (len(tdi_d_s)-1)
-            + tms_s_b) # end-state
         
-        tdi_s = ("0" * len(tms_s_a)
-                + tdi_d_s
-                + "0" * (len(tms_s_b)-1)
-                )
         
-        self.jtg_seq.queue(tms_s, tdi_s)
-
     def set_enddr(self, enddr):
         assert enddr in valid_svf_end_states
 #        print("changing enddr to", enddr)
@@ -160,10 +198,11 @@ class svfinterpreter():
 #                _ = [self.jtg.state_change(x) for x in arg]
                 # multiple states....
             else:
-                s = jtg_tp.state_change(arg[0])
+                s, s_l = get_int_and_b_len(jtg_tp.state_change('IRSHIFT'))
+#                s = jtg_tp.state_change(arg[0])
 #                self.jtg.state_change(arg[0])
                 # single state
-            self.jtg_seq.queue(s,"0"*len(s))
+            self.jtg_seq.tqueue((s,s_l),(0,s_l))
 
     def run_test(self, arg: list):
         # THIS function is INCOMPLETE. it only deals with two cases.
@@ -222,6 +261,7 @@ class svfinterpreter():
      #       print("data_sub called in mode:",mode,"with arg, seq:",arg,",",sequence)
         # the alternatives for "sig" variable are self.bus.TDI
         if isinstance(arg, str):
+            sig.length = length
             if arg == 'TDI':
                 sig.D = sequence
             elif arg == 'TDO':
@@ -235,7 +275,8 @@ class svfinterpreter():
         elif isinstance(arg, list):
             for item in arg:
                 # format into binary. svf format is hex
-                bsequence = '{0:0{length}b}'.format(int(item[1], 16), length = length)
+#                bsequence = '{0:0{length}b}'.format(int(item[1], 16), length = length)
+                bsequence = int(item[1], 16)
                 self._data_sub_parse(item[0], bsequence, mode, sig, length = length)
 
     def dummy(self, arg=None):
@@ -256,7 +297,8 @@ class svfinterpreter():
                 print("Error, ", svfcase, "function not in command list")
     def end(self):
         self.jtg_seq.end_clean()
-        print(self.jtg_seq.get_tdo_bits_list())
+        return self.jtg_seq.get_tdo_bits_list()
+#        print(self.jtg_seq.get_tdo_bits_list())
 #        self.jtg.sca.ch.__del__() # safe shutdown.
         
     svfcommands = {

tests/test_whole_list_with_logging.py

@@ -44,9 +44,11 @@ def space():
 def littlespace():
     print("------")
 
-li = read_svf("../idcode.svf")#("../p_400klines.svf")#("../p_reduced.svf")
+li = read_svf("../p.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 35 minutes 21.746152 seconds for 400klines with delays. what happened?
+# operation completed in 0 minutes 20.630858 seconds for 400klines with integers.
 # operation completed in 8 minutes 8.541882 seconds
 # operation completed in 2 minutes 30.999758 seconds with no delays.. .
 listone = copy.deepcopy(li)
@@ -76,10 +78,19 @@ with z:
             i += 1
             if i % 100_000 == 0:
                 print(".", end="")
-        svf.end()
+        hugelist = svf.end()
     except KeyboardInterrupt:
         print("----- C-C detected! -----")
     finally:
         
         sw1.stop()
         print("ran {} tests".format(i))
+
+f = open("output.txt","w+")
+for line in hugelist:
+    f.write(line)
+    f.write("\n")
+f.close()
+
+
+