DIRECTORY
Basics,
CD, CDBasics, CDCells, CDDirectory, CDInstances, CDProperties, CDSatellites, CDSymbolicObjects,
CedarProcess,
Core, CoreClasses, CoreOps, CoreProperties,
CoreGeometry,
GList, HashTable, IO, Process,
PWObjects,
Rope, RopeList,
Sinix, SinixD2Intervals, TerminalIO;
Signals
InternalBug: PUBLIC SIGNAL [name: ROPE] = CODE;
CallerBug: PUBLIC SIGNAL [] = CODE;
FusionPropMismatch: PUBLIC SIGNAL [name: ROPE, prop: ATOM, value1, value2: REF] = CODE;
FusionStructureMismatch: PUBLIC SIGNAL [name: ROPE, wire1, wire2: Wire] = CODE;
StructureMismatch: PUBLIC SIGNAL [name: ROPE, actual, subPublic: WireSeq] = CODE;
FusionByNameMismatch: PUBLIC SIGNAL [name, msg: ROPE, wire: Wire] = CODE;
StructuralLoop: PUBLIC SIGNAL [name: ROPE, wire: Wire] = CODE;
Fusion data structure and internal manipulation
NameWire:
TYPE =
RECORD [name:
ROPE, wire: Wire];
FusionData: TYPE = REF FusionDataRec;
FusionDataRec:
TYPE =
RECORD [
mode: Mode, -- to avoid passing it around
nir: CD.Rect, -- Rectangles for which geometry that is strictly inside (edge excluded) is not promoted public
name: ROPE, -- name of the object currently extracted
isAbut: BOOL, -- recording publics depend on this property
fused: HashTable.Table, -- Association [fused -> root] [Wire -> Wire]. If root=NIL, then this wire is a root. Basically all the wires ever created belong to this table.
data: REF, -- different information for Abut and Cell. For abuts it contains the next rects, (REF SinixD2Intervals.Table). For Cell, it is a LIST OF NameWire. This list is not sorted at creation time, and same name may appear several times.
rects: SEQUENCE nbOfLayers: NAT OF SinixD2Intervals.Table -- Association (per layer) [fusion geometry -> wire] [CD.Rect -> IW]. Wire may or may not be a root.
];
AbutData: TYPE = REF AbutDataRec;
AbutDataRec:
TYPE =
RECORD [
inX: BOOL, -- to avoid passing it around
nextRects: SEQUENCE nbOfLayers: NAT OF SinixD2Intervals.Table -- Association (per layer) [fusion geometry -> wire] [CD.Rect -> IW]. Wire may or may not be a root.
];
rect:
PROC [r:
CD.Rect]
RETURNS [
IO.Value] = {
RETURN [IO.rope[IO.PutFR["[%g, %g, %g, %g]", IO.int[r.x1], IO.int[r.y1], IO.int[r.x2], IO.int[r.y2]]]];
};
CreateRoot:
PROC [fusionData: FusionData, size:
NAT, props: Properties ←
NIL]
RETURNS [wire: Wire] = {
EachProperty:
PROC [prop:
ATOM, val:
REF
ANY ←
NIL] = {
newVal:
REF
ANY ←
SELECT prop
FROM
fusionData.mode.decoration.pinsProp => NIL,
fusionData.mode.decoration.geometryProp => NIL,
CoreOps.nameProp => NIL,
ENDCASE => val;
CoreProperties.PutWireProp[wire, prop, newVal];
};
wire ← CoreOps.CreateWires[size: size];
CoreProperties.Enumerate[props, EachProperty];
[] ← HashTable.Store[fusionData.fused, wire, NIL];
};
copyGeometry indicates if this geometry is only going to be used for fusion and does not have to figure in the geometry and pins properties (real geometry versus geometry at the level below).
InsertInstances:
PROC [fusionData: FusionData, transformation: Transformation, instances: Instances, wire: Wire, copyGeometry:
BOOL] = {
IF ~HashTable.Fetch[fusionData.fused, wire].found
THEN SIGNAL InternalBug[fusionData.name];
IF RootWire[fusionData, wire]#wire THEN SIGNAL InternalBug[fusionData.name];
FOR is: Instances ← instances, is.rest
WHILE is#
NIL
DO
inst: Instance ← CoreGeometry.Transform[transformation, is.first];
layers: LayerRange ← fusionData.mode.instanceLayer[inst];
FOR i: NAT IN [layers.min .. layers.max] DO SinixD2Intervals.Insert[fusionData[i], inst, wire] ENDLOOP;
If a pin is found we just note that this is a public wire
IF CoreGeometry.AtEdge[fusionData.nir, inst]
THEN CoreProperties.PutWireProp[wire, $Public, $Public];
ENDLOOP;
IF copyGeometry THEN CoreGeometry.AddGeometry[fusionData.mode.decoration, wire, CoreGeometry.TransformList[transformation, instances]];
};
Fusion external manipulation
Creates a DAG Wire from a HashTable, getting rid of wires that have their father also in the list.
CreateDAGWireSeq:
PROC [table: HashTable.Table]
RETURNS [wire: WireSeq] = {
wires: LIST OF Wire ← NIL;
EachKeyDelete: HashTable.EachPairAction = {
WireDelete:
PROC [wire: Wire] = {
IF ~HashTable.Delete[table, wire] THEN RETURN; -- already done
FOR i:
NAT
IN [0 .. wire.size)
DO
WireDelete[wire[i]];
ENDLOOP;
};
wire: Wire ← NARROW [key];
FOR i:
NAT
IN [0 .. wire.size)
DO
delete all the sons
WireDelete[wire[i]];
ENDLOOP;
};
index: NAT ← 0;
SummarizeWires: HashTable.EachPairAction = {
wire[index] ← NARROW [key];
index ← index+1;
};
[] ← HashTable.Pairs[table, EachKeyDelete];
wire ← CoreOps.CreateWires[HashTable.GetSize[table]];
[] ← HashTable.Pairs[table, SummarizeWires];
IF index#HashTable.GetSize[table] THEN SIGNAL InternalBug[NIL];
};
MakeResult:
PROC [fusionData: FusionData, obj:
CD.Object, cellInstances:
LIST
OF CoreClasses.CellInstance]
RETURNS [record: CellType] = {
decoration: CoreGeometry.Decoration = fusionData.mode.decoration;
publics: HashTable.Table ← HashTable.Create[3];
internals: HashTable.Table ← HashTable.Create[5];
InternalDagIfy: HashTable.EachPairAction = {
WireDagIfy:
PROC [wire: Wire, maxIter:
NAT ← 32] = {
32 should be enough to avoid 815
IF maxIter=0 THEN SIGNAL StructuralLoop[fusionData.name, wire]; -- probably loop in the Wire structure
IF RootWire[fusionData, wire]#wire THEN SIGNAL InternalBug[fusionData.name];
FOR i:
NAT
IN [0 .. wire.size)
DO
wire[i] ← RootWire[fusionData, wire[i]];
WireDagIfy[wire[i], maxIter-1];
ENDLOOP;
};
wire: Wire ← NARROW [key];
IF value#NIL THEN RETURN; -- we dagify only the roots
[] ← HashTable.Store[internals, wire, NIL];
IF CoreProperties.GetWireProp[wire, $Public]#
NIL
THEN {
[] ← HashTable.Store[publics, wire, NIL];
CoreProperties.PutWireProp[wire, $Public, NIL];
};
WireDagIfy[wire];
};
AddDecorateWire: CoreOps.EachWireProc = {
pins: Instances ← NIL;
AddPin: CoreGeometry.EachInstanceProc = {
IF CoreGeometry.AtEdge[fusionData.nir, instance] THEN pins ← CONS [instance, pins];
};
[] ← CoreGeometry.EnumerateGeometry[decoration, wire, AddPin];
CoreGeometry.AddPins[decoration, wire, pins];
};
We find out who are the publics and internals
[] ← HashTable.Pairs[fusionData.fused, InternalDagIfy];
We replace in all instances wires by their roots
FOR list:
LIST
OF CoreClasses.CellInstance ← cellInstances, list.rest
WHILE list#
NIL
DO
instance: CoreClasses.CellInstance ← list.first;
actual: Wire ← instance.actual;
FOR i:
NAT
IN [0 .. actual.size)
DO
wire: Wire ← RootWire[fusionData, actual[i]];
IF ~CoreOps.CorrectConform[wire, instance.type.public[i]] THEN SIGNAL StructureMismatch[fusionData.name, wire, instance.type.public[i]];
actual[i] ← wire;
ENDLOOP;
ENDLOOP;
We build the CellType
record ← CoreClasses.CreateRecordCell[
public: CreateDAGWireSeq[publics], internal: CreateDAGWireSeq[internals],
instances: cellInstances,
name: CDDirectory.Name[obj],
giveNames: TRUE
];
CoreGeometry.PutObject[decoration, record, obj];
We set all pins to be lazy for that record
CoreGeometry.PutRecordLazyPins[decoration, record, fusionData.nir];
We correct previous statement for all explicit geometry
[] ← CoreOps.VisitWireSeq[record.public, AddDecorateWire];
};
LayoutFusionByName:
PROC [fusionData: FusionData] = {
refList: REF LIST OF NameWire = NARROW [fusionData.data];
nameToWire: HashTable.Table = HashTable.Create[mod: 11, equal: HashTable.RopeEqual, hash: HashTable.HashRope];
FOR nameWires:
LIST
OF NameWire ← refList^, nameWires.rest
WHILE nameWires#
NIL
DO
wire: Wire ← RootWire[fusionData, nameWires.first.wire];
name: ROPE ← OrNames[nameWires.first.name, CoreOps.GetShortWireName[wire], fusionData.name];
previousWire: Wire ← NARROW [HashTable.Fetch[nameToWire, name].value];
IF previousWire#
NIL
THEN {
previousWire ← RootWire[fusionData, previousWire];
IF previousWire#wire
THEN {
wire ← StructuredFusion[fusionData, wire, previousWire];
TerminalIO.PutF["Fusion by name for '%g' in cell '%g'.\n", IO.rope[name], IO.rope[fusionData.name]];
CoreProperties.PutWireProp[wire, $FusedByName, $FusedByName];
};
};
[] ← HashTable.Store[nameToWire, name, wire];
[] ← CoreOps.SetShortWireName[wire, name];
ENDLOOP;
};
NoFusionByName:
PROC [fusionData: FusionData] = {
refList: REF LIST OF NameWire = NARROW [fusionData.data];
EachNameWire: HashTable.EachPairAction = {
uniqueID: INT ← 0;
name: ROPE = NARROW [key];
wires: Wires ← NARROW [value];
[] ← CoreOps.SetShortWireName[wires.first, name];
wires ← wires.rest;
IF wires=NIL THEN RETURN;
TerminalIO.PutF["NO fusion by name for '%g' in cell '%g'.\n", IO.rope[name], IO.rope[fusionData.name]];
WHILE wires#
NIL
DO
[] ← CoreOps.SetShortWireName[wires.first, IO.PutFR["%g$%g$", IO.rope[name], IO.int[uniqueID]]];
uniqueID ← uniqueID + 1;
wires ← wires.rest;
ENDLOOP;
};
nameToWires: HashTable.Table = HashTable.Create[mod: 11, equal: HashTable.RopeEqual, hash: HashTable.HashRope]; -- contains (for every name) the list of roots that have it for name
FOR nameWires:
LIST
OF NameWire ← refList^, nameWires.rest
WHILE nameWires#
NIL
DO
name: ROPE ← nameWires.first.name;
wire: Wire = RootWire[fusionData, nameWires.first.wire];
wires: Wires ← NARROW [HashTable.Fetch[nameToWires, name].value];
IF NOT CoreOps.Member[wires, wire] THEN wires ← CONS [wire, wires];
[] ← HashTable.Store[nameToWires, name, wires];
ENDLOOP;
[] ← HashTable.Pairs[nameToWires, EachNameWire];
};
SchematicsFusionByName:
PROC [fusionData: FusionData] = {
refList: REF LIST OF NameWire = NARROW [fusionData.data];
nameToWire: HashTable.Table = HashTable.Create[mod: 11, equal: HashTable.RopeEqual, hash: HashTable.HashRope];
names: ROPES ← NIL;
We first fuse all the nameWire with same name, and at the same time prepare the list of all the names that have components
FOR nameWires:
LIST
OF NameWire ← refList^, nameWires.rest
WHILE nameWires#
NIL
DO
wire: Wire ← RootWire[fusionData, nameWires.first.wire];
name: ROPE ← OrNames[nameWires.first.name, CoreOps.GetShortWireName[wire], fusionData.name];
previousWire: Wire ← NARROW [HashTable.Fetch[nameToWire, name].value];
hasComponents: BOOL = CoreOps.ParseWireName[name].components#NIL;
IF previousWire#NIL THEN previousWire ← RootWire[fusionData, previousWire];
IF previousWire#
NIL
AND previousWire#wire
THEN wire ← StructuredFusion[fusionData, wire, previousWire]
ELSE IF hasComponents THEN names ← CONS [name, names];
[] ← HashTable.Store[nameToWire, name, wire];
IF NOT hasComponents THEN [] ← CoreOps.SetShortWireName[wire, name];
ENDLOOP;
We sort the names, using the trick that foo[2].mumble or foo[2][3] are after foo[2] in the lexicographic order
names ← RopeList.Sort[names, RopeList.Compare];
FOR list:
ROPES ← RopeList.Sort[names, RopeList.Compare], list.rest
WHILE list#
NIL
DO
name: ROPE ← list.first;
wire: Wire = RootWire[fusionData, NARROW [HashTable.Fetch[nameToWire, name].value]];
base: ROPE; components: ROPES ← NIL;
matchingWire: Wire;
[base, components] ← CoreOps.ParseWireName[name];
matchingWire ← NARROW [HashTable.Fetch[nameToWire, base].value];
WHILE components#
NIL
DO
index: INT ← -1;
IF matchingWire=NIL THEN SIGNAL FusionByNameMismatch[fusionData.name, IO.PutFR["Path name %g does not correspond to any wire", IO.rope[name]], wire];
matchingWire ← RootWire[fusionData, matchingWire];
FOR i:
NAT
IN [0 .. matchingWire.size)
DO
subWireName: ROPE ← CoreOps.GetShortWireName[matchingWire[i]];
IF subWireName=NIL THEN subWireName ← IO.PutR1[IO.int[i]];
IF Rope.Equal[subWireName, components.first]
THEN {
IF index=-1 THEN index ← i ELSE FusionByNameMismatch[fusionData.name, IO.PutFR["Current wire has 2 or more sub-wires with field `%g'", IO.rope[components.first]], wire];
};
ENDLOOP;
IF index=-1 THEN SIGNAL FusionByNameMismatch[fusionData.name, IO.PutFR["Current wire does not have a sub-wire with field `%g'", IO.rope[components.first]], wire];
matchingWire ← matchingWire[index];
components ← components.rest;
ENDLOOP;
[] ← StructuredFusion[fusionData, matchingWire, wire];
ENDLOOP;
};
AddNameWire:
PROC [fusionData: FusionData, name:
ROPE, wire: Wire] = {
nameWires: REF LIST OF NameWire ← NARROW [fusionData.data];
nameWires^ ← CONS [[name: name, wire: wire], nameWires^];
};
The following PROC implements Fisher-Galler fusion, not for efficiency, but for simplicity
RootWire:
PROC [fusionData: FusionData, wire: Wire]
RETURNS [rootWire: Wire] = {
IF wire=NIL THEN SIGNAL InternalBug[fusionData.name];
rootWire ← NARROW [HashTable.Fetch[fusionData.fused, wire].value];
IF rootWire=NIL THEN RETURN [wire];
IF rootWire=wire THEN SIGNAL InternalBug[fusionData.name];
rootWire ← RootWire[fusionData, rootWire];
[] ← HashTable.Replace[fusionData.fused, wire, rootWire];
};
This mechanism could be exported if we wanted that.
PropFusionProc:
TYPE =
PROC [prop:
ATOM, value1, value2:
REF
ANY, name:
ROPE]
RETURNS [value:
REF
ANY];
NameFusion: PropFusionProc = {
value ← OrNames[NARROW [value1], NARROW [value2], name];
};
DefaultFusion: PropFusionProc = {
IF value1#NIL AND value2#NIL AND value1#value2 THEN SIGNAL FusionPropMismatch[name, prop, value1, value2];
value ← IF value1=NIL THEN value2 ELSE value1;
};
Appends the properties of fused to the ones of root, but treating short names specially
FuseProperties:
PUBLIC
PROC [mode: Sinix.Mode, fused, root: Wire, name:
ROPE] = {
EachProperty:
PROC [prop:
ATOM, val:
REF
ANY] = {
rootValue: REF ← CoreProperties.GetWireProp[root, prop];
SELECT prop
FROM
CoreOps.nameProp => CoreProperties.PutWireProp[root, prop, NameFusion[prop, val, rootValue, name]];
mode.decoration.geometryProp => CoreGeometry.AddGeometry[mode.decoration, root, CoreGeometry.GetGeometry[mode.decoration, fused]];
mode.decoration.pinsProp => CoreGeometry.AddPins[mode.decoration, root, CoreGeometry.GetPins[mode.decoration, fused]]; -- this never happens during Cell or Abut extraction, because pins are not yet there, but might occur when called from SisyphImpl.ProcessGlobalName
ENDCASE => CoreProperties.PutWireProp[root, prop, DefaultFusion[prop, val, rootValue, name]];
};
CoreProperties.Enumerate[fused.properties, EachProperty];
};
This proc really does the fusion of fused and root, by wiping fused of some tables, and adding interesting properties of fused to root.
DeleteFused:
PROC [fusionData: FusionData, fused, root: Wire] = {
IF ~HashTable.Fetch[fusionData.fused, fused].found THEN SIGNAL InternalBug[fusionData.name];
IF RootWire[fusionData, fused]#fused THEN SIGNAL InternalBug[fusionData.name];
IF ~HashTable.Fetch[fusionData.fused, root].found THEN SIGNAL InternalBug[fusionData.name];
IF RootWire[fusionData, root]#root THEN SIGNAL InternalBug[fusionData.name];
IF fused=root THEN SIGNAL InternalBug[fusionData.name]; -- should never occur
FuseProperties[fusionData.mode, fused, root, fusionData.name];
fused.properties ← NIL; -- to help GC
[] ← HashTable.Store[fusionData.fused, fused, root];
};
StructuredFusion:
PROC [fusionData: FusionData, wire1, wire2: Wire]
RETURNS [wire: Wire] = {
wire1 ← RootWire[fusionData, wire1];
wire2 ← RootWire[fusionData, wire2];
IF wire1=wire2 THEN RETURN [wire1];
SELECT
TRUE
FROM
wire1=wire2 => wire ← wire1;
wire1.size=0 => {DeleteFused[fusionData, wire1, wire2]; wire ← wire2};
wire2.size=0 => {DeleteFused[fusionData, wire2, wire1]; wire ← wire1};
wire1.size=wire2.size => {
wire ← CreateRoot[fusionData, wire1.size];
FOR i:
NAT
IN [0 .. wire.size)
DO
wire[i] ← StructuredFusion[fusionData, wire1[i], wire2[i]];
ENDLOOP;
DeleteFused[fusionData, wire1, wire];
DeleteFused[fusionData, wire2, wire];
};
ENDCASE => SIGNAL FusionStructureMismatch[fusionData.name, wire1, wire2];
};
FindTouchingWires:
PROC [fusionData: FusionData, transformation: Transformation, geometry: Instances]
RETURNS [touchingWires:
LIST
OF Wire ←
NIL] = {
FOR insts: Instances ← geometry, insts.rest
WHILE insts#
NIL
DO
inst: Instance ← CoreGeometry.Transform[transformation, insts.first];
layers: LayerRange ← fusionData.mode.instanceLayer[inst];
rect: CD.Rect ← CoreGeometry.InlineBBox[inst];
InternalFindTouchingWires:
PROC [instance: Instance, wire: Wire] = {
wire ← RootWire[fusionData, wire];
IF ~HashTable.Fetch[fusionData.fused, wire].found THEN SIGNAL InternalBug[fusionData.name];
IF CoreOps.Member[touchingWires, wire] THEN RETURN;
IF fusionData.mode.touchProc[instance, inst] THEN touchingWires ← CONS [wire, touchingWires];
};
FOR i:
NAT
IN [layers.min .. layers.max]
DO
SinixD2Intervals.Enumerate[fusionData[i], InternalFindTouchingWires, rect];
ENDLOOP;
ENDLOOP;
};
Other Internal utilities
FusionGeometry:
PROC [fusionData: FusionData, transformation: Transformation, geometry: Instances, copyGeometry:
BOOL]
RETURNS [wire: Wire ←
NIL] = {
touchingWires: LIST OF Wire ← FindTouchingWires[fusionData, transformation, geometry];
IF touchingWires=
NIL
THEN {
wire ← CreateRoot[fusionData, 0];
InsertInstances[fusionData, transformation, geometry, wire, copyGeometry];
RETURN;
};
wire ← touchingWires.first;
InsertInstances[fusionData, transformation, geometry, wire, copyGeometry];
touchingWires ← touchingWires.rest;
WHILE touchingWires#
NIL
DO
fused: Wire ← touchingWires.first;
wire ← StructuredFusion[fusionData, fused, wire];
touchingWires ← touchingWires.rest;
ENDLOOP;
};
The complexity of this proc is partly due to the fact that we have a DAG
FusionWire:
PROC [fusionData: FusionData, dagTable: HashTable.Table, public: Wire, transformation: Transformation, copyProps:
BOOL]
RETURNS [actual: Wire] = {
prevActual: Wire ← NARROW [HashTable.Fetch[dagTable, public].value];
structActual: Wire;
publicName: ROPE ← CoreOps.GetShortWireName[public];
pins: Instances ← CoreGeometry.GetPins[fusionData.mode.decoration, public];
IF prevActual#NIL THEN RETURN [prevActual];
structActual ← CreateRoot[fusionData, public.size, IF copyProps THEN public.properties ELSE NIL];
FOR i:
NAT
IN [0 .. public.size)
DO
structActual[i] ← FusionWire[fusionData, dagTable, public[i], transformation, copyProps];
ENDLOOP;
actual ←
IF pins=
NIL
THEN structActual
ELSE StructuredFusion[
fusionData, structActual,
FusionGeometry[fusionData, transformation, pins, copyProps]
];
IF copyProps AND publicName#NIL THEN AddNameWire[fusionData, publicName, actual];
[] ← HashTable.Store[dagTable, public, actual];
};
FusionWireSeq:
PROC [fusionData: FusionData, public: WireSeq, transformation: Transformation]
RETURNS [actual: Wire] = {
dagTable: HashTable.Table ← HashTable.Create[3];
actual ← CoreOps.CreateWires[public.size];
FOR i:
NAT
IN [0 .. actual.size)
DO
actual[i] ← FusionWire[fusionData, dagTable, public[i], transformation, FALSE];
ENDLOOP;
};
Attention: modifies physically its argument!
SortInstances:
PROC [instances:
LIST
OF
CD.Instance]
RETURNS [sorted:
LIST
OF
CD.Instance ←
NIL] = {
Eval:
PROC [inst:
CD.Instance]
RETURNS [
INT] = {
pos: CD.Position ← CDBasics.BaseOfRect[CDInstances.InstRectI[inst]];
RETURN [pos.x+pos.y];
};
Compare: GList.CompareProc = {
RETURN [Basics.CompareINT[Eval[NARROW [ref1]], Eval[NARROW [ref2]]]];
};
sorted ← NARROW [GList.Sort[instances, Compare]];
};
Extraction
cacheProp: ATOM ← PWObjects.RegisterProp[$SinixCache, FALSE, TRUE];
Extract:
PUBLIC ExtractProc = {
cache: Cache ← NARROW [CDProperties.GetObjectProp[obj, cacheProp]];
CDProperties.PutObjectProp[obj, satellitesProp, CDSatellites.GetSatelliteRopes[obj]];
IF cache#NIL AND cache.mode=mode AND mode.equalProc[obj, cache.properties, cache.userData, properties, userData] THEN RETURN [result: cache.result, props: cache.props];
BEGIN
priority: CedarProcess.Priority ← CedarProcess.GetPriority[];
atom: ATOM ← NARROW [CDProperties.GetListProp[properties, mode.extractProcProp]];
extractProc: ExtractProc;
IF atom=NIL THEN atom ← NARROW [CDProperties.GetObjectProp[obj, mode.extractProcProp]];
IF atom=NIL THEN atom ← NARROW [CDProperties.GetProp[obj.class, mode.extractProcProp]];
IF atom=
NIL
THEN extractProc ← ExtractExpand
ELSE {
refProc: REF ExtractProc ← NARROW [HashTable.Fetch[registeredExtractProcs, atom].value];
IF refProc=
NIL
THEN {
TerminalIO.PutF["*** ExtractProc $%g not registered. You must run the program defining it.\n", IO.atom[atom]]; SIGNAL CallerBug[];
};
extractProc ← refProc^;
};
CedarProcess.CheckAbort[];
CedarProcess.SetPriority[background];
Process.Yield[];
[result, props] ← extractProc[obj, mode, properties, userData];
We detect trivial causes of bugs!
WITH result
SELECT
FROM
wire: Wire => {};
wires: Wires => {};
cellType: CellType => IF NOT CoreGeometry.HasObject[mode.decoration, cellType] THEN SIGNAL CallerBug[]; -- decorations missing!
ENDCASE => IF result#NIL THEN SIGNAL CallerBug[]; -- probably some ExtractProc is grossly wrong
CedarProcess.SetPriority[priority];
CDProperties.PutObjectProp[obj, cacheProp, NEW [CacheRec ← [mode: mode, properties: properties, userData: userData, result: result, props: props]]];
END;
};
registeredExtractProcs: HashTable.Table ← HashTable.Create[];
RegisterExtractProc:
PUBLIC
PROC [key:
ATOM, extractProc: ExtractProc] = {
IF NOT HashTable.Store[registeredExtractProcs, key, NEW [ExtractProc ← extractProc]] THEN TerminalIO.PutF["ExtractProc overwritten for $%g.\n", IO.atom[key]];
};
ExtractCell:
PUBLIC ExtractProc = {
ir: CD.Rect ← CD.InterestRect[obj];
cdInstances: LIST OF CD.Instance ← NIL;
nbOfInstances: INT = CDCells.CountInstances[obj];
fusionData: FusionData ← NEW [FusionDataRec[mode.nbOfLayers]];
currentInstances: LIST OF CoreClasses.CellInstance ← NIL;
EachInstance: CDCells.InstEnumerator = {cdInstances ← CONS [inst, cdInstances]};
[] ← CDCells.EnumerateInstances[obj, EachInstance];
cdInstances ← SortInstances[cdInstances]; -- Modified in place!
TerminalIO.PutF["Extracting [%g] cell %g (bbox: %g, instances: %g)\n", IO.rope[IF mode.fusionByName=none THEN IO.PutFR["%g[%g]", IO.rope[mode.decoration.name], IO.int[NARROW [userData, REF INT]^]] ELSE mode.decoration.name], IO.rope[CDDirectory.Name[obj]], rect[obj.bbox], IO.int[nbOfInstances]];
fusionData.mode ← mode; fusionData.name ← CDDirectory.Name[obj];
fusionData.nir ←
IF mode.fusionByName=none
THEN CDBasics.Extend[ir, - NARROW [userData, REF INT]^] ELSE ir;
fusionData.fused ← HashTable.Create[3]; fusionData.data ← NEW [LIST OF NameWire ← NIL]; fusionData.isAbut ← FALSE;
FOR i:
NAT
IN [0 .. mode.nbOfLayers)
DO
fusionData[i] ← SinixD2Intervals.Create[
logHashSize: SELECT TRUE FROM nbOfInstances<=7 => 3, nbOfInstances<=60 => 5, ENDCASE => 11,
range: obj.bbox
];
ENDLOOP;
CDProperties.PutObjectProp[obj, satellitesProp, CDSatellites.GetSatelliteRopes[obj]]; -- to reinforce invariantes on the object (restriction of CDSatellites)
WHILE cdInstances#
NIL
DO
cdInstance: CD.Instance ← cdInstances.first;
subUserData: REF ← userData;
subResult: REF; subProps: Properties;
CDProperties.PutInstanceProp[cdInstance, satellitesProp, CDSatellites.GetSatelliteRopes[cdInstance]];
IF mode.fusionByName=none
THEN {
UnionOverlap:
PROC [rect:
CD.Rect] = {
interSize: CD.Position;
IF overlap+overlap>bbox.x2-bbox.x1 OR overlap+overlap>bbox.y2-bbox.y1 THEN RETURN;
interSize ← CDBasics.SizeOfRect[CDBasics.Intersection[rect, CDBasics.Extend[bbox, -overlap]]];
overlap ← MAX [overlap, MIN [interSize.x, interSize.y]];
IF overlap+overlap>bbox.x2-bbox.x1 OR overlap+overlap>bbox.y2-bbox.y1 THEN RETURN;
interSize ← CDBasics.SizeOfRect[CDBasics.Intersection[rect, CDBasics.Extend[bbox, -overlap]]];
overlap ← MAX [overlap, MIN [interSize.x, interSize.y]];
};
EachInstanceOverlap: CDCells.InstEnumerator = {
IF inst#cdInstance THEN UnionOverlap[CDInstances.InstRectO[inst]];
};
Compute the right overlap of theses cells on this instance
bbox: CD.Rect ← CDInstances.InstRectI[cdInstance];
overlap: INT ← 0;
UnionOverlap[[FIRST[INT], FIRST[INT], fusionData.nir.x1, LAST[INT]]];
UnionOverlap[[fusionData.nir.x2, FIRST[INT], LAST[INT], LAST[INT]]];
UnionOverlap[[FIRST[INT], FIRST[INT], LAST[INT], fusionData.nir.y1]];
UnionOverlap[[FIRST[INT], fusionData.nir.y2, LAST[INT], LAST[INT]]];
[] ← CDCells.EnumerateInstances[obj, EachInstanceOverlap];
subUserData ← NEW [INT ← overlap];
};
[subResult, subProps] ← Extract[cdInstance.ob, mode, cdInstance.properties, subUserData];
IF subResult#
NIL
THEN
WITH subResult
SELECT
FROM
subWire: Wire => {
[] ← FusionWire[fusionData, HashTable.Create[1], subWire, cdInstance.trans, TRUE];
};
subWires: Wires => {
dagTable: HashTable.Table ← HashTable.Create[3];
WHILE subWires#
NIL
DO
[] ← FusionWire[fusionData, dagTable, subWires.first, cdInstance.trans, TRUE];
subWires ← subWires.rest;
ENDLOOP;
};
subCellType: CellType => {
bbox: CD.Rect ← CDInstances.BoundingRectO[cdInstances.rest];
instance: CoreClasses.CellInstance ← CoreClasses.CreateInstance[
actual: FusionWireSeq[fusionData, subCellType.public, cdInstance.trans],
type: subCellType, props: subProps
];
it is impossible here to check for conformance, since fusion might have been done differently in different parts of the DAG
CoreGeometry.PutTrans[mode.decoration, instance, cdInstance.trans];
currentInstances ← CONS [instance, currentInstances];
We try to simplify fusionData by getting rid of all pieces of geometry which are outside the bounding box for sure
FOR i:
NAT
IN [0 .. mode.nbOfLayers)
DO
SinixD2Intervals.DeleteOutside[fusionData[i], bbox];
ENDLOOP;
};
ENDCASE => SIGNAL InternalBug[fusionData.name];
cdInstances ← cdInstances.rest;
ENDLOOP;
Time to do fusion by name!
SELECT mode.fusionByName
FROM
layout => LayoutFusionByName[fusionData];
none => NoFusionByName[fusionData];
schematics => SchematicsFusionByName[fusionData];
ENDCASE => CallerBug[]; --no way to do fusionByName in this mode!
result ← MakeResult[fusionData, obj, currentInstances];
};
AbutFusionWire:
PROC [fusionData: FusionData, dagTable: HashTable.Table, public: Wire, transformation: Transformation, subIr:
CD.Rect]
RETURNS [actual: Wire] = {
RecordEachPin: CoreGeometry.EachInstanceProc = {
sides: CoreGeometry.Sides ← CoreGeometry.GetSides[subIr, instance];
IF (~inX
AND sides[bottom])
OR (inX
AND sides[left])
THEN thesePins ← CONS [instance, thesePins];
IF (~inX
AND sides[top])
OR (inX
AND sides[right])
THEN {
inst: Instance ← CoreGeometry.Transform[transformation, instance];
layers: LayerRange ← mode.instanceLayer[inst];
FOR i: NAT IN [layers.min .. layers.max] DO SinixD2Intervals.Insert[abutData[i], inst, structActual] ENDLOOP;
};
IF
NOT CoreGeometry.TransfedNotAtEdge[transformation, nir, instance]
THEN CoreProperties.PutWireProp[structActual, $Public, $Public];
};
prevActual: Wire ← NARROW [HashTable.Fetch[dagTable, public].value];
structActual: Wire;
abutData: AbutData ← NARROW [fusionData.data];
thesePins: Instances ← NIL; -- not transformed
mode: Mode ← fusionData.mode;
inX: BOOL ← abutData.inX;
nir: CD.Rect ← fusionData.nir;
IF prevActual#NIL THEN RETURN [prevActual];
structActual ← CreateRoot[fusionData, public.size];
[] ← CoreGeometry.EnumeratePins[fusionData.mode.decoration, public, RecordEachPin];
FOR i:
NAT
IN [0 .. public.size)
DO
structActual[i] ← AbutFusionWire[fusionData, dagTable, public[i], transformation, subIr];
ENDLOOP;
actual ←
IF thesePins=
NIL
THEN structActual
ELSE StructuredFusion[
fusionData, structActual,
FusionGeometry[fusionData, transformation, thesePins, FALSE]
];
[] ← HashTable.Store[dagTable, public, actual];
};
AbutFusionWireSeq:
PROC [fusionData: FusionData, public: WireSeq, transformation: Transformation, subIr:
CD.Rect]
RETURNS [actual: Wire] = {
dagTable: HashTable.Table ← HashTable.Create[3];
actual ← CoreOps.CreateWires[public.size];
FOR i:
NAT
IN [0 .. actual.size)
DO
actual[i] ← AbutFusionWire[fusionData, dagTable, public[i], transformation, subIr];
ENDLOOP;
};
ExtractAbut:
PUBLIC ExtractProc = {
ir: CD.Rect ← CD.InterestRect[obj];
range: CD.Rect ← obj.bbox;
fusionData: FusionData ← NEW [FusionDataRec[mode.nbOfLayers]];
abutData: AbutData ← NEW [AbutDataRec[mode.nbOfLayers]];
currentInstances: LIST OF CoreClasses.CellInstance ← NIL;
count: NAT ← 0;
EachAbutSubObject: PWObjects.EachSubObjectProc = {
subIr: CD.Rect ← CD.InterestRect[subObject]; -- in the transformation coordonnate system
subResult: REF; subCellType: CellType; subProps: Properties;
instance: CoreClasses.CellInstance;
transformation: Transformation = [CDBasics.SubPoints[pos, CDBasics.BaseOfRect[subIr]]];
[subResult, subProps] ← Extract[subObject, mode, NIL, userData];
subCellType ← NARROW [subResult];
instance ← CoreClasses.CreateInstance[
actual: AbutFusionWireSeq[fusionData, subCellType.public, transformation, subIr],
type: subCellType, props: subProps
];
IF ~CoreOps.CorrectConform[instance.actual, subCellType.public] THEN SIGNAL StructureMismatch[fusionData.name, instance.actual, subCellType.public];
FOR i:
NAT
IN [0 .. mode.nbOfLayers)
DO
table: SinixD2Intervals.Table ← fusionData[i];
fusionData[i] ← abutData[i]; abutData[i] ← table;
SinixD2Intervals.DeleteOutside[table, SinixD2Intervals.universe];
ENDLOOP;
CoreGeometry.PutTrans[mode.decoration, instance, transformation];
currentInstances ← CONS [instance, currentInstances];
};
CountAbutSubObject: PWObjects.EachSubObjectProc = {count ← count + 1};
PWObjects.EnumerateSubObjects[obj, CountAbutSubObject];
fusionData.mode ← mode; fusionData.name ← CDDirectory.Name[obj]; fusionData.fused ← HashTable.Create[3]; fusionData.data ← abutData; fusionData.isAbut ← TRUE;
fusionData.nir ←
IF mode.fusionByName=none
THEN CDBasics.Extend[ir, - NARROW [userData, REF INT]^] ELSE ir;
abutData.inX ← obj.class=PWObjects.abutXClass;
FOR i:
NAT
IN [0 .. mode.nbOfLayers)
DO
abutData[i] ← SinixD2Intervals.Create[range: range];
ENDLOOP;
FOR i:
NAT
IN [0 .. mode.nbOfLayers)
DO
fusionData[i] ← SinixD2Intervals.Create[range: range];
ENDLOOP;
TerminalIO.PutF["Extracting [%g] abut %g (bbox: %g, instances: %g)\n", IO.rope[mode.decoration.name], IO.rope[CDDirectory.Name[obj]], rect[obj.bbox], IO.int[count]];
The main loop over "instances". Attention, we are assuming here that we are seing instances from left to right and bottom to top [this assumption is made in AbutFusionWire by the chosen sides]
PWObjects.EnumerateSubObjects[obj, EachAbutSubObject];
result ← MakeResult[fusionData, obj, currentInstances];
};
ExtractExpand:
PUBLIC ExtractProc = {
newObj: CD.Object ← CDDirectory.Expand[obj, NIL, NIL].new;
TerminalIO.PutF["Expanding [%g] object %g of class %g\n", IO.rope[mode.decoration.name], IO.rope[CDDirectory.Name[obj]], IO.atom[obj.class.objectType]];
IF newObj=NIL THEN SIGNAL CallerBug[]; -- no expand proc found for this object that we do not know how to extract!
RETURN Extract[newObj, mode, CDProperties.DAppendProps[obj.properties, properties], userData];
};
OrNames:
PROC [name1, name2, objName:
ROPE]
RETURNS [name:
ROPE ←
NIL] = {
IF name1=NIL THEN RETURN [name2];
IF name2=NIL THEN RETURN [name1];
IF Rope.Equal[name1, name2] THEN RETURN [name1];
SIGNAL FusionPropMismatch[objName, CoreOps.nameProp, name1, name2];
};
NameFromSatellites:
PROC [obj: Object, properties:
CD.PropList]
RETURNS [name:
ROPE ←
NIL] = {
objName: ROPE = CDDirectory.Name[obj];
name ← NARROW [CDProperties.GetListProp[properties, $SignalName]];
FOR ropes:
ROPES ←
NARROW [CDProperties.GetListProp[properties, satellitesProp]], ropes.rest
WHILE ropes#NIL DO name ← OrNames[name, ropes.first, objName] ENDLOOP;
FOR ropes:
ROPES ←
NARROW [CDProperties.GetObjectProp[obj, satellitesProp]], ropes.rest
WHILE ropes#NIL DO name ← OrNames[name, ropes.first, objName] ENDLOOP;
};
ExtractRect:
PUBLIC ExtractProc = {
wire: Wire;
IF obj.layer=CD.shadeLayer OR obj.layer=CD.errorLayer OR obj.layer=CD.backgroundLayer OR obj.layer=CD.outlineLayer OR obj.layer=CD.selectionLayer OR obj.layer=CD.commentLayer THEN RETURN [NIL];
wire ← CoreOps.CreateWire[name: NameFromSatellites[obj, properties]];
CoreGeometry.PutPins[mode.decoration, wire, LIST [[obj]]];
result ← wire;
};
ExtractPin:
PUBLIC ExtractProc = {
wire: Wire;
instance: CD.Instance ← CDInstances.NewInst[ob: obj, properties: properties];
pinName: ROPE ← CDSymbolicObjects.GetName[instance];
IF NOT Rope.Equal[NameFromSatellites[obj, properties], pinName] THEN SIGNAL CallerBug[];
wire ← CoreOps.CreateWire[name: pinName];
CoreGeometry.PutPins[mode.decoration, wire, LIST [[CoreGeometry.CDPinToCoreGeometryPin[obj, properties]]]];
result ← wire;
};
ExtractAtomic:
PUBLIC ExtractProc = {
wire: Wire;
wire ← CoreOps.CreateWire[name: NameFromSatellites[obj, properties]];
CoreGeometry.PutPins[mode.decoration, wire, LIST [[obj]]];
result ← wire;
};
ExtractNull:
PUBLIC ExtractProc = {result ←
NIL};
LazyPinsEnumerate: CoreGeometry.LazyEnumerateProc = {
node: PWObjects.Node ← NARROW [data1];
rir: REF CD.Rect ← NARROW [data2];
FOR i:
NAT
IN [0 .. node.size)
DO
instance: CoreGeometry.Instance = [node[i].object, [node[i].position]];
IF CoreGeometry.AtEdge[rir^, instance] THEN quit ← eachInstance[instance];
IF quit THEN RETURN;
ENDLOOP;
};
LazyGeometryEnumerate: CoreGeometry.LazyEnumerateProc = {
node: PWObjects.Node ← NARROW [data1];
FOR i:
NAT
IN [0 .. node.size)
DO
quit ← eachInstance[[node[i].object, [node[i].position]]];
IF quit THEN RETURN;
ENDLOOP;
};
ExtractRouting: ExtractProc = {
cellType: CellType;
routing: PWObjects.RoutingSpecific = NARROW [obj.specific];
publics: LIST OF Wire ← NIL;
TerminalIO.PutF["Extracting [%g] routing %g (nodes: %g)\n", IO.rope[mode.decoration.name], IO.rope[CDDirectory.Name[obj]], IO.int[routing.size]];
FOR i:
NAT
IN [0 .. routing.size)
DO
node: PWObjects.Node = routing[i];
name: ROPE = NARROW [CDProperties.GetListProp[node.properties, $SignalName]];
wire: Wire ← CoreOps.CreateWire[name: name];
CoreGeometry.PutLazyGeometry[mode.decoration, wire, LazyGeometryEnumerate, node];
CoreGeometry.PutLazyPins[mode.decoration, wire, LazyPinsEnumerate, node, NEW [CD.Rect ← routing.ir]];
publics ← CONS [wire, publics];
ENDLOOP;
We build the CellType
cellType ← CoreClasses.CreateRecordCell[
public: CoreOps.CreateWire[publics],
internal: CoreOps.CreateWire[publics],
instances: NIL,
name: CDDirectory.Name[obj]
];
CoreGeometry.PutObject[mode.decoration, cellType, obj];
result ← cellType;
};
Initialization
RegisterExtractProc[$ExtractCell, ExtractCell];
RegisterExtractProc[$ExtractAbut, ExtractAbut];
RegisterExtractProc[$ExtractExpand, ExtractExpand];
RegisterExtractProc[$ExtractRect, ExtractRect];
RegisterExtractProc[$ExtractPin, ExtractPin];
RegisterExtractProc[$ExtractAtomic, ExtractAtomic];
RegisterExtractProc[$ExtractNull, ExtractNull];
RegisterExtractProc[$ExtractRouting, ExtractRouting];
END.