--routedefs.mesa

DIRECTORY  IODefs;

RouteDefs:DEFINITIONS = BEGIN

--ROUTEDEFS

Circuit:TYPE=INTEGER;
RunNo:TYPE=INTEGER;
bigRun:RunNo=10000;
EventNo:TYPE=INTEGER;
ChannelNo:TYPE=INTEGER;
InterNo:TYPE=INTEGER;
Lambda:TYPE=INTEGER;
bigLambda:Lambda=32000;
NetNo:TYPE=INTEGER;
JoinType:TYPE=INTEGER;
InterType:TYPE=INTEGER;
noOffset:INTEGER=1000;

CoordL:TYPE=RECORD[x,y:INTEGER_0]; --in lambda
CoordC:TYPE=RECORD[x,y:INTEGER_0]; --in events
nilG:Link=[];
outOfSight:CoordL=[-20,-20];

BoolPtr:TYPE=POINTER TO BOOLEAN;
ProcedureDescriptor:TYPE=RECORD[doit,printIt:PROCEDURE,enabler:BoolPtr];
Where:TYPE={top,bottom,left,right}_top;
What:TYPE={blue,red,both};
Level:TYPE={red,blue};
ConnKind:TYPE={none,left,right,tee,edge}_none;
Side:TYPE={n,s,e,w,x}_x;
Turn:TYPE={se,sw,ne,nw,hor,vert}; --relative to inter
RectKind:TYPE={none,cell,channel,inter,culDeSacR,culDeSacL,box,bend5,bend9,bend6,bend10,wallL,wallR};
Orient:TYPE={unknown,hor,vert,inter,bend};
Huggers:TYPE=RECORD[ch,n,s,e,w:Side_x,valid:BOOLEAN_FALSE];
Levelers:TYPE=RECORD[n,s,e,w:[0..6]_0];
Margins:TYPE=RECORD[n,s,e,w:[0..16)_3];

--LOOK HERE !!

Problem:TYPE=RECORD[cells:CellListPtr_NIL, chipSize:CoordL_[],
  wirelist:NetListPtr_NIL];

Rectangle:TYPE=RECORD[
  pos:CoordL,                   --Rectangle.CreateRectangle, Rectless.Compress
  sizeL:CoordL,                 --Rectangle.CreateRectangle, Rectless.Compress
  l:Link_[],                    --Rectless.CreateSecondaryLists
  n,s,e,w:RectanglePtr_NIL,     --Rectless.Compress
  nw,sw,ne,se,en,wn,es,ws:Lambda_0,
  nSource,sSource,              --Rectangle.CreateRectangle
  wSource,eSource:BOOLEAN_FALSE,--Rectangle.CreateRectangle
  channelNo:ChannelNo_0,        --Rectangle.CreateRectangle
  sizeC:CoordC,                 --Rectless.ComputeSizeC
  junction:JunctionPtr_NIL,     --Rectless.CreateSecondaryLists
  events:EventListPtr_NIL,      --Rectangle.AddEvent, Rectless.Compress
  orient:Orient_unknown,        --Rectless.MarkNatureAndOrientAndWhere
  nature:RectKind_none,         --Rectless.MarkNatureAndOrientAndWhere
  runs:RunListPtr_NIL,          --Runs.AddRun
  conns:ConnListPtr_NIL,
  levelers:Levelers,            --Rectless.*MakeLevelers*
  margins:Margins,
  used:INTEGER_0,
  avail:INTEGER_0,
  usedCircuit:INTEGER_0
  ];

Event:TYPE=RECORD[
  index:INTEGER_-1,              --Rectless.SetEventNumbers
  circuit:Circuit_0,             --Rectangle.AddEvent
  where:Where,                   --Rectless.xxx
  side:Side,                     --Rectangle.AddEvent
  level:What_both,
  offset:Lambda_noOffset,        --Rectangle.AddEvent, Rectless.AdjustOffset
  net:NetPtr_NIL,                --Rectangle.AddEvent
  opposite:EventPtr_NIL,         --Rectless.SetEventNumbers
  next,prev:EventPtr_NIL,        --Rectless.SetnextAndPrevEvents
  conn:ConnPtr_NIL               --Conn.MakeEdgeConn
  ];

--  Source1 = Runs.MakeRun, Runs.FixUpJunctionWithInters, Crosses.SplitCon

