Stats

Locked Locked
Replies 8
Subscribers 144
Views 15146
Members are here 0

This discussion has been locked.

You can no longer post new replies to this discussion. If you have a question you can start a new discussion

defstruct in pcell (for layout), is it possible?

sjoerdh over 11 years ago

Hello,

This is what I want to do:

Create a pcell that instantiates other pcells (layout)
Perform various "measurements" on this new instance (i.e.: retrieve the bounding box)
This information has to be used lateron in the pcell code

I'd like to store this information in a table, where each cell is a defstruct.The code looks like this:

procedure( genCurMir( ... )
    let( ()
        ...
        curMirInst = makeTable( "curMirInst" nil )
        defstruct( instance boundingBox gateCenter drainCenter sourceCentre )
        curMirInst["CELL1"] = make_instance()
        ...
        curMirInst["CELL1"]->boundingBox = instID~>bBox
        ...
    ) ;;; end of let
) ;;; end of procedure genCurMir

After generating the pcell (loading the code containing the command "pcDefinePCell") weird things happen: I am unable to open any view (layout/schematic/symbol/...).Entering commands in the CIW will result (9 out of 10 times) in an error, which is the same error when trying to open any cell-view:

*Error* setq/set: Variable is protected and cannot be assigned to - instance

I have tried creating the defstruct with an other name (blablablabla, definitely not used anywhere else), but the same error, only "instance" replaced by "blablablabla". I have to restart Cedence to regain control.

Furthermore, this created defstruct seems to be global, whereas I created it inside a let. I'd like to keep it local though.

So my question is:

Is it possible to use defstructs in pcells?
If so, what am I doing wrong?

I'd realy like to use this method (table of defstructs) since it is very conveniant.

Any help is highly appreciated.

Thanks in advance,

Sjoerd

Parents

sjoerdh over 11 years ago

