Added updated analytical characterization with combined models

compiler/modules/bank.py

@@ -1216,36 +1216,62 @@ class bank(design.design):
                             rotate=90)
 
         
-    def analytical_delay(self, corner, slew, load):
-        """ return  analytical delay of the bank"""
-        results = []
+    # def analytical_delay(self, corner, slew, load):
+        # """ return  analytical delay of the bank"""
+        # results = []
         
-        decoder_delay = self.row_decoder.analytical_delay(corner, slew, self.wordline_driver.input_load())
+        # decoder_delay = self.row_decoder.analytical_delay(corner, slew, self.wordline_driver.input_load())
 
-        word_driver_delay = self.wordline_driver.analytical_delay(corner, 
-                                                                  decoder_delay.slew, 
-                                                                  self.bitcell_array.input_load())
+        # word_driver_delay = self.wordline_driver.analytical_delay(corner, 
+                                                                  # decoder_delay.slew, 
+                                                                  # self.bitcell_array.input_load())
+
+        # #FIXME: Array delay is the same for every port.
+        # bitcell_array_delay = self.bitcell_array.analytical_delay(corner, word_driver_delay.slew)
+
+        # #This also essentially creates the same delay for each port. Good structure, no substance
+        # for port in self.all_ports:
+            # if self.words_per_row > 1:
+                # column_mux_delay = self.column_mux_array[port].analytical_delay(corner, 
+                                                                                # bitcell_array_delay.slew,
+                                                                                # self.sense_amp_array.input_load())
+            # else:
+                # column_mux_delay = self.return_delay(delay = 0.0, slew=word_driver_delay.slew)
+                
+            # bl_t_data_out_delay = self.sense_amp_array.analytical_delay(corner, 
+                                                                        # column_mux_delay.slew,
+                                                                        # self.bitcell_array.output_load())
+            # # output load of bitcell_array is set to be only small part of bl for sense amp.
+            # results.append(decoder_delay + word_driver_delay + bitcell_array_delay + column_mux_delay + bl_t_data_out_delay) 
+
+        # return results
+    
+    def analytical_delay(self, corner, slew, load):
+        """ return  analytical delay of the bank. This will track the clock to output path"""
+        #FIXME: This delay is determined in the control logic. Should be moved here.
+        # word_driver_delay = self.wordline_driver.analytical_delay(corner, 
+                                                                  # slew, 
+                                                                  # self.bitcell_array.input_load())
 
         #FIXME: Array delay is the same for every port.
-        bitcell_array_delay = self.bitcell_array.analytical_delay(corner, word_driver_delay.slew)
+        word_driver_slew =  0
+        bitcell_array_delay = self.bitcell_array.analytical_delay(corner, word_driver_slew)
 
         #This also essentially creates the same delay for each port. Good structure, no substance
-        for port in self.all_ports:
-            if self.words_per_row > 1:
-                column_mux_delay = self.column_mux_array[port].analytical_delay(corner, 
-                                                                                bitcell_array_delay.slew,
-                                                                                self.sense_amp_array.input_load())
-            else:
-                column_mux_delay = self.return_delay(delay = 0.0, slew=word_driver_delay.slew)
-                
-            bl_t_data_out_delay = self.sense_amp_array.analytical_delay(corner, 
-                                                                        column_mux_delay.slew,
-                                                                        self.bitcell_array.output_load())
-            # output load of bitcell_array is set to be only small part of bl for sense amp.
-            results.append(decoder_delay + word_driver_delay + bitcell_array_delay + column_mux_delay + bl_t_data_out_delay) 
-
-        return results
-         
+        if self.words_per_row > 1:
+            column_mux_delay = self.column_mux_array[port].analytical_delay(corner, 
+                                                                            bitcell_array_delay.slew,
+                                                                            self.sense_amp_array.input_load())
+        else:
+            column_mux_delay = []  
+            
+        column_mux_slew =  0    
+        sense_amp_delay = self.sense_amp_array.analytical_delay(corner, 
+                                                                    column_mux_slew,
+                                                                    self.bitcell_array.output_load())
+        # output load of bitcell_array is set to be only small part of bl for sense amp.
+        return  bitcell_array_delay + column_mux_delay + sense_amp_delay
+    
     def determine_wordline_stage_efforts(self, external_cout, inp_is_rise=True):    
         """Get the all the stage efforts for each stage in the path within the bank clk_buf to a wordline"""
         #Decoder is assumed to have settled before the negative edge of the clock. Delay model relies on this assumption