Run:TYPE=RECORD[
  circuit:Circuit_0,             --Source1
  run:RunNo_0,                   --Runs.AssignCulDeSac/TopDown/BottomUpRunNo
  start,end:EventNo_0,           --Source1
  startOff,endOff:INTEGER_0,     --Crosses.SetRunOffset
  chan:RectanglePtr_NIL,         --Source1
  path:PathPtr_NIL,              --Runs.MakeRun/FixUpJunctionWithInters
  order:BOOLEAN_FALSE,
  stU,stD,stL:BOOLEAN_FALSE,     --Runs.MakeRun/FixUpJunctionWithInters,
  endU,endD,endL:BOOLEAN_FALSE,  --Runs.MakeRun/FixUpJunctionWithInters
  startOffX,endOffX:Lambda_0,
  startConn,endConn:ConnPtr_NIL  --Conn.Make..Conn, Crosses.SplitCon
  ];

-- Crosses.SplitConn copies a whole conn, as well as changing fields

Conn:TYPE=RECORD[
  circuit:Circuit_0,             --Conn.Make..Conn
  start,end:RunNo_0,             --Conn.Make..Conn, Crosses.Split
  event:EventNo_0,               --Conn.Make..Conn
  level:Level_red,               --Conn.FixJogColor
  startKind,endKind:ConnKind,    --Crosses.InitConn, Crosses.Split
  offset:INTEGER_noOffset,       --Conn.Offset..
  eventPtr:EventPtr_NIL,         --Conn.Make..Conn
  lambdaX:Lambda_-1,
  startRun,endRun:RunPtr_NIL,    --Conn.Make..Conn
  closeS,closeE:BOOLEAN_FALSE    --Conn.FixJogColor
  ];

Cell:TYPE=RECORD[sizeL,pos:CoordL_[], signals:SignalListPtr_NIL,
    cellNo:INTEGER_0];
Signal:TYPE=RECORD[name:STRING_NIL,circuit:Circuit_0,side:Side_n,
    level:What_both,offset:Lambda_0,net:NetPtr_NIL];
Net:TYPE=RECORD[number:Circuit_0,name:STRING_NIL,netNo:NetNo_0];
Link:TYPE=RECORD[channel:RectanglePtr_NIL,inter:RectanglePtr_NIL];
Topology:TYPE=RECORD[one,two:RectanglePtr_NIL,oneToTwo:Side_e];
Path:TYPE=RECORD[n,s,e,w:PathPtr_NIL,
  channel:RectanglePtr_NIL, inter:RectanglePtr_NIL,
  index:EventPtr_NIL, pathNo:INTEGER_0, started:BOOLEAN_FALSE,
  circuit:Circuit_-1, wire:IWirePtr, huggers:Huggers_[]];
Pathway:TYPE=RECORD[circuit:Circuit_0,path:PathListPtr_NIL];
Silicon:TYPE=RECORD[pos,pos2:CoordL_[0,0],level:What_both,
  solid:BOOLEAN_FALSE, circuit:Circuit_0];
Junction:TYPE=RECORD[iwires:IWireListPtr_NIL,ne,nw,se,sw:Bridge_[], bridgeNS,bridgeEW:RunNo_0];
IWire:TYPE=RECORD[type:InterType_0,ey,wy,nx,sx:RunNo_-1,
  circuit:Circuit_-1,h:Huggers_[],be1,be2,bn1,bn2:BOOLEAN_FALSE,
  path:PathPtr];
Bridge:TYPE=RECORD[x,y:RunNo_-1,hor:BOOLEAN_TRUE];

--place and grid internal to Paths, here only for allocation

Place:TYPE=RECORD[pos:CoordL_[0,0],score:Lambda_0,circuit:Circuit_0,
  back,n,s,e,w:PlacePtr_NIL, perm:BOOLEAN_FALSE, done:BOOLEAN_FALSE,
  un,us,ue,uw:RectanglePtr_NIL];
Grid:TYPE=RECORD[a,b:PlacePtr_NIL,above,below:Link_nilG,hor,done,hi,lo:BOOLEAN_FALSE];



RectanglePtr:TYPE=LONG POINTER TO Rectangle_NIL;
ConnPtr:TYPE=LONG POINTER TO Conn_NIL;
EventPtr:TYPE=LONG POINTER TO Event_NIL;
RunPtr:TYPE=LONG POINTER TO Run_NIL;
CellPtr:TYPE=LONG POINTER TO Cell_NIL;
SignalPtr:TYPE=LONG POINTER TO Signal_NIL;
NetPtr:TYPE=LONG POINTER TO Net_NIL;
TopologyPtr:TYPE=LONG POINTER TO Topology_NIL;
PathPtr:TYPE=LONG POINTER TO Path_NIL;
PathwayPtr:TYPE=LONG POINTER TO Pathway_NIL;
PlacePtr:TYPE=LONG POINTER TO Place_NIL;
GridPtr:TYPE=LONG POINTER TO Grid_NIL;
SiliconPtr:TYPE=LONG POINTER TO Silicon_NIL;
JunctionPtr:TYPE=LONG POINTER TO Junction_NIL;
IWirePtr:TYPE=LONG POINTER TO IWire_NIL;

