Python debug.info方法代码示例

# 需要导入模块: import debug [as 别名]
# 或者: from debug import info [as 别名]
def __init__(self, cols, rows, name="bitcell_array"):
        design.design.__init__(self, name)
        debug.info(1, "Creating {0} {1} x {2}".format(self.name, rows, cols))


        self.column_size = cols
        self.row_size = rows

        c = reload(__import__(OPTS.config.bitcell))
        self.mod_bitcell = getattr(c, OPTS.config.bitcell)
        self.cell = self.mod_bitcell()
        self.add_mod(self.cell)

        self.height = self.row_size*self.cell.height 
        self.width = self.column_size*self.cell.width 
        
        self.add_pins()
        self.create_layout()
        self.add_layout_pins()
        self.DRC_LVS() 

# 需要导入模块: import debug [as 别名]
# 或者: from debug import info [as 别名]
def gds_write_file(self, newLayout):
        """Writes the pin shape and label to GDS"""
        debug.info(4, "writing pin (" + str(self.layer) + "):" 
                   + str(self.width()) + "x" + str(self.height()) + " @ " + str(self.ll()))
        newLayout.addBox(layerNumber=layer[self.layer],
                         purposeNumber=0,
                         offsetInMicrons=self.ll(),
                         width=self.width(),
                         height=self.height(),
                         center=False)
        newLayout.addText(text=self.name,
                          layerNumber=layer[self.layer],
                          purposeNumber=0,
                          offsetInMicrons=self.ll(),
                          magnification=GDS["zoom"],
                          rotate=None) 

# 需要导入模块: import debug [as 别名]
# 或者: from debug import info [as 别名]
def pdf_write(self, pdf_name):
        # NOTE: Currently does not work (Needs further research)
        #self.pdf_name = self.name + ".pdf"
        debug.info(0, "Writing to %s" % pdf_name)
        pdf = gdsMill.pdfLayout(self.gds)

        return
        pdf.layerColors[self.gds.layerNumbersInUse[0]] = "#219E1C"
        pdf.layerColors[self.gds.layerNumbersInUse[1]] = "#271C9E"
        pdf.layerColors[self.gds.layerNumbersInUse[2]] = "#CC54C8"
        pdf.layerColors[self.gds.layerNumbersInUse[3]] = "#E9C514"
        pdf.layerColors[self.gds.layerNumbersInUse[4]] = "#856F00"
        pdf.layerColors[self.gds.layerNumbersInUse[5]] = "#BD1444"
        pdf.layerColors[self.gds.layerNumbersInUse[6]] = "#FD1444"
        pdf.layerColors[self.gds.layerNumbersInUse[7]] = "#FD1414"

        pdf.setScale(500)
        pdf.drawLayout()
        pdf.writeToFile(pdf_name) 

# 需要导入模块: import debug [as 别名]
# 或者: from debug import info [as 别名]
def print_attr(self):
        """Prints a list of attributes for the current layout object"""
        debug.info(0, 
                   "|==============================================================================|")
        debug.info(0, 
                   "|=========      LIST OF OBJECTS (Rects) FOR: " + self.attr["name"])
        debug.info(0, 
                   "|==============================================================================|")
        for obj in self.objs:
            debug.info(0, "layer={0} : offset={1} : size={2}".format(
                obj.layerNumber, obj.offset, obj.size))

        debug.info(0, 
                   "|==============================================================================|")
        debug.info(0, 
                   "|=========      LIST OF INSTANCES FOR: " +
                   self.attr["name"])
        debug.info(0, 
                   "|==============================================================================|")
        for inst in self.insts:
            debug.info(0, "name={0} : mod={1} : offset={2}".format(
                inst.name, inst.mod.name, inst.offset)) 

# 需要导入模块: import debug [as 别名]
# 或者: from debug import info [as 别名]
def get_tool(tool_type, preferences):
    """
    Find which tool we have from a list of preferences and return the
    one selected and its full path.
    """
    debug.info(2,"Finding {} tool...".format(tool_type))
    global OPTS

    for name in preferences:
        exe_name = find_exe(name)
        if exe_name != None:
            debug.info(1, "Using {0}: {1}".format(tool_type,exe_name))
            return(name,exe_name)
        else:
            debug.info(1, "Could not find {0}, trying next {1} tool.".format(name,tool_type))
    else:
        return(None,"") 