compiler/modules/bitcell_array.py

@@ -4,6 +4,7 @@ from tech import drc, spice
 from vector import vector
 from globals import OPTS
 from sram_factory import factory
+import logical_effort
 
 class bitcell_array(design.design):
     """
@@ -130,23 +131,32 @@ class bitcell_array(design.design):
                         self.add_power_pin(pin_name, pin.center(), 0, pin.layer)
                             
 
+    # def analytical_delay(self, corner, slew, load=0):
+        # from tech import drc
+        # wl_wire = self.gen_wl_wire()
+        # wl_wire.return_delay_over_wire(slew)
+
+        # wl_to_cell_delay = wl_wire.return_delay_over_wire(slew)
+        # # hypothetical delay from cell to bl end without sense amp
+        # bl_wire = self.gen_bl_wire()
+        # cell_load = 2 * bl_wire.return_input_cap() # we ingore the wire r
+                                                   # # hence just use the whole c
+        # bl_swing = 0.1
+        # cell_delay = self.cell.analytical_delay(corner, wl_to_cell_delay.slew, cell_load, swing = bl_swing)
+
+        # #we do not consider the delay over the wire for now
+        # return self.return_delay(cell_delay.delay+wl_to_cell_delay.delay,
+                                 # wl_to_cell_delay.slew)
+    
     def analytical_delay(self, corner, slew, load=0):
-        from tech import drc
-        wl_wire = self.gen_wl_wire()
-        wl_wire.return_delay_over_wire(slew)
-
-        wl_to_cell_delay = wl_wire.return_delay_over_wire(slew)
-        # hypothetical delay from cell to bl end without sense amp
-        bl_wire = self.gen_bl_wire()
-        cell_load = 2 * bl_wire.return_input_cap() # we ingore the wire r
-                                                   # hence just use the whole c
-        bl_swing = 0.1
-        cell_delay = self.cell.analytical_delay(corner, wl_to_cell_delay.slew, cell_load, swing = bl_swing)
-
-        #we do not consider the delay over the wire for now
-        return self.return_delay(cell_delay.delay+wl_to_cell_delay.delay,
-                                 wl_to_cell_delay.slew)
-                        
+        """Returns relative delay of the bitline in the bitcell array"""
+        #The load being driven/drained is mostly the bitline but could include the sense amp or the column mux.
+        #The load from the bitlines is due to the drain capacitances from all the other bitlines and wire parasitics.
+        drain_parasitics = .5 #each bitcell adds half a parasitic to the delay
+        wire_parasitics = .05 * drain_parasitics #Wires add 5% to this.
+        bitline_load = (drain_parasitics+wire_parasitics)*self.row_size * logical_effort.logical_effort.pinv
+        return [self.cell.analytical_delay(corner, slew, load+bitline_load)]
+    
     def analytical_power(self, corner, load):
         """Power of Bitcell array and bitline in nW."""
         from tech import drc, parameter

compiler/modules/control_logic.py

@@ -33,10 +33,10 @@ class control_logic(design.design):
         self.num_words = num_rows*words_per_row
         
         self.enable_delay_chain_resizing = True
+        self.inv_parasitic_delay = logical_effort.logical_effort.pinv
         
         #Determines how much larger the sen delay should be. Accounts for possible error in model.
         self.wl_timing_tolerance = 1 
-        self.parasitic_inv_delay = parameter["min_inv_para_delay"] 
         self.wl_stage_efforts = None
         self.sen_stage_efforts = None
         
@@ -219,7 +219,7 @@ class control_logic(design.design):
     def get_dynamic_delay_chain_size(self, previous_stages, previous_fanout):
         """Determine the size of the delay chain used for the Sense Amp Enable using path delays"""
         from math import ceil
-        previous_delay_chain_delay = (previous_fanout+1+self.parasitic_inv_delay)*previous_stages
+        previous_delay_chain_delay = (previous_fanout+1+self.inv_parasitic_delay)*previous_stages
         debug.info(2, "Previous delay chain produced {} delay units".format(previous_delay_chain_delay))
         
         delay_fanout = 3 # This can be anything >=2
@@ -227,7 +227,7 @@ class control_logic(design.design):
         #inverter adds 1 unit of delay (due to minimum size). This also depends on the pinv value
         required_delay = self.wl_delay*self.wl_timing_tolerance - (self.sen_delay-previous_delay_chain_delay)
         debug.check(required_delay > 0, "Cannot size delay chain to have negative delay")
-        delay_stages = ceil(required_delay/(delay_fanout+1+self.parasitic_inv_delay))
+        delay_stages = ceil(required_delay/(delay_fanout+1+self.inv_parasitic_delay))
         if delay_stages%2 == 1: #force an even number of stages. 
             delay_stages+=1
             #Fanout can be varied as well but is a little more complicated but potentially optimal.
@@ -237,7 +237,7 @@ class control_logic(design.design):
     def get_dynamic_delay_fanout_list(self, previous_stages, previous_fanout):
         """Determine the size of the delay chain used for the Sense Amp Enable using path delays"""
         
-        previous_delay_chain_delay = (previous_fanout+1+self.parasitic_inv_delay)*previous_stages
+        previous_delay_chain_delay = (previous_fanout+1+self.inv_parasitic_delay)*previous_stages
         debug.info(2, "Previous delay chain produced {} delay units".format(previous_delay_chain_delay))
         
         fanout_rise = fanout_fall = 2 # This can be anything >=2
@@ -284,9 +284,9 @@ class control_logic(design.design):
     def calculate_stages_with_fixed_fanout(self, required_delay, fanout):
         from math import ceil
         #Delay being negative is not an error. It implies that any amount of stages would have a negative effect on the overall delay
-        if required_delay <= 3+self.parasitic_inv_delay: #3 is the minimum delay per stage (with pinv=0).
+        if required_delay <= 3+self.inv_parasitic_delay: #3 is the minimum delay per stage (with pinv=0).
             return 1
-        delay_stages = ceil(required_delay/(fanout+1+self.parasitic_inv_delay))
+        delay_stages = ceil(required_delay/(fanout+1+self.inv_parasitic_delay))
         return delay_stages
     
     def calculate_stage_list(self, total_stages, fanout_rise, fanout_fall):
@@ -850,14 +850,14 @@ class control_logic(design.design):
     def get_delays_to_wl(self):
         """Get the delay (in delay units) of the clk to a wordline in the bitcell array"""
         debug.check(self.sram.all_mods_except_control_done, "Cannot calculate sense amp enable delay unless all module have been added.")
-        self.wl_stage_efforts = self.determine_wordline_stage_efforts()
-        clk_to_wl_rise,clk_to_wl_fall = logical_effort.calculate_relative_rise_fall_delays(self.wl_stage_efforts, self.parasitic_inv_delay)
+        self.wl_stage_efforts = self.get_wordline_stage_efforts()
+        clk_to_wl_rise,clk_to_wl_fall = logical_effort.calculate_relative_rise_fall_delays(self.wl_stage_efforts)
         total_delay = clk_to_wl_rise + clk_to_wl_fall 
         debug.info(1, "Clock to wl delay is rise={:.3f}, fall={:.3f}, total={:.3f} in delay units".format(clk_to_wl_rise, clk_to_wl_fall,total_delay))
         return clk_to_wl_rise,clk_to_wl_fall 
      
         
-    def determine_wordline_stage_efforts(self):
+    def get_wordline_stage_efforts(self):
         """Follows the gated_clk_bar -> wl_en -> wordline signal for the total path efforts"""
         stage_effort_list = []
         
@@ -871,7 +871,7 @@ class control_logic(design.design):
         last_stage_is_rise = stage_effort_list[-1].is_rise
         
         #Then ask the sram for the other path delays (from the bank)
-        stage_effort_list += self.sram.determine_wordline_stage_efforts(last_stage_is_rise)
+        stage_effort_list += self.sram.get_wordline_stage_efforts(last_stage_is_rise)
         
         return stage_effort_list
         
@@ -880,17 +880,15 @@ class control_logic(design.design):
            This does not incorporate the delay of the replica bitline.
         """
         debug.check(self.sram.all_mods_except_control_done, "Cannot calculate sense amp enable delay unless all module have been added.")