Hi Andrew, theopaone and anyone else,
I've been playing around with table-of-defstructs and table-of-tables, and sofar for most of my coding both work equally simple. However, there's one case which I can't get to work if I use t-o-t, but is very easy in a t-o-ds. Please see an example below (the output is indented):
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Table of defstructs:
tempInstDS = makeTable( 'tempInstDSTable nil )
defstruct(sstCMMinstance instName instOrigin instOrient)
tempInstDS[1] = make_sstCMMinstance()
tempInstDS[2] = make_sstCMMinstance()
tempInstDS[3] = make_sstCMMinstance()
tempInstDS[1]->instName = "instC"
tempInstDS[2]->instName = "instB"
tempInstDS[3]->instName = "instA"
tempInstDS[1]->instOrient = "R90"
tempInstDS[2]->instOrient = "R180"
tempInstDS[3]->instOrient = "MX"
tempInstDS[1]
    sstCMMinstance@0x11a08878
tempInstDS[1]->?
    (instOrient instOrigin instName)
tempInstDS[1]->??
    (instOrient "R90" instOrigin nil instName
        "instC"
    )
sort(tempInstDS->? 'lessp)
    (1 2 3)
foreach(key sort(tempInstDS->? 'lessp) printf("%L\n" tempInstDS[key]->? )) =>
    (instOrient instOrigin instName)
    (instOrient instOrigin instName)
    (instOrient instOrigin instName)
    (1 2 3)
foreach(key sort(tempInstDS->? 'lessp) printf("%L\n" tempInstDS[key]->?? ))
    (instOrient "R90" instOrigin nil instName "instC")
    (instOrient "R180" instOrigin nil instName "instB")
    (instOrient "MX" instOrigin nil instName "instA")
    (1 2 3)
foreach(key sort(tempInstDS->? 'lessp) printf("%L\n" tempInstDS[key]->instName ))
    "instC"
    "instB"
    "instA"
    (1 2 3)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

It is the last command I like to replicate using a t-o-t. This is the equivalent:
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Table of tables:
tempInst=makeTable( 'tempInstTable nil )
tempInst[list(1 "name")]="instC"
tempInst[list(2 "name")]="instB"
tempInst[list(3 "name")]="instA"
tempInst[list(1 "orient")]="R90"
tempInst[list(2 "orient")]="R180"
tempInst[list(3 "orient")]="MY"
tempInst->?
    ((1 "name")
        (3 "name")
        (2 "name")
        (1 "orient")
        (3 "orient")
        (2 "orient")
    )
sortcar( tempInst->? 'lessp)
    ((1 "orient")
        (1 "name")
        (2 "orient")
        (2 "name")
        (3 "orient")
        (3 "name")
    )
foreach( key sortcar( tempInst->? 'lessp) printf( "%L\n" tempInst[key] ))
    "R90"
    "instC"
    "R180"
    "instB"
    "MY"
    "instA"
    ((1 "orient")
        (1 "name")
        (2 "orient")
        (2 "name")
        (3 "orient")
        (3 "name")
    )
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
This is what I tried to get the same output as with the last command of the t-o-ds:
Since the following works:
tempInst['(1 "name")]
    "instC"
I thought I had to do this:
foreach( key sortcar( tempInst->? 'lessp) printf( "%L\n" tempInst['(car(key) "name")] ))
    output is all nil (6 times)
I have tried many different constructions for the printf statement, oa:
printf( "%L\n" tempInst['(key "name")] )
printf( "%L\n" tempInst[list(car(key) "name")] )
Even something simple as this doesn't work:
for(i 1 3 printf( "%L\n" tempInst[list(i "name")] ))
This truly surprises me since tempInst[list(1 "name")] does work...
What I try to do:
The output of the foreach should be all names (and only the names) of each instance.
The t-o-ds solution is simple, and easy to understand (see the last command of the t-o-ds code). The t-o-t? No solution yet.
I hope one of you can show me how to do it, or point me into the right direction by describing what I do wrong, so I can figur out myself what I am doing wrong.
Thank you in advance.
Kind regards,
Sjoerd
Cancel
Vote Up 0 Vote Down

Cancel

Reply

sjoerdh over 11 years ago

Hi Andrew, theopaone and anyone else,
I've been playing around with table-of-defstructs and table-of-tables, and sofar for most of my coding both work equally simple. However, there's one case which I can't get to work if I use t-o-t, but is very easy in a t-o-ds. Please see an example below (the output is indented):
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Table of defstructs:
tempInstDS = makeTable( 'tempInstDSTable nil )
defstruct(sstCMMinstance instName instOrigin instOrient)
tempInstDS[1] = make_sstCMMinstance()
tempInstDS[2] = make_sstCMMinstance()
tempInstDS[3] = make_sstCMMinstance()
tempInstDS[1]->instName = "instC"
tempInstDS[2]->instName = "instB"
tempInstDS[3]->instName = "instA"
tempInstDS[1]->instOrient = "R90"
tempInstDS[2]->instOrient = "R180"
tempInstDS[3]->instOrient = "MX"
tempInstDS[1]
    sstCMMinstance@0x11a08878
tempInstDS[1]->?
    (instOrient instOrigin instName)
tempInstDS[1]->??
    (instOrient "R90" instOrigin nil instName
        "instC"
    )
sort(tempInstDS->? 'lessp)
    (1 2 3)
foreach(key sort(tempInstDS->? 'lessp) printf("%L\n" tempInstDS[key]->? )) =>
    (instOrient instOrigin instName)
    (instOrient instOrigin instName)
    (instOrient instOrigin instName)
    (1 2 3)
foreach(key sort(tempInstDS->? 'lessp) printf("%L\n" tempInstDS[key]->?? ))
    (instOrient "R90" instOrigin nil instName "instC")
    (instOrient "R180" instOrigin nil instName "instB")
    (instOrient "MX" instOrigin nil instName "instA")
    (1 2 3)
foreach(key sort(tempInstDS->? 'lessp) printf("%L\n" tempInstDS[key]->instName ))
    "instC"
    "instB"
    "instA"
    (1 2 3)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

It is the last command I like to replicate using a t-o-t. This is the equivalent:
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Table of tables:
tempInst=makeTable( 'tempInstTable nil )
tempInst[list(1 "name")]="instC"
tempInst[list(2 "name")]="instB"
tempInst[list(3 "name")]="instA"
tempInst[list(1 "orient")]="R90"
tempInst[list(2 "orient")]="R180"
tempInst[list(3 "orient")]="MY"
tempInst->?
    ((1 "name")
        (3 "name")
        (2 "name")
        (1 "orient")
        (3 "orient")
        (2 "orient")
    )
sortcar( tempInst->? 'lessp)
    ((1 "orient")
        (1 "name")
        (2 "orient")
        (2 "name")
        (3 "orient")
        (3 "name")
    )
foreach( key sortcar( tempInst->? 'lessp) printf( "%L\n" tempInst[key] ))
    "R90"
    "instC"
    "R180"
    "instB"
    "MY"
    "instA"
    ((1 "orient")
        (1 "name")
        (2 "orient")
        (2 "name")
        (3 "orient")
        (3 "name")
    )
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
This is what I tried to get the same output as with the last command of the t-o-ds:
Since the following works:
tempInst['(1 "name")]
    "instC"
I thought I had to do this:
foreach( key sortcar( tempInst->? 'lessp) printf( "%L\n" tempInst['(car(key) "name")] ))
    output is all nil (6 times)
I have tried many different constructions for the printf statement, oa:
printf( "%L\n" tempInst['(key "name")] )
printf( "%L\n" tempInst[list(car(key) "name")] )
Even something simple as this doesn't work:
for(i 1 3 printf( "%L\n" tempInst[list(i "name")] ))
This truly surprises me since tempInst[list(1 "name")] does work...
What I try to do:
The output of the foreach should be all names (and only the names) of each instance.
The t-o-ds solution is simple, and easy to understand (see the last command of the t-o-ds code). The t-o-t? No solution yet.
I hope one of you can show me how to do it, or point me into the right direction by describing what I do wrong, so I can figur out myself what I am doing wrong.
Thank you in advance.
Kind regards,
Sjoerd
Cancel
Vote Up 0 Vote Down

Cancel

Children

No Data

Community Guidelines

The Cadence Design Communities support Cadence users and technologists interacting to exchange ideas, news, technical information, and best practices to solve problems and get the most from Cadence technology. The community is open to everyone, and to provide the most value, we require participants to follow our Community Guidelines that facilitate a quality exchange of ideas and information. By accessing, contributing, using or downloading any materials from the site, you agree to be bound by the full Community Guidelines.