372 lines
11 KiB
C
372 lines
11 KiB
C
/*
|
||
* mzInit.c --
|
||
*
|
||
* Initialization code for maze router module.
|
||
* Called after technology file readin.
|
||
*
|
||
* *********************************************************************
|
||
* * Copyright (C) 1988, 1990 Michael H. Arnold and the Regents of the *
|
||
* * University of California. *
|
||
* * Permission to use, copy, modify, and distribute this *
|
||
* * software and its documentation for any purpose and without *
|
||
* * fee is hereby granted, provided that the above copyright *
|
||
* * notice appear in all copies. The University of California *
|
||
* * makes no representations about the suitability of this *
|
||
* * software for any purpose. It is provided "as is" without *
|
||
* * express or implied warranty. Export of this software outside *
|
||
* * of the United States of America may require an export license. *
|
||
* *********************************************************************
|
||
*/
|
||
|
||
#ifndef lint
|
||
static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/mzrouter/mzInit.c,v 1.1.1.1 2008/02/03 20:43:50 tim Exp $";
|
||
#endif /* not lint */
|
||
|
||
#include <stdio.h>
|
||
|
||
#include "utils/magic.h"
|
||
#include "utils/geometry.h"
|
||
#include "tiles/tile.h"
|
||
#include "utils/hash.h"
|
||
#include "database/database.h"
|
||
#include "drc/drc.h"
|
||
#include "select/select.h"
|
||
#include "utils/signals.h"
|
||
#include "textio/textio.h"
|
||
#include "windows/windows.h"
|
||
#include "dbwind/dbwind.h"
|
||
#include "utils/styles.h"
|
||
#include "debug/debug.h"
|
||
#include "utils/undo.h"
|
||
#include "textio/txcommands.h"
|
||
#include "utils/malloc.h"
|
||
#include "utils/list.h"
|
||
#include "utils/heap.h"
|
||
#include "mzrouter/mzrouter.h"
|
||
#include "mzrouter/mzInternal.h"
|
||
|
||
|
||
/*---- Static Data (local to this file) ----*/
|
||
|
||
/* Dummy cells used to display global hint planes */
|
||
CellDef *mzHHintDef = (CellDef *) NULL;
|
||
CellUse *mzHHintUse = (CellUse *) NULL;
|
||
CellDef *mzVHintDef = (CellDef *) NULL;
|
||
CellUse *mzVHintUse = (CellUse *) NULL;
|
||
|
||
/* Dummy cells used to display global fence planes */
|
||
CellDef *mzHFenceDef = (CellDef *) NULL;
|
||
CellUse *mzHFenceUse = (CellUse *) NULL;
|
||
|
||
/* Dummy cells used to display global rotate planes */
|
||
CellDef *mzHRotateDef = (CellDef *) NULL;
|
||
CellUse *mzHRotateUse = (CellUse *) NULL;
|
||
CellDef *mzVRotateDef = (CellDef *) NULL;
|
||
CellUse *mzVRotateUse = (CellUse *) NULL;
|
||
|
||
/* Dummy cells used to display global bounds planes */
|
||
CellDef *mzHBoundsDef = (CellDef *) NULL;
|
||
CellUse *mzHBoundsUse = (CellUse *) NULL;
|
||
CellDef *mzVBoundsDef = (CellDef *) NULL;
|
||
CellUse *mzVBoundsUse = (CellUse *) NULL;
|
||
|
||
/* Dummy cell used to display blockage plane */
|
||
CellDef *mzBlockDef = (CellDef *) NULL;
|
||
CellUse *mzBlockUse = (CellUse *) NULL;
|
||
|
||
/* Dummy cell used to display estimate plane */
|
||
CellDef *mzEstimateDef = (CellDef *) NULL;
|
||
CellUse *mzEstimateUse = (CellUse *) NULL;
|
||
|
||
/* Forward declarations */
|
||
extern void mzBuildPlanes();
|
||
|
||
|
||
/*
|
||
* ----------------------------------------------------------------------------
|
||
*
|
||
* MZInit --
|
||
*
|
||
* This procedure is called when Magic starts up, after
|
||
* technology initialization.
|
||
*
|
||
* Results:
|
||
* None.
|
||
*
|
||
* Side effects:
|
||
* Register ourselves with debug module
|
||
* Setup datastructures.
|
||
*
|
||
* ----------------------------------------------------------------------------
|
||
*/
|
||
|
||
void
|
||
MZInit()
|
||
{
|
||
int n;
|
||
|
||
/* Debug structure */
|
||
static struct
|
||
{
|
||
char *di_name;
|
||
int *di_id;
|
||
} dflags[] = {
|
||
"steppath", &mzDebStep,
|
||
"maze", &mzDebMaze,
|
||
0
|
||
};
|
||
|
||
/* Register with debug module */
|
||
mzDebugID = DebugAddClient("mzrouter", sizeof dflags/sizeof dflags[0]);
|
||
for (n = 0; dflags[n].di_name; n++)
|
||
*(dflags[n].di_id) = DebugAddFlag(mzDebugID, dflags[n].di_name);
|
||
|
||
/* Finalize parameters */
|
||
MZAfterTech();
|
||
|
||
/* Setup internal tile planes and associated paint tables, cells for
|
||
* display during debugging, etc.
|
||
*/
|
||
mzBuildPlanes();
|
||
|
||
/* Initialize destination alignment structures */
|
||
mzNLInit(&mzXAlignNL, INITIAL_ALIGN_SIZE);
|
||
mzNLInit(&mzYAlignNL, INITIAL_ALIGN_SIZE);
|
||
|
||
/* Setup result cell */
|
||
DBNewYank("__mz_result", &mzResultUse, &mzResultDef);
|
||
}
|
||
|
||
/*
|
||
* ----------------------------------------------------------------------------
|
||
*
|
||
* MZAttachHintPlanes --
|
||
*
|
||
* Reattaches the global pointers to the various hint planes. Should be
|
||
* called anytime the plane structures are altered (on initialization, and
|
||
* in response to DBScaleEverything())
|
||
*
|
||
* Results:
|
||
* None.
|
||
*
|
||
* Side Effects:
|
||
* Global pointers modified.
|
||
* ----------------------------------------------------------------------------
|
||
*/
|
||
|
||
void
|
||
MZAttachHintPlanes()
|
||
{
|
||
mzHHintPlane = mzHHintDef->cd_planes[PL_M_HINT];
|
||
mzVHintPlane = mzVHintDef->cd_planes[PL_M_HINT];
|
||
|
||
mzHFencePlane = mzHFenceDef->cd_planes[PL_F_HINT];
|
||
mzEstimatePlane = mzEstimateDef->cd_planes[PL_M_HINT];
|
||
|
||
mzHRotatePlane = mzHRotateDef->cd_planes[PL_R_HINT];
|
||
mzVRotatePlane = mzVRotateDef->cd_planes[PL_R_HINT];
|
||
|
||
mzHBoundsPlane = mzHBoundsDef->cd_planes[PL_M_HINT];
|
||
mzVBoundsPlane = mzVBoundsDef->cd_planes[PL_M_HINT];
|
||
}
|
||
|
||
|
||
/*
|
||
* ----------------------------------------------------------------------------
|
||
*
|
||
* mzBuildPlanes --
|
||
*
|
||
* Setup internal type masks, paint tables, planes, and cells for debugging.
|
||
*
|
||
* Results:
|
||
* None.
|
||
*
|
||
* Side effects:
|
||
* Internal cells allocated.
|
||
*
|
||
* ----------------------------------------------------------------------------
|
||
*/
|
||
|
||
void
|
||
mzBuildPlanes()
|
||
{
|
||
/* --------- Setup mask of all hint types --------------- */
|
||
|
||
/* mzHintTypesMask */
|
||
TTMaskZero(&mzHintTypesMask);
|
||
TTMaskSetType(&mzHintTypesMask,TT_MAGNET);
|
||
TTMaskSetType(&mzHintTypesMask,TT_FENCE);
|
||
TTMaskSetType(&mzHintTypesMask,TT_ROTATE);
|
||
|
||
/* --------- Blockage planes ----------------------------------------- */
|
||
/* (Blockage planes indicate where the router is allowed to route on
|
||
* each route-type. 0-width routes are made and then flushed out
|
||
* to design rule correct paths after routing completes). There are
|
||
* two blockage planes for each routing layer or and routing
|
||
* contact - one organized into maximal vertical strips, and one into
|
||
* horizontal strips).
|
||
*/
|
||
|
||
/* Setup paint table for blockage planes */
|
||
{
|
||
int r,s;
|
||
|
||
/* Indices are "paint", "have". The entry value designates "result" */
|
||
|
||
/* Blockage painting is governed by strict priority order:
|
||
* you always get the higher numbered type,
|
||
* EXCEPT that painting space always gives space.
|
||
*/
|
||
for (r = 0; r < TT_MAXROUTETYPES; r++)
|
||
{
|
||
for (s = 0; s < TT_MAXROUTETYPES; s++)
|
||
{
|
||
if(r == TT_SPACE)
|
||
{
|
||
mzBlockPaintTbl[r][s] = TT_SPACE;
|
||
}
|
||
else
|
||
{
|
||
mzBlockPaintTbl[r][s] = MAX(r,s);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Create dummy cell for displaying blockage planes
|
||
* (see *mzroute showblock command in mzTest.c)
|
||
*/
|
||
DBNewYank("__BLOCK", &mzBlockUse,&mzBlockDef);
|
||
DBFreePaintPlane(mzBlockDef->cd_planes[PL_M_HINT]);
|
||
TiFreePlane(mzBlockDef->cd_planes[PL_M_HINT]);
|
||
mzBlockDef->cd_planes[PL_M_HINT] = NULL;
|
||
|
||
/* -- Setup mask of valid tile types on which to start a route path -- */
|
||
/* mzStartTypesMask */
|
||
TTMaskZero(&mzStartTypesMask);
|
||
TTMaskSetType(&mzStartTypesMask,TT_SAMENODE);
|
||
TTMaskSetType(&mzStartTypesMask,TT_ABOVE_UD_WALK);
|
||
TTMaskSetType(&mzStartTypesMask,TT_BELOW_UD_WALK);
|
||
TTMaskSetType(&mzStartTypesMask,TT_ABOVE_LR_WALK);
|
||
TTMaskSetType(&mzStartTypesMask,TT_BELOW_LR_WALK);
|
||
TTMaskSetType(&mzStartTypesMask,TT_LEFT_WALK);
|
||
TTMaskSetType(&mzStartTypesMask,TT_RIGHT_WALK);
|
||
TTMaskSetType(&mzStartTypesMask,TT_TOP_WALK);
|
||
TTMaskSetType(&mzStartTypesMask,TT_BOTTOM_WALK);
|
||
TTMaskSetType(&mzStartTypesMask,TT_DEST_AREA);
|
||
|
||
/*------------- Bounds Planes --------------------------------------- */
|
||
/* (Blockage planes are generated incrementally. The two global bounds
|
||
* planes record the areas for which blockage planes have already been
|
||
* generated.) */
|
||
|
||
/* Setup paint table for bounds planes */
|
||
{
|
||
int r,s;
|
||
|
||
/* Indices are "paint", "have". The entry value designates "result" */
|
||
|
||
/* (Want TT_INBLOCK to persist when TT_GENBLOCK painted on top,
|
||
* so that
|
||
* after painting TT_GENBLOCK over region to be expanded TT_GENBLOCK
|
||
* tiles give subregions that haven't already been expanded.
|
||
*/
|
||
|
||
/* Default is to get what you paint */
|
||
for (r = 0; r < TT_MAXROUTETYPES; r++)
|
||
for (s = 0; s < TT_MAXROUTETYPES; s++)
|
||
mzBoundsPaintTbl[r][s] = r;
|
||
|
||
/* Nothing changes TT_INBOUNDS except TT_SPACE */
|
||
for (r = 0; r < TT_MAXROUTETYPES; r++)
|
||
if (r != TT_SPACE)
|
||
mzBoundsPaintTbl[r][TT_INBOUNDS] = TT_INBOUNDS;
|
||
}
|
||
|
||
/* Create global bounds planes -
|
||
* and attach to dummy cells for display during debugging */
|
||
|
||
DBNewYank("__HBOUNDS", &mzHBoundsUse,&mzHBoundsDef);
|
||
DBNewYank("__VBOUNDS", &mzVBoundsUse,&mzVBoundsDef);
|
||
|
||
/*------------- Dest Area Internal Cell ------------------------------ */
|
||
/* (Destination area'a are painted here to make sure there is always
|
||
* something for the router to connect to. This cell is used along
|
||
* with mzRouteUse to generate blockage planes.)
|
||
*/
|
||
|
||
DBNewYank("__DESTAREAS", &mzDestAreasUse,&mzDestAreasDef);
|
||
|
||
/* ------------ Estimate Plane ------------------------------------- */
|
||
/* (The global estimation plane provides info. for estimating cost to
|
||
* completion for partial paths, that factor in large blocks such as
|
||
* fences and subcells.)
|
||
*/
|
||
|
||
/* Setup paint table for estimate plane */
|
||
{
|
||
int r,s;
|
||
|
||
/* Indices are "paint", "have". The entry value designates "result" */
|
||
|
||
/* Estimate painting is governed by priority order:
|
||
* you always get the higher numbered type,
|
||
* EXCEPT that painting space always gives space
|
||
*/
|
||
for (r = 0; r < TT_MAXROUTETYPES; r++)
|
||
{
|
||
for (s = 0; s < TT_MAXROUTETYPES; s++)
|
||
{
|
||
if(r == TT_SPACE)
|
||
{
|
||
mzEstimatePaintTbl[r][s] = TT_SPACE;
|
||
}
|
||
else
|
||
{
|
||
mzEstimatePaintTbl[r][s] = MAX(r,s);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Create global estimate plane
|
||
* and attach to dummy cells for display during debugging */
|
||
|
||
DBNewYank("__ESTIMATE", &mzEstimateUse,&mzEstimateDef);
|
||
|
||
/* ----------- Hint Planes ---------------------------------------- */
|
||
/* (Global hint planes store all hints visible to router - unencumbered
|
||
* by cell structure and fence and rotate regions.)
|
||
*/
|
||
|
||
/* Create global hint planes -
|
||
* and attach to dummy cells for display during debugging */
|
||
|
||
DBNewYank("__HHINT", &mzHHintUse,&mzHHintDef);
|
||
DBNewYank("__VHINT", &mzVHintUse,&mzVHintDef);
|
||
|
||
/* --------------- Fence Plane ----------------------------------
|
||
* (Global fence plane gives location of all fences visible to router -
|
||
* unencumbered by cell structure and hint and rotate regions.)*/
|
||
|
||
/* Create global fence plane
|
||
* and attach to dummy cells for display during debugging */
|
||
|
||
DBNewYank("__HFENCE", &mzHFenceUse,&mzHFenceDef);
|
||
|
||
/* --------------- Rotate Planes -------------------------------
|
||
* (Global rotate plane gives location of all rotate regions visible
|
||
* to router -
|
||
* unencumbered by cell structure and hint and rotate regions.) */
|
||
|
||
/* Create global rotate planes
|
||
* and attach to dummy cells for display during debugging */
|
||
|
||
DBNewYank("__HROTATE", &mzHRotateUse,&mzHRotateDef);
|
||
DBNewYank("__VROTATE", &mzVRotateUse,&mzVRotateDef);
|
||
|
||
MZAttachHintPlanes();
|
||
|
||
return;
|
||
}
|