-        self.sen_stage_efforts = self.determine_sa_enable_stage_efforts()
-        clk_to_sen_rise, clk_to_sen_fall = logical_effort.calculate_relative_rise_fall_delays(self.sen_stage_efforts, self.parasitic_inv_delay)
+        self.sen_stage_efforts = self.get_sa_enable_stage_efforts()
+        clk_to_sen_rise, clk_to_sen_fall = logical_effort.calculate_relative_rise_fall_delays(self.sen_stage_efforts)
         total_delay = clk_to_sen_rise + clk_to_sen_fall 
         debug.info(1, "Clock to s_en delay is rise={:.3f}, fall={:.3f}, total={:.3f} in delay units".format(clk_to_sen_rise, clk_to_sen_fall,total_delay))
         return clk_to_sen_rise, clk_to_sen_fall   
           
-    def determine_sa_enable_stage_efforts(self):
+    def get_sa_enable_stage_efforts(self):
         """Follows the gated_clk_bar signal to the sense amp enable signal adding each stages stage effort to a list"""
         stage_effort_list = []
-        #Calculate the load on clk_buf_bar
-        ext_clk_buf_cout = self.sram.get_clk_bar_cin()
         
         #Initial direction of clock signal for this path
         last_stage_rise = True
@@ -917,7 +915,54 @@ class control_logic(design.design):
         """Gets a list of the stages and delays in order of their path."""
         if self.sen_stage_efforts == None or self.wl_stage_efforts == None:
             debug.error("Model delays not calculated for SRAM.", 1)
