From 3d7a56ac3a02042a18b0120f322a21658214659d Mon Sep 17 00:00:00 2001 From: Tim Edwards Date: Tue, 15 Oct 2019 16:24:49 -0400 Subject: [PATCH] Finally got around to undoing an annoyance caused by the wholesale reduction of memory and startup time, which was to maintain only one CIF style in memory. The new method is just to read in and keep the DRC CIF style separately from the output CIF style. Because the CIF sections of the techfile are read before the DRC sections, and the CIF DRC style is declared in the DRC section, the CIF DRC style is read in on the fly during the first DRC checking. --- cif/CIFgen.c | 70 ++++++++++++++++++++++++++++++++++++++++++++++----- cif/CIFint.h | 1 + cif/CIFtech.c | 10 +++++--- drc/DRCcif.c | 40 ++++++++++++++++++++++++----- 4 files changed, 106 insertions(+), 15 deletions(-) diff --git a/cif/CIFgen.c b/cif/CIFgen.c index d063a087..7233d12f 100644 --- a/cif/CIFgen.c +++ b/cif/CIFgen.c @@ -842,6 +842,35 @@ endbloat: return 0; } +/* + *------------------------------------------------------- + * + * cifFoundFun -- + * + * Find the first tile in the given area. + * + * Results: + * Return 1 to stop the search and process. + * Set clientData to the tile found. + * + *------------------------------------------------------- + */ + +int +cifFoundFunc(tile, treturn) + Tile *tile; + Tile **treturn; +{ + *treturn = tile; + return 1; +} + +/* Data structure for bloat-all function */ +typedef struct _bloatStruct { + CIFOp *op; + CellDef *def; +} BloatStruct; + /* * ---------------------------------------------------------------------------- * @@ -873,18 +902,26 @@ endbloat: } int -cifBloatAllFunc(tile, op) +cifBloatAllFunc(tile, bls) Tile *tile; /* The tile to be processed. */ - CIFOp *op; /* Describes the operation to be performed */ + BloatStruct *bls; { Rect area; TileTypeBitMask connect; Tile *t, *tp; TileType type; - BloatData *bloats = (BloatData *)op->co_client; + BloatData *bloats; int i; + PlaneMask pmask; + int pNum; + CIFOp *op; + CellDef *def; static Stack *BloatStack = (Stack *)NULL; + op = bls->op; + def = bls->def; + bloats = (BloatData *)op->co_client; + /* Create a mask of all connecting types (these must be in a single * plane), then call a search function to find all connecting material * of these types. @@ -900,7 +937,24 @@ cifBloatAllFunc(tile, op) if (BloatStack == (Stack *)NULL) BloatStack = StackNew(64); - PUSHTILE(tile, BloatStack); + /* If the type of the tile to be processed is not in the same plane */ + /* as the bloat type(s), then find any tile under the tile to be */ + /* processed that belongs to the connect mask, and use that as the */ + /* starting tile. */ + + t = tile; + type = TiGetType(tile); + pNum = DBPlane(type); + pmask = CoincidentPlanes(&connect, pNum); + if (pmask == 0) + { + TiToRect(tile, &area); + if (DBSrPaintArea((Tile *)NULL, def->cd_planes[bloats->bl_plane], &area, + &connect, cifFoundFunc, (ClientData)(&t)) == 0) + return 0; /* Nothing found here */ + } + + PUSHTILE(t, BloatStack); while (!StackEmpty(BloatStack)) { t = (Tile *) STACKPOP(BloatStack); @@ -2688,6 +2742,7 @@ cifSrTiles(cifOp, area, cellDef, temps, func, cdArg) { TileTypeBitMask maskBits; TileType t; + Tile *tp; int i; BloatData *bloats; @@ -2699,7 +2754,7 @@ cifSrTiles(cifOp, area, cellDef, temps, func, cdArg) cifScale = (CIFCurStyle) ? CIFCurStyle->cs_scaleFactor : 1; - /* Bloat operations have to be in a single plane */ + /* Bloat operations (except bloat-all) have to be in a single plane */ switch (cifOp->co_opcode) { case CIFOP_BLOAT: @@ -2783,6 +2838,7 @@ CIFGenLayer(op, area, cellDef, temps, clientdata) SearchContext scx; TileType ttype; char *netname; + BloatStruct bls; int (*cifGrowFuncPtr)() = (CIFCurStyle->cs_flags & CWF_GROW_EUCLIDEAN) ? cifGrowEuclideanFunc : cifGrowFunc; @@ -2971,8 +3027,10 @@ CIFGenLayer(op, area, cellDef, temps, clientdata) case CIFOP_BLOATALL: cifPlane = curPlane; + bls.op = op; + bls.def = cellDef; cifSrTiles(op, area, cellDef, temps, - cifBloatAllFunc, (ClientData) op); + cifBloatAllFunc, (ClientData)&bls); break; case CIFOP_SQUARES: diff --git a/cif/CIFint.h b/cif/CIFint.h index 6d3ef7ba..c9280e12 100644 --- a/cif/CIFint.h +++ b/cif/CIFint.h @@ -310,6 +310,7 @@ extern void CIFLoadStyle(); extern Plane *CIFPlanes[]; /* Normal place to store CIF. */ extern CIFKeep *CIFStyleList; /* List of all CIF styles. */ extern CIFStyle *CIFCurStyle; /* Current style being used. */ +extern CIFStyle *CIFDRCStyle; /* CIF style for DRC checking (optional) */ extern CellUse *CIFComponentUse; /* Flatten stuff in here if needed. */ extern CellDef *CIFComponentDef; /* Corresponds to CIFComponentUse. */ extern CellUse *CIFDummyUse; /* Used to dummy up a CellUse for a diff --git a/cif/CIFtech.c b/cif/CIFtech.c index 54bb05c6..25a920e3 100644 --- a/cif/CIFtech.c +++ b/cif/CIFtech.c @@ -1081,13 +1081,17 @@ CIFTechLine(sectionName, argc, argv) if (argc != 3) goto wrongNumArgs; cifParseLayers(argv[1], CIFCurStyle, &newOp->co_paintMask, (TileTypeBitMask *)NULL, FALSE); - bloatLayers = newOp->co_paintMask; bloats = (BloatData *)mallocMagic(sizeof(BloatData)); for (i = 0; i < TT_MAXTYPES; i++) bloats->bl_distance[i] = 0; newOp->co_client = (ClientData)bloats; - cifParseLayers(argv[2], CIFCurStyle, &mask, &tempMask, TRUE); + + /* 10/15/2019: Lifting restriction that the types that */ + /* trigger the bloating must be in the same plane as the */ + /* types that are bloated into. */ + + TTMaskZero(&bloatLayers); TTMaskSetMask(&bloatLayers, &mask); if (!TTMaskEqual(&tempMask, &DBZeroTypeBits)) TechError("Can't use templayers in bloat statement.\n"); @@ -1945,7 +1949,7 @@ CIFLoadStyle(stylename) { SectionID invcif; - if (CIFCurStyle->cs_name == stylename) return; + if (CIFCurStyle && (CIFCurStyle->cs_name == stylename)) return; cifTechNewStyle(); CIFCurStyle->cs_name = stylename; diff --git a/drc/DRCcif.c b/drc/DRCcif.c index b4344620..fa4f00c7 100644 --- a/drc/DRCcif.c +++ b/drc/DRCcif.c @@ -67,9 +67,10 @@ extern bool DRCForceReload; TileTypeBitMask drcCifGenLayers; DRCCookie *drcCifRules[MAXCIFLAYERS][2]; -DRCCookie *drcCifCur=NULL; +DRCCookie *drcCifCur = NULL; int drcCifValid = FALSE; -int beenWarned; +bool beenWarned = FALSE; +char *drcNeedStyle = NULL; #define DRC_CIF_SPACE 0 #define DRC_CIF_SOLID 1 @@ -112,14 +113,12 @@ drcCifSetStyle(argc, argv) { if (!strcmp(new->cs_name, argv[1])) { + drcNeedStyle = new->cs_name; DRCForceReload = TRUE; if (!strcmp(new->cs_name, CIFCurStyle->cs_name)) drcCifStyle = CIFCurStyle; else { - TechError("DRC cif extensions are not enabled.\n\t" - "Use \"cif ostyle %s\" to enable them.\n", - new->cs_name); drcCifStyle = NULL; beenWarned = TRUE; /* post no more error messages */ } @@ -501,9 +500,35 @@ drcCifCheck(arg) int scale; int i,j; int oldTiles; + CIFStyle *CIFSaveStyle = NULL; + if (CIFCurStyle != drcCifStyle) + { + if (drcNeedStyle == NULL) { + TxError("Error: No DRC CIF style declared!\n"); + return; + } + + CIFSaveStyle = CIFCurStyle; + + if (drcCifStyle == NULL) + { + TxPrintf("Loading DRC CIF style.\n"); + CIFCurStyle = NULL; + CIFLoadStyle(drcNeedStyle); + if (drcCifValid == FALSE) + CIFCurStyle = CIFSaveStyle; + else + drcCifStyle = CIFCurStyle; + } + if (drcCifStyle == NULL) + { + TxError("Error: Failed to load CIF DRC style.\n"); + return; + } + CIFCurStyle = drcCifStyle; + } if (drcCifValid == FALSE) return; - else if (CIFCurStyle != drcCifStyle) return; scale = drcCifStyle->cs_scaleFactor; cifrect = *checkRect; @@ -534,6 +559,9 @@ drcCifCheck(arg) } arg->dCD_rect = checkRect; DRCstatCifTiles += DRCstatTiles - oldTiles; + + /* Put it back the way you found it */ + if (CIFSaveStyle != NULL) CIFCurStyle = CIFSaveStyle; } /*