RectangleList:TYPE=RECORD[h:RectanglePtr,t:RectangleListPtr];
ConnList:TYPE=RECORD[h:ConnPtr,t:ConnListPtr];
EventList:TYPE=RECORD[h:EventPtr,t:EventListPtr];
RunList:TYPE=RECORD[h:RunPtr,t:RunListPtr];
CellList:TYPE=RECORD[h:CellPtr,t:CellListPtr];
SignalList:TYPE=RECORD[h:SignalPtr,t:SignalListPtr];
NetList:TYPE=RECORD[h:NetPtr,t:NetListPtr];
TopologyList:TYPE=RECORD[h:TopologyPtr,t:TopologyListPtr];
PathList:TYPE=RECORD[h:PathPtr,t:PathListPtr];
PathwayList:TYPE=RECORD[h:PathwayPtr,t:PathwayListPtr];
PlaceList:TYPE=RECORD[h:PlacePtr,t:PlaceListPtr];
GridList:TYPE=RECORD[h:GridPtr,t:GridListPtr];
SiliconList:TYPE=RECORD[h:SiliconPtr,t:SiliconListPtr];
IWireList:TYPE=RECORD[h:IWirePtr,t:IWireListPtr];

RectangleListPtr:TYPE=LONG POINTER TO RectangleList;
ConnListPtr:TYPE=LONG POINTER TO ConnList;
EventListPtr:TYPE=LONG POINTER TO EventList;
RunListPtr:TYPE=LONG POINTER TO RunList;
CellListPtr:TYPE=LONG POINTER TO CellList;
SignalListPtr:TYPE=LONG POINTER TO SignalList;
NetListPtr:TYPE=LONG POINTER TO NetList;
TopologyListPtr:TYPE=LONG POINTER TO TopologyList;
PathListPtr:TYPE=LONG POINTER TO PathList;
PathwayListPtr:TYPE=LONG POINTER TO PathwayList;
PlaceListPtr:TYPE=LONG POINTER TO PlaceList;
GridListPtr:TYPE=LONG POINTER TO GridList;
SiliconListPtr:TYPE=LONG POINTER TO SiliconList;
IWireListPtr:TYPE=LONG POINTER TO IWireList;

CtlProc:TYPE=PROCEDURE RETURNS[INTEGER];


-- END OF TYPE DECLARATIONS

--Ctl Procs called by RouteControl

CreateCells:CtlProc;--RouteCells
CreateRectangles:CtlProc;--RouteRectangle
RectLess:CtlProc; --RouteRectLess
MakeLevelers:CtlProc; --RouteRectLess
CreateTopology:CtlProc;--RouteTopology
ChannelLevelRouting:CtlProc;--RoutePaths2
MakeHugs:CtlProc;--RouteHugs
RouteIntersections:CtlProc;--RouteInter
TheMainShowIsRouteRunsInChannels:CtlProc;--RouteRuns
InstallCrossChannelConnections:CtlProc;--RouteConn
InstallInternalContacts:CtlProc;--RouteCrosses
DoSilicon:CtlProc; --RouteSilicon
CheckLayout:CtlProc; --RouteChecker

--misc

ReducePath:PROCEDURE;--RoutePaths1
GetInput:PROCEDURE; --from RouteParse

--the following are all implemented in utilities

EnumerateChannels:PROCEDURE[PROCEDURE[RectanglePtr]];
EnumerateInters:PROCEDURE[PROCEDURE[RectanglePtr]];
EnumerateRectangles:PROCEDURE[PROCEDURE[RectanglePtr]];
EnumerateSignals:PROCEDURE[c:CellPtr,x:PROCEDURE[CellPtr,SignalPtr]];
EnumerateCells:PROCEDURE[PROCEDURE[CellPtr]];
EnumerateConns:PROCEDURE[RectanglePtr,PROCEDURE[RectanglePtr,ConnPtr]];
EnumerateEvents:PROCEDURE[RectanglePtr,PROCEDURE[RectanglePtr,EventPtr]];
EnumerateRuns:PROCEDURE[RectanglePtr,PROCEDURE[RectanglePtr,RunPtr]];
EnumerateAllSignals:PROCEDURE[PROCEDURE[CellPtr,SignalPtr]];
EnumerateAllRuns:PROCEDURE[c:PROCEDURE[RectanglePtr,RunPtr]];
EnumerateAllConns:PROCEDURE[call:PROCEDURE[RectanglePtr,ConnPtr]];
EnumerateSilicon:PROCEDURE[call:PROCEDURE[SiliconPtr]];