-        wl_delays = logical_effort.calculate_delays(self.wl_stage_efforts, self.parasitic_inv_delay)
-        sen_delays = logical_effort.calculate_delays(self.sen_stage_efforts, self.parasitic_inv_delay)
+        wl_delays = logical_effort.calculate_delays(self.wl_stage_efforts)
+        sen_delays = logical_effort.calculate_delays(self.sen_stage_efforts)
         return wl_delays, sen_delays
         
+    def analytical_delay(self, corner, slew, load):
+        """Gets the analytical delay from clk input to wl_en output"""
+        stage_effort_list = []
+        #Calculate the load on clk_buf_bar
+        ext_clk_buf_cout = self.sram.get_clk_bar_cin()
+        
+        #Operations logic starts on negative edge
+        last_stage_rise = False 
+        
+        #First stage(s), clk -(pdriver)-> clk_buf. 
+        clk_buf_cout = self.replica_bitline.get_en_cin()
+        stage_effort_list += self.clk_buf_driver.get_stage_efforts(clk_buf_cout, last_stage_rise)
+        last_stage_rise = stage_effort_list[-1].is_rise
+        
+        #Second stage, clk_buf -(inv)-> clk_bar
+        clk_bar_cout = self.and2.get_cin()
+        stage_effort_list += self.and2.get_stage_efforts(clk_bar_cout, last_stage_rise)
+        last_stage_rise = stage_effort_list[-1].is_rise
+        
+        #Third stage clk_bar -(and)-> gated_clk_bar
+        gated_clk_bar_cin = self.get_gated_clk_bar_cin()
+        stage_effort_list.append(self.inv.get_stage_effort(gated_clk_bar_cin, last_stage_rise))
+        last_stage_rise = stage_effort_list[-1].is_rise
+
+        #Stages from gated_clk_bar -------> wordline 
+        stage_effort_list += self.get_wordline_stage_efforts()
+        return stage_effort_list
+       
+    def get_clk_buf_cin(self):
+        """Get the loads that are connected to the buffered clock. 
+           Includes all the DFFs and some logic."""
+       
+        #Control logic internal load
+        int_clk_buf_cap = self.inv.get_cin() + self.ctrl_dff_array.get_clk_cin() + self.and2.get_cin()
+
+        #Control logic external load (in the other parts of the SRAM)
+        ext_clk_buf_cap = self.sram.get_clk_bar_cin()
+       
+        return int_clk_buf_cap + ext_clk_buf_cap
+        
+    def get_gated_clk_bar_cin(self):
+        """Get intermediates net gated_clk_bar's capacitance"""
+        total_cin = 0
+        total_cin += self.wl_en_driver.get_cin()
+        if self.port_type == 'rw':
+            total_cin +=self.and2.get_cin() 
+        return total_cin

