<> <> <> <> <> <> <<>> DIRECTORY Build, Core, CoreClasses, CoreFlat, CoreOps, CoreProperties, Flow, Globals, HashTable, IO, Model, Real, Rope, WriteCapa; BuildImpl: CEDAR PROGRAM IMPORTS CoreClasses, CoreFlat, CoreOps, CoreProperties, Flow, Globals, HashTable, IO, Model, Real, Rope, WriteCapa EXPORTS Build = BEGIN OPEN Build; CoreAttributes: TYPE = LIST OF CoreAttributeRec; CoreAttributeRec: TYPE = RECORD [ port: CoreClasses.TransistorPort, attribute: Rope.ROPE]; FlatCellProc: TYPE = PROC [cell: Core.CellType, target: CoreFlat.FlatCellTypeRec _ CoreFlat.allFlatCells, flatCell: CoreFlat.FlatCellTypeRec _ [], instance: CoreClasses.CellInstance _ NIL, parent: Core.CellType _ NIL, flatParent: CoreFlat.FlatCellTypeRec _ [], data: REF ANY _ NIL, wireName: HashTable.Table]; Units: PUBLIC REAL _ 2.0; <> totalNodes: INT _ 0; totalFets: ARRAY[0..Model.maxFetTypes) OF INT _ ALL[0]; debug: PUBLIC BOOL _ FALSE; EOF: ERROR = CODE; <> Terminal: TYPE = {gate, source, drain}; BuildNode: PUBLIC PROC[flatWire: CoreFlat.FlatWire, globalVars: Globals.GlobalVars] RETURNS [Globals.Node] = { <> new: Globals.Node; val: HashTable.Value; found: BOOLEAN; <> <> <> [found: found, value: val] _ HashTable.Fetch[globalVars.nodeTable, flatWire]; IF found THEN RETURN[NARROW[val]]; new _ NEW[Globals.NodeRec]; <> new.flatWire _ flatWire; new.cap _ WriteCapa.GetRootCap[flatWire.wire]; new.res _ 0; new.hiTime _ -1.0; new.loTime _ -1.0; new.firstPointer _ NIL; new.always0 _ FALSE; new.always1 _ FALSE; new.input _ FALSE; new.precharged _ FALSE; new.dynamic _ FALSE; new.ratioError _ FALSE; new.watched _ FALSE; <> [] _ HashTable.Store[table: globalVars.nodeTable, key: flatWire, value: new]; totalNodes _ totalNodes + 1; RETURN [new]; }; BuildPointer: PROC[node: Globals.Node, fet: Globals.Fet] = { <> p: Globals.Pointer _ NEW[Globals.PointerRec _ [fet, node.firstPointer]]; node.firstPointer _ p; }; BuildFet: PROC[gate, source, drain: CoreFlat.FlatWire, fetData: REF ANY, l, w: REAL, globalVars: Globals.GlobalVars] RETURNS [fet: Globals.Fet] = { <> <<>> <> f2: Globals.Fet; ptr: Globals.Pointer; type: REF INTEGER _ NARROW[fetData]; fet _ NEW[Globals.FetRec]; fet.type _ type^; fet.gate _ BuildNode[gate, globalVars]; fet.source _ BuildNode[source, globalVars]; fet.drain _ BuildNode[drain, globalVars]; fet.area _ l*w; fet.aspect _ l/w; <> <> <> IF fet.type = Model.fetNDep THEN { IF fet.source = globalVars.VddNode THEN { IF fet.drain = fet.gate THEN fet.type _ Model.fetNLoad ELSE fet.type _ Model.fetNSuper; } ELSE IF fet.drain = globalVars.VddNode THEN { IF fet.source = fet.gate THEN fet.type _ Model.fetNLoad ELSE fet.type _ Model.fetNSuper; }; }; <> <> <> <> <> <> <> <<};>> <> <> <> <<};>> <> IF (fet.source # globalVars.VddNode) AND (fet.source # globalVars.GroundNode) THEN ptr _ fet.source.firstPointer ELSE IF (fet.drain # globalVars.VddNode) AND (fet.drain # globalVars.GroundNode) THEN ptr _ fet.drain.firstPointer ELSE IF (fet.gate # globalVars.VddNode) AND (fet.gate # globalVars.GroundNode) THEN ptr _ fet.gate.firstPointer ELSE ptr _ NIL; WHILE ptr # NIL DO f2 _ ptr.fet; IF (f2.gate = fet.gate) AND (f2.drain = fet.drain) AND (f2.source = fet.source) AND (f2.type = fet.type) THEN { f2.area _ f2.area + fet.area; f2.aspect _ 1.0/(1.0/f2.aspect + 1.0/fet.aspect); fet _ f2; EXIT; }; ptr _ ptr.next; ENDLOOP; IF ptr = NIL THEN { BuildPointer[fet.gate, fet]; IF fet.drain # fet.gate THEN BuildPointer[fet.drain, fet]; IF (fet.source # fet.gate) AND (fet.source # fet.drain) THEN BuildPointer[fet.source, fet]; fet.on0 _ Model.TypeTable[fet.type].on0; fet.on1 _ Model.TypeTable[fet.type].on1; fet.onAlways _ Model.TypeTable[fet.type].onAlways; }; totalFets[fet.type] _ totalFets[fet.type] + 1; RETURN; }; BuildAtt: PROC[fet: Globals.Fet, terminal: Terminal, string: Rope.ROPE] RETURNS [Rope.ROPE] = { <> <<>> pos, index: INT; pos _ Rope.Run[string, 0, "Crystal:", 0, FALSE]; IF pos < 7 THEN { pos _ Rope.Run[string, 0, "Cr:", 0, FALSE]; IF pos < 2 THEN RETURN[NIL]; }; string _ Rope.Replace[base: string, start: 0, len: pos, with: NIL]; <> IF terminal = gate THEN { index _ Model.NameToIndex[string]; IF index < 0 THEN RETURN [IO.PutFR["unknown transistor type %s", IO.rope[string]]]; fet.type _ index; RETURN [NIL]; }; <> IF Rope.Equal[string, "In", FALSE] OR Rope.Equal[string, "IN", FALSE] THEN { IF terminal = source THEN fet.noDrainInfo _ TRUE ELSE fet.noSourceInfo _ TRUE; } ELSE IF Rope.Equal[string, "Out", FALSE] OR Rope.Equal[string, "OUT", FALSE] THEN { IF terminal = source THEN fet.noSourceInfo _ TRUE ELSE fet.noDrainInfo _ TRUE; } ELSE Flow.Build[fet: fet, name: string, source: terminal=source]; RETURN [NIL]; }; Stats: PUBLIC PROC[] = { total: INT _ 0; IO.PutF[Globals.StdOut, "Total number of nodes: %d.\n", IO.int[totalNodes]]; FOR i:INT IN [0..Model.maxFetTypes) DO IF totalFets[i] = 0 THEN LOOP; IO.PutF[Globals.StdOut, "Number of %s transistors: %d.\n", IO.rope[Model.TypeTable[i].name], IO.int[totalFets[i]]]; total _ total + totalFets[i]; ENDLOOP; IO.PutF[Globals.StdOut, "Total number of transistors: %d.\n", IO.int[total]]; }; <> <<>> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <<};>> <> <> <> <> <> <<};>> <<};>> <<};>> <<>> <> <> <> <<>> <<};>> <> <<>> <> <> <> <> <> <> <> <> <> <> < gate, ch1 => source, ch2 => drain, ENDCASE => ERROR), Rope.Cat["Cry: ", att.first.attribute]];>> <> <> <> <<}>> <> <<>> <> <<[] _ HashTable.Store[table: publics, key: wire, value: $Public];>> <<};>> <<>> <> <> <> <> <<};>> <<};>> <<>> <> <> <> <> <<[] _ HashTable.Store[table: wireName, key: publicWire, value: name];>> <<};>> <<};>> <<>> <> <> <> <> <> <> <> <> <> <> <> <> <> <<};>> <<};>> <<>> <> <> <> <> <> <<};>> <<};>> <<>> <> <> <> <<[] _ HashTable.Store[table: wireName, key: wire, value: name];>> <> <> <<};>> <<>> <> <> <> <> <> <> <> <> <> <> <> <> <> <<>> <> <> <> <> <> <<>> <> <> <> <> < tranTab[nE] _ NEW[INTEGER _ i];>> < tranTab[pE] _ NEW[INTEGER _ i];>> < tranTab[nD] _ NEW[INTEGER _ i];>> <> <> <> <> <> <<};>> <<>> <> <> <> <> <> <<}>> <> <<};>> <<>> <> <> <> <<};>> <<>> NodeFromRope: PUBLIC PROC [id: Rope.ROPE, globalVars: Globals.GlobalVars] RETURNS [node: Globals.Node] ~ { flatWire: CoreFlat.FlatWire _ NEW[CoreFlat.FlatWireRec _ CoreFlat.ParseWirePath[globalVars.rootCell, id]]; node _ NARROW[HashTable.Fetch[globalVars.nodeTable, flatWire].value]; }; RopeFromNode: PUBLIC PROC [node: Globals.Node, globalVars: Globals.GlobalVars] RETURNS [id: Rope.ROPE] ~ { id _ CoreFlat.WirePathRope[globalVars.rootCell, node.flatWire^]; }; NetFromCore: PUBLIC PROC[ct: Core.CellType] RETURNS [globalVars: Globals.GlobalVars] = { InsertPublic: PROC[wire: Core.Wire] = { InsertWire[wire, CoreFlat.rootCellType, globalVars, wireName, public]; }; wireName: HashTable.Table _ HashTable.Create[]; IO.PutF[Globals.StdOut, "\nConverting cell %g . . .", IO.rope[CoreOps.GetCellTypeName[ct]]]; globalVars _ NEW[Globals.GlobalVarsRec]; globalVars.rootCell _ ct; globalVars.nodeTable _ HashTable.Create[equal: CoreFlat.FlatWireEqual, hash: CoreFlat.FlatWireHash]; CoreOps.VisitRootAtomics[root: ct.public, eachWire: InsertPublic]; Flatten[cell: ct, data: globalVars, wireName: wireName]; globalVars.GroundNode _ NodeFromRope[GndName, globalVars]; globalVars.GroundNode.input _ TRUE; globalVars.GroundNode.always0 _ TRUE; globalVars.VddNode _ NodeFromRope[VddName, globalVars]; globalVars.VddNode.input _ TRUE; globalVars.VddNode.always1 _ TRUE; IO.PutRope[Globals.StdOut, " \nFinished\n"]; }; InsertWire: PROC [wire: Core.Wire, flatCell: CoreFlat.FlatCellTypeRec, globalVars: Globals.GlobalVars, wireName: HashTable.Table, wireRoot: CoreFlat.WireRoot _ internal] = { node: Globals.Node; flatWire: CoreFlat.FlatWire _ NEW[CoreFlat.FlatWireRec]; flatWire.flatCell _ flatCell; flatWire.wireRoot _ wireRoot; flatWire.wire _ wire; node _ BuildNode[flatWire, globalVars]; [] _ HashTable.Store[table: wireName, key: wire, value: flatWire]; }; Flatten: FlatCellProc = { globalVars: Globals.GlobalVars _ NARROW[data]; SELECT cell.class FROM CoreClasses.transistorCellClass => { gateWire: CoreFlat.FlatWire _ NARROW[HashTable.Fetch[table: wireName, key: cell.public[ORD[CoreClasses.TransistorPort.gate]]].value]; ch1Wire: CoreFlat.FlatWire _ NARROW[HashTable.Fetch[table: wireName, key: cell.public[ORD[CoreClasses.TransistorPort.ch1]]].value]; ch2Wire: CoreFlat.FlatWire _ NARROW[HashTable.Fetch[table: wireName, key: cell.public[ORD[CoreClasses.TransistorPort.ch2]]].value]; tran: CoreClasses.Transistor _ NARROW[cell.data]; fet: Globals.Fet _ BuildFet[gateWire, ch1Wire, ch2Wire, tranTab[tran.type], Real.Float[tran.length], Real.Float[tran.width], globalVars]; atts: CoreAttributes _ NARROW[CoreProperties.GetCellTypeProp[from: cell, prop: crystalAttProp]]; FOR att: CoreAttributes _ atts, att.rest UNTIL att=NIL DO error: Rope.ROPE _ BuildAtt[fet, (SELECT att.first.port FROM gate => gate, ch1 => source, ch2 => drain, ENDCASE => ERROR), Rope.Cat["Cry: ", att.first.attribute]]; IF error#NIL THEN IO.PutF[Globals.StdOut, "Attribute error: %s.\n", IO.rope[error]]; ENDLOOP; }; CoreClasses.recordCellClass => { MarkAtomicPublic: PROC[wire: Core.Wire] = { [] _ HashTable.Store[table: publics, key: wire, value: $Public]; }; InsertInternal: PROC[wire: Core.Wire] = { IF NOT HashTable.Fetch[table: publics, key: wire].found THEN { InsertWire[wire, flatCell, globalVars, wireName]; }; }; rct: CoreClasses.RecordCellType; publics: HashTable.Table _ HashTable.Create[cell.public.size+1]; rct _ NARROW[cell.data]; CoreOps.VisitRootAtomics[root: cell.public, eachWire: MarkAtomicPublic]; CoreOps.VisitRootAtomics[root: rct.internal, eachWire: InsertInternal]; NextCellType[cell, target, flatCell, instance, parent, flatParent, data, wireName, Flatten] }; ENDCASE => { NextCellType[cell, target, flatCell, instance, parent, flatParent, data, wireName, Flatten] }; }; NextCellType: PROC [cell: Core.CellType, target: CoreFlat.FlatCellTypeRec, flatCell: CoreFlat.FlatCellTypeRec, instance: CoreClasses.CellInstance, parent: Core.CellType, flatParent: CoreFlat.FlatCellTypeRec, data: REF ANY, wireName: HashTable.Table, proc: FlatCellProc] = { BindCellType: CoreFlat.UnboundFlatCellProc = { BindPublicToActual: CoreOps.EachWirePairProc = { <> IF publicWire.size=0 THEN { flatWire: CoreFlat.FlatWire _ NARROW[HashTable.Fetch[table: wireName, key: actualWire].value]; [] _ HashTable.Store[table: wireName, key: publicWire, value: flatWire]; }; }; IF CoreOps.VisitBinding[actual: IF instance=NIL OR instance.type#cell THEN previous.public ELSE instance.actual, public: cell.public, eachWirePair: BindPublicToActual] THEN ERROR; proc[cell, target, flatCell, instance, parent, flatParent, data, wireName]; }; previous: Core.CellType _ cell; CoreFlat.NextUnboundCellType[cell, target, flatCell, instance, parent, flatParent, data, BindCellType]; }; SetAtt: PUBLIC PROC [transistor: Core.CellType, port: CoreClasses.TransistorPort, attribute: Core.ROPE] RETURNS [sameTransistor: Core.CellType] = { currentAtts: CoreAttributes _ NARROW[CoreProperties.GetCellTypeProp[from: transistor, prop: crystalAttProp]]; IF transistor.class#CoreClasses.transistorCellClass THEN ERROR; FOR att: CoreAttributes _ currentAtts, att.rest UNTIL att=NIL DO IF att.first.port=port THEN { att.first.attribute _ attribute; EXIT; }; REPEAT FINISHED => { currentAtts _ CONS[[port, attribute], currentAtts]; CoreProperties.PutCellTypeProp[on: transistor, prop: crystalAttProp, value: currentAtts]; }; ENDLOOP; sameTransistor _ transistor; }; GndName: Rope.ROPE _ "public.Gnd"; VddName: Rope.ROPE _ "public.Vdd"; crystalAttProp: ATOM = CoreProperties.RegisterProperty[prop: $CrystalAtt]; tranTab: ARRAY CoreClasses.TransistorType OF REF INTEGER; FOR i: INTEGER IN [0..Model.maxFetTypes) DO ttype: Model.TType _ Model.TypeTable[i]; IF ttype = NIL THEN EXIT; SELECT TRUE FROM Rope.Equal[ttype.name, "NETran"] => tranTab[nE] _ NEW[INTEGER _ i]; Rope.Equal[ttype.name, "PETran"] => tranTab[pE] _ NEW[INTEGER _ i]; Rope.Equal[ttype.name, "NDTran"] => tranTab[nD] _ NEW[INTEGER _ i]; ENDCASE; ENDLOOP; END.