InitStorage,ReturnStorage:PROCEDURE;
AllocateList:PROCEDURE RETURNS[LONG POINTER];
AllocateRectangle:PROCEDURE RETURNS[RectanglePtr];
--AllocateChannel:PROCEDURE RETURNS[ChannelPtr];
AllocateEvent:PROCEDURE RETURNS[EventPtr];
AllocateRun:PROCEDURE RETURNS[RunPtr];
AllocateConn:PROCEDURE RETURNS[ConnPtr];
AllocateCell:PROCEDURE RETURNS[CellPtr];
AllocateSignal:PROCEDURE RETURNS[SignalPtr];
AllocateNet:PROCEDURE RETURNS[NetPtr];
AllocateTopology:PROCEDURE RETURNS[TopologyPtr];
AllocatePathway:PROCEDURE RETURNS[PathwayPtr];
AllocatePlace:PROCEDURE RETURNS[PlacePtr];
AllocatePath:PROCEDURE RETURNS[PathPtr];
AllocateGrid:PROCEDURE RETURNS[GridPtr];
AllocateSilicon:PROCEDURE RETURNS[SiliconPtr];
AllocateIWire:PROCEDURE RETURNS[IWirePtr];
AllocateJunction:PROCEDURE RETURNS[JunctionPtr];

FreeList:PROCEDURE[LONG POINTER];
FreePlace:PROCEDURE[PlacePtr];
FreePath:PROCEDURE[PathPtr];
FreePathway:PROCEDURE[PathwayPtr];
FreeGrid:PROCEDURE[GridPtr];
FreeRun:PROCEDURE[RunPtr];
FreeConn:PROCEDURE[ConnPtr];
FreeJunction:PROCEDURE[JunctionPtr];
FreeSilicon:PROCEDURE[SiliconPtr];

Return:PROCEDURE;
ShowLabel:PROCEDURE[STRING];
ShowString:PROCEDURE[STRING];
ShowChar:PROCEDURE[CHARACTER];
ShowDecimal:PROCEDURE[i:INTEGER,s:STRING_NIL];
ShowCircuit:PROCEDURE[c:Circuit] RETURNS[CHARACTER];
SameString:PUBLIC PROCEDURE[a,b:STRING] RETURNS[BOOLEAN];
WritePoint:PROCEDURE[x,y:INTEGER];
ShowPoint:PROCEDURE[s:STRING,x,y:INTEGER];
ShowWire:PROCEDURE[SiliconPtr];
Clear:PROCEDURE[s:STRING];
MakeType:PROCEDURE[n,e,s,w:BOOLEAN] RETURNS[InterType];

--from RouteMakeBlue

MakeBlue:PROCEDURE;

--from RouteSilicon

MakeBlueWire:PROCEDURE[hor:BOOLEAN,x,y,l:Lambda];
MakeRedWire:PROCEDURE[hor:BOOLEAN,x,y,l:Lambda];
MakeContact:PROCEDURE[x,y:Lambda];

--from RouteInter

InterSilicon:PROCEDURE[inter:RectanglePtr];
WhereIs:PROCEDURE[PathPtr,Side,RunNo] RETURNS[RunNo];

--from RouteChipmonkPlot

StartPlot,EndPlot:PROCEDURE;
PlotCell:PROCEDURE[CellPtr];
PlotBlueWire:PROCEDURE[hor:BOOLEAN,x,y,l:Lambda];
PlotRedWire:PROCEDURE[hor:BOOLEAN,x,y,l:Lambda];
PlotBlueRedContact:PROCEDURE[x,y:Lambda];
GetChipmonkString:PROCEDURE[result,prompt1:STRING,prompt2,prompt3:STRING_NIL];
Interrupt:ERROR; --raised by GetChipmonkString when push the rightmost
                 --unlabeled key, asking to abort;

allPaths:PathListPtr; --between paths1 and paths2

--all global variables are implemented in Utilities

channels:RectangleListPtr;    --Rectless.MakeSecondaryLists
problem:Problem;
example:INTEGER;
chipmonk,plot,print:BOOLEAN;
inters:RectangleListPtr;      --Rectless.MakeSecondaryLists
topology:TopologyListPtr;
paths:PathwayListPtr;
layout:SiliconListPtr;
rectangles:RectangleListPtr;  --Rectangle.NewRect


END.

Timing

key Parameters:  C: #cells   E: #events (sources) k1: # channels/circuit= 2
derived pars:
  RECT: # rectangles     = 4C
  CHAN: # channels       = 2C
  INTER: # intersections = 2C
  RUNS: # runs / channel = E/2C
  CONN: # conns / channel= E/C
  SILICON: # mask objects= 16E

Crosses: CHAN (CONN*CONN*RUN) = E (E/C)**2
Checker: (SILICON + ALLSIGNALS) squared = (17E)**2
Inter:   INTER (ALLPATHS + IWIRES) = E (4C+8)
MakeBlue: SILICON(SILICON + LIST(LIST+CELL)) = 16E(16E + *10(C+10))
Silicon: E(E/C+20)