luke
/
magic
mirror of https://github.com/RTimothyEdwards/magic.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
magic/mzrouter/mzInit.c

372 lines
11 KiB
C
Raw Permalink Blame History

/*
* 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;
}
Reference in New Issue View Git Blame Copy Permalink