Schematic net/inst name mapping: case-insensitive to case-sensitive

How else would you imagine it being done?  Unless you know what's in each schematic, you won't know what to map to - and you'll need to traverse the hierarchy to collect that information. Of course, you can optimize it by only storing the mapping per cellView rather than per hierarchical path, but I can't see how you would know what to map to unless you know what's there.

Andrew

I was sorta hoping there was a little-known, seldom-used, SKILL name-mapping function that would take care of everything for me. :)

If I do have to build my own list of all hierarchical net and instance names, which (if any) of these methods would you recommend?

1. Parse output of schHiFind()
2. Low-level recursive SKILL traversal via dbOpenCellViewByType(), dbGetAnyInstSwitchMaster(), etc.
3. Write a custom netlister via the OSS interface
4. Export some case-insensitive file format (e.g. SPICE netlist) and then parse the map file to recover the name mapping

I've done #2 at previous companies, and I know it's a bit involved. Maybe the most painless solution is to file a CCR asking for a case-insensitive version of geAddNetProbe()? ;)

 We've done something similar and used #2. It is not that complicated, and much more efficient than the others, especially the CCR idea.

You can make a simple map for a given cellview like this: 

procedure(myBuildInstCaseMapTable(@optional (cv geGetEditCellView()))
  let((instMapTable)
    instMapTable=makeTable("instMapTable" nil)
    foreach(inst cv~>instances~>name
        instMapTable[lowerCase(inst)]=inst
    )
    instMapTable
  ) ;let
) ;proc

Derek

I agree with Derek, using #2 makes sense.  #4 is not a good idea because the map file contents are not public and may change (there's an API to access it, but that won't help you since it is an API to do a mapping).

An enhancement request to do a case-insensitive probe is not that bad an idea, but it's unlikely to be implemented in anything other than a future release (and even then it's too late for IC616 in most likelihood - so you're talking about at least a couple of years, I'd have thought).

Andrew.

Thanks Derek & Andrew for the thoughtful advice.

I thought I'd share my SKILL++ implementation of #2. You were right: it wasn't much code at all.

;;; Macros

;; For those who are tired of (sprintf nil ...)
;; Using defmacro instead of defun protects the args from being eval'd twice.
(defmacro format (string @rest objects)
  `(sprintf nil ,string ,@objects))

(defmacro find (var xs body)
  "First element in XS matching the predicate BODY."
  `(car (exists ,var ,xs ,body)))

;;; General functions

(defun caseInsensitivelyEqual (r s "tt")
  "Compare two strings case-insensitively."
  (eqv (upperCase r) (upperCase s)))

(defun dropLast (xs "l")
  (if (cddr xs)
      (cons (car xs) (dropLast (cdr xs)))
    (list (car xs))))

;; foldl :: (b -> a -> b) -> b -> [a] -> b
(defun foldl (f e xs "ugl")
  (if (null xs)
      e
    (foldl f (f e (car xs)) (cdr xs))))

;;; Specific functions

;; Instance name constructor and destructor
;; bkInstName . mkInstName = id

;; (mkInstName "foo")   => "foo"
;; (mkInstName "foo" 3) => "foo<3>"
(defun mkInstName (baseName @optional instNum "tg")
  (strcat baseName (if instNum (format "<%d>" instNum) "")))

;; (bkInstName "foo")    => ("foo" nil)
;; (bkInstName "foo<3>") => ("foo" 3)
(defun bkInstName (name "t")
  (destructuringBind (baseName @optional instNum) (parseString name "<>")
    (list baseName (when instNum (atoi instNum)))))

;; (baseName "foo")    => "foo"
;; (baseName "foo<3>") => "foo"
(defun baseName (name "t")
  (car (bkInstName name)))

;; (instNum "foo")    => nil
;; (instNum "foo<3>") => 3
(defun instNum (name "t")
  (cadr (bkInstName name)))

;; (findNetName cv "vss") => "VSS"
(defun findNetName (cv name "dt")
  (or (find sigName cv->sigNames
        (caseInsensitivelyEqual sigName name))
      (error "Can't find net %L in cellview %L"
             name (list cv->libName cv->cellName cv->viewName))))

(defun findInst (cv name "dt")
  (or (find inst cv->instances
        (caseInsensitivelyEqual inst->baseName (baseName name)))
      (error "Can't find instance %L in cellview %L"
             name (list cv->libName cv->cellName cv->viewName))))

;; nextInst :: (cellView, pathString) -> instName -> (cellView, pathString)
(defun nextInst (cvPath instName "lt")
  (destructuringBind (cv path) cvPath
    (let ((inst (findInst cv instName)))
      (list (dbGetAnyInstSwitchMaster inst "schematic")
            (strcat path "/" (mkInstName inst->baseName (instNum instName)))))))

;; resolve :: cellView -> [instName] -> (cellView, pathString)
(defun resolve (cv path "dl")
  (foldl nextInst (list cv "") path))

;; (correctCase 'inst cv "/RtOp/TrKwLbLk/TrKrOw/DeCoVsT")
;;   => "/rtop/trkwlblk/trkrow/DECOVST"
;; (correctCase 'net cv "/RtOp/TrKwLbLk/TrKrOw/DeCoVsT/nEt06")
;;   => "/rtop/trkwlblk/trkrow/DECOVST/net06"
(defun correctCase (objType topCv path "sdt")
  (let ((p (parseString path "/")))
    (if (eq objType 'inst)
        (cadr (resolve topCv p))
      (destructuringBind (botCv correctPath) (resolve topCv (dropLast p))
        (strcat correctPath "/" (findNetName botCv (car (last p))))))))

Are they case-sensitive in what? This has very tool-specific answers so I'd need to know which tool you are talking about?

Regards,

Andrew

Net names, terminal names, instance names etc are all case sensitive in Virtuoso. That's not a matter of being that way by default - they're always case sensitive.

Regards,

Andrew.