compiler/modules/sense_amp.py

@@ -2,6 +2,7 @@ import design
 import debug
 import utils
 from tech import GDS,layer, parameter,drc
+import logical_effort
 
 class sense_amp(design.design):
     """
@@ -31,12 +32,13 @@ class sense_amp(design.design):
         bitline_pmos_size = 8 #FIXME: This should be set somewhere and referenced. Probably in tech file.
         return spice["min_tx_drain_c"]*(bitline_pmos_size/parameter["min_tx_size"])#ff   
         
-    def analytical_delay(self, corner, slew, load=0.0):
-        from tech import spice
-        r = spice["min_tx_r"]/(10)
-        c_para = spice["min_tx_drain_c"]
-        result = self.cal_delay_with_rc(corner, r = r, c =  c_para+load, slew = slew)
-        return self.return_delay(result.delay, result.slew)
+    def analytical_delay(self, corner, slew, load):
+        #Delay of the sense amp will depend on the size of the amp and the output load.
+        parasitic_delay = 1
+        cin = (parameter["sa_inv_pmos_size"] + parameter["sa_inv_nmos_size"])/drc("minwidth_tx")
+        sa_size = parameter["sa_inv_nmos_size"]/drc("minwidth_tx")
+        cc_inv_cin = cin
+        return logical_effort.logical_effort('column_mux', sa_size, cin, load+cc_inv_cin, parasitic_delay, False)
 
     def analytical_power(self, corner, load):
         """Returns dynamic and leakage power. Results in nW"""

compiler/modules/sense_amp_array.py

@@ -136,8 +136,8 @@ class sense_amp_array(design.design):
     def input_load(self):
         return self.amp.input_load()
     
-    def analytical_delay(self, corner, slew, load=0.0):
-        return self.amp.analytical_delay(corner, slew=slew, load=load)
+    def analytical_delay(self, corner, slew, load):
+        return [self.amp.analytical_delay(corner, slew=slew, load=load)]
         
     def get_en_cin(self):
         """Get the relative capacitance of all the sense amp enable connections in the array"""

compiler/modules/single_level_column_mux_array.py

@@ -227,3 +227,10 @@ class single_level_column_mux_array(design.design):
         result = self.cal_delay_with_rc(corner, r = r, c =  c_para+load, slew = slew, swing = volt_swing)
         return self.return_delay(result.delay, result.slew)            
             
+
+    def analytical_delay(self, corner, slew, load):
+        """Returns relative delay that the column mux adds"""
+        #Single level column mux will add parasitic loads from other mux pass transistors and the sense amp.
+        drain_parasitics = .5 #Assumed parasitics from unused TXs
+        array_load = drain_parasitics*self.words_per_row*logical_effort.pinv
+        return [self.mux.analytical_delay(corner, slew, load+array_load)]