# 需要导入模块: import debug [as 别名]
# 或者: from debug import info [as 别名]
def parse_output(filename, key):
    """Parses a hspice output.lis file for a key value"""
    if OPTS.spice_name == "xa" :
        # customsim has a different output file name
        full_filename="{0}xa.meas".format(OPTS.openram_temp)
    else:
        # ngspice/hspice using a .lis file
        full_filename="{0}{1}.lis".format(OPTS.openram_temp, filename)

    try:
        f = open(full_filename, "r")
    except IOError:
        debug.error("Unable to open spice output file: {0}".format(full_filename),1)
    contents = f.read()
    # val = re.search(r"{0}\s*=\s*(-?\d+.?\d*\S*)\s+.*".format(key), contents)
    val = re.search(r"{0}\s*=\s*(-?\d+.?\d*[e]?[-+]?[0-9]*\S*)\s+.*".format(key), contents)
    
    if val != None:
        debug.info(4, "Key = " + key + " Val = " + val.group(1))
        return val.group(1)
    else:
        return "Failed" 

# 需要导入模块: import debug [as 别名]
# 或者: from debug import info [as 别名]
def __init__(self, size=1, beta=parameter["beta"], height=bitcell.height, route_output=True):
        # We need to keep unique names because outputting to GDSII
        # will use the last record with a given name. I.e., you will
        # over-write a design in GDS if one has and the other doesn't
        # have poly connected, for example.
        name = "pinv_{}".format(pinv.unique_id)
        pinv.unique_id += 1
        pgate.pgate.__init__(self, name)
        debug.info(2, "create pinv structure {0} with size of {1}".format(name, size))

        self.nmos_size = size
        self.pmos_size = beta*size
        self.beta = beta
        self.height = height # Maybe minimize height if not defined in future?
        self.route_output = False

        self.add_pins()
        self.create_layout()

        # for run-time, we won't check every transitor DRC/LVS independently
        # but this may be uncommented for debug purposes
        #self.DRC_LVS() 

# 需要导入模块: import debug [as 别名]
# 或者: from debug import info [as 别名]
def __init__(self, text, layerNumber, offset, zoom=-1):
        """Initializes a text label for specified layer"""
        geometry.__init__(self)
        self.name = "label"
        self.text = text
        self.layerNumber = layerNumber
        self.offset = vector(offset).snap_to_grid()
        if zoom<0:
            self.zoom = GDS["zoom"]
        else:
            self.zoom = zoom


        self.size = 0

        debug.info(4,"creating label " + self.text + " " + str(self.layerNumber) + " " + str(self.offset)) 

# 需要导入模块: import debug [as 别名]
# 或者: from debug import info [as 别名]
def __init__(self, columns, word_size, name=""):
        self.columns = columns
        self.word_size = word_size
        if name=="":
            name = "flop_array_c{0}_w{1}".format(columns,word_size)
        design.design.__init__(self, name)
        debug.info(1, "Creating {}".format(self.name))

        c = reload(__import__(OPTS.config.ms_flop))
        self.mod_ms_flop = getattr(c, OPTS.config.ms_flop)
        self.ms = self.mod_ms_flop("ms_flop")
        self.add_mod(self.ms)

        self.width = self.columns * self.ms.width
        self.height = self.ms.height
        self.words_per_row = self.columns / self.word_size

        self.create_layout() 

# 需要导入模块: import debug [as 别名]
# 或者: from debug import info [as 别名]
def __init__(self, size=1, height=bitcell.height):
        """ Creates a cell for a simple 3 input nand """
        name = "pnand3_{0}".format(pnand3.unique_id)
        pnand3.unique_id += 1
        pgate.pgate.__init__(self, name)
        debug.info(2, "create pnand3 structure {0} with size of {1}".format(name, size))

        self.nmos_size = 3*size
        self.pmos_size = parameter["beta"]*size
        self.nmos_width = self.nmos_size*drc["minwidth_tx"]
        self.pmos_width = self.pmos_size*drc["minwidth_tx"]
        self.height = height

        # FIXME: Allow these to be sized
        debug.check(size==1,"Size 1 pnand3 is only supported now.")
        self.tx_mults = 1

        self.add_pins()
        self.create_layout()
        #self.DRC_LVS() 

# 需要导入模块: import debug [as 别名]
# 或者: from debug import info [as 别名]
def __init__(self, word_size, words_per_row):
        design.design.__init__(self, "sense_amp_array")
        debug.info(1, "Creating {0}".format(self.name))

        c = reload(__import__(OPTS.config.sense_amp))
        self.mod_sense_amp = getattr(c, OPTS.config.sense_amp)
        self.amp = self.mod_sense_amp("sense_amp")
        self.add_mod(self.amp)

        self.word_size = word_size
        self.words_per_row = words_per_row
        self.row_size = self.word_size * self.words_per_row

        self.height = self.amp.height
        self.width = self.amp.width * self.word_size * self.words_per_row

        self.add_pins()
        self.create_layout()
        self.DRC_LVS() 

# 需要导入模块: import debug [as 别名]
# 或者: from debug import info [as 别名]
def __init__(self, columns, word_size):
        design.design.__init__(self, "write_driver_array")
        debug.info(1, "Creating {0}".format(self.name))

        c = reload(__import__(OPTS.config.write_driver))
        self.mod_write_driver = getattr(c, OPTS.config.write_driver)
        self.driver = self.mod_write_driver("write_driver")
        self.add_mod(self.driver)

        self.columns = columns
        self.word_size = word_size
        self.words_per_row = columns / word_size

        self.width = self.columns * self.driver.width
        self.height = self.height = self.driver.height
        
        self.add_pins()
        self.create_layout()
        self.DRC_LVS() 

# 需要导入模块: import debug [as 别名]
# 或者: from debug import info [as 别名]
def isdiff(file1,file2):
    """ This is used to compare two files and display the diff if they are different.. """
    import debug
    import filecmp
    import difflib
    check = filecmp.cmp(file1,file2)
    if not check:
        debug.info(2,"MISMATCH {0} {1}".format(file1,file2))
        f1 = open(file1,"r")
        s1 = f1.readlines()
        f2 = open(file2,"r")
        s2 = f2.readlines()
        for line in difflib.unified_diff(s1, s2):
            debug.error(line)   
    else:
        debug.info(2,"MATCH {0} {1}".format(file1,file2))
    return (check) 

# 需要导入模块: import debug [as 别名]
# 或者: from debug import info [as 别名]
def init_queue(self):
        """
        Populate the queue with all the source pins with cost
        to the target. Each item is a path of the grid cells.
        We will use an A* search, so this cost must be pessimistic.
        Cost so far will be the length of the path.
        """
        debug.info(4,"Initializing queue.")

        # uniquify the source (and target while we are at it)
        self.source = list(set(self.source))
        self.target = list(set(self.target))
        
        for s in self.source:
            cost = self.cost_to_target(s)
            debug.info(4,"Init: cost=" + str(cost) + " " + str([s]))
            self.q.put((cost,[s])) 

# 需要导入模块: import debug [as 别名]
# 或者: from debug import info [as 别名]
def find_pin(self,pin):
        """ 
        Finds the pin shapes and converts to tracks. 
        Pin can either be a label or a location,layer pair: [[x,y],layer].
        """

        if type(pin)==str:
            (pin_name,pin_layer,pin_shapes) = self.layout.getAllPinShapesByLabel(str(pin))
        else:
            (pin_name,pin_layer,pin_shapes) = self.layout.getAllPinShapesByLocLayer(pin[0],pin[1])

        new_pin_shapes = []
        for pin_shape in pin_shapes:
            debug.info(2,"Find pin {0} layer {1} shape {2}".format(pin_name,str(pin_layer),str(pin_shape)))
            # repack the shape as a pair of vectors rather than four values
            new_pin_shapes.append([vector(pin_shape[0],pin_shape[1]),vector(pin_shape[2],pin_shape[3])])
            
        debug.check(len(new_pin_shapes)>0,"Did not find any pin shapes for {0}.".format(str(pin)))
        
        return (pin_layer,new_pin_shapes)