/*
 * PlowRandom.c --
 *
 * Plowing.
 * Random testing: generate a whole bunch of random plows
 * and make sure each one produces a design-rule-correct
 * result that has the same extracted circuit (minus the
 * parasitics) as the initial cell.
 *
 *     ********************************************************************* 
 *     * Copyright (C) 1985, 1990 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[]="$Header: /ufs/repository/magic/plow/PlowRandom.c,v 1.3 2006/02/08 03:48:02 fang Exp $";
#endif  /* not lint */

#include <stdio.h>
#include <sys/types.h>
#include <sys/file.h>
#include <sys/stat.h>
#ifdef	SYSV
#include <fcntl.h>
#endif
#include <unistd.h>
#include "misc/magic.h"
#include "utils/geometry.h"
#include "tiles/tile.h"
#include "utils/hash.h"
#include "database/database.h"
#include "plow/plow.h"
#include "plow/plowInt.h"
#include "textio/textio.h"
#include "undo/undo.h"
#include "signals/signals.h"
#include "drc/drc.h"

/* Imports from PlowMain.c */
extern CellDef *plowYankDef;

/* Forward declarations */
int plowFindFirstError();
static int plowGenRandom(int lo, int hi);
static void plowGenRect(register Rect *bbox, register Rect *r);

/*
 * ----------------------------------------------------------------------------
 *
 * PlowRandomTest --
 *
 * Random testing: generate a whole bunch of random plows
 * and make sure each one produces a design-rule-correct
 * result that has the same extracted circuit (minus the
 * parasitics) as the initial cell.
 *
 * Output the coordinates and direction of each plow as
 * we go, flagging it as one producing a DRC violation
 * or a connectivity violation as we go.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Writes a whole bunch of information via TxPrintf(),
 *	as described above.
 *
 * ----------------------------------------------------------------------------
 */

/* Void */
void
PlowRandomTest(def)
    CellDef *def;
{
#ifdef	notdef
    static char *tempgood = "/tmp/PlowGoodaXXXXX";
    static char *temptemp = "/tmp/PlowTempaXXXXX";
    char goodName[64], tempName[64], goodExt[64], tempExt[64];
    char command[256];
#endif	/* notdef */
    static int dirs[] = { GEO_NORTH, GEO_SOUTH, GEO_EAST, GEO_WEST };
    static char *dirnames[] = { "up", "down", "right", "left" };
    Rect plowRect;
    int dir, plowDir;

#ifdef	notdef
    strcpy(goodName, tempgood);
    strcpy(tempName, temptemp);
    mktemp(goodName);
    mktemp(tempName);
    sprintf(goodExt, "%s.ext", goodName);
    sprintf(tempExt, "%s.ext", tempName);

    /* Generate "good" extracted file */
    ExtCell(def, goodName);
    (void) sprintf(command, "sedplow %s", goodExt);
    system(command);
#endif	/* notdef */

    /* Repeatedly try to break plowing */
    while (!SigInterruptPending)
    {
	/* Generate a random plow direction and rectangle */
	dir = plowGenRandom(0, 3);
	plowDir = dirs[dir];
	plowGenRect(&def->cd_bbox, &plowRect);
	(void) Plow(def, &plowRect, DBAllTypeBits, plowDir);
	TxPrintf("%s %d %d %d %d\n", dirnames[dir],
			plowRect.r_xbot, plowRect.r_ybot,
			plowRect.r_xtop, plowRect.r_ytop);
	TxFlush();

	/* Finish the design-rule check and count any errors */
	DRCCatchUp();
	if (DBSrPaintArea((Tile *) NULL, def->cd_planes[PL_DRC_ERROR],
		    &def->cd_bbox, &DBAllButSpaceBits,
		    plowFindFirstError, (ClientData) NULL))
	{
	    TxPrintf("%s %d %d %d %d: DRC error\n", dirnames[dir],
			plowRect.r_xbot, plowRect.r_ybot,
			plowRect.r_xtop, plowRect.r_ytop);
	    TxFlush();
	}

	/* Turn off the modified bit so we get the same timestamp */
	def->cd_flags &= ~CDMODIFIED;

#ifdef	notdef
	/* Extract to the temp file */
	ExtCell(def, tempName);
	(void) sprintf(command, "sedplow %s", tempExt);
	system(command);

	/* Check for any differences */
	if (plowFileDiff(goodExt, tempExt))
	{
	    TxPrintf("%s %d %d %d %d: EXT error\n", dirnames[dir],
			plowRect.r_xbot, plowRect.r_ybot,
			plowRect.r_xtop, plowRect.r_ytop);
	    TxFlush();
	}
#endif	/* notdef */

	/* Make sure there's always something to undo */
	DBPutLabel(def, &def->cd_bbox, -1, "dummylabel", TT_SPACE);

	/* Undo */
	UndoBackward(1);
    }

#ifdef	notdef
    (void) unlink(goodExt);
    (void) unlink(tempExt);
#endif	/* notdef */
}

/*
 * ----------------------------------------------------------------------------
 *
 * plowFindFirstError --
 *
 * Filter procedure called via DBSrPaintArea by PlowRandomTest()
 * above, on the PL_DRC_ERROR plane, looking for non-space tiles.
 *
 * Results:
 *	Returns 1 always, to force DBSrPaintArea to abort and
 *	return 1.
 *
 * Side effects:
 *	None.
 *
 * ----------------------------------------------------------------------------
 */
int
plowFindFirstError(void)
{
    return (1);
}

/*
 * ----------------------------------------------------------------------------
 *
 * plowGenRect --
 *
 * Generate a random plow rectangle.
 * This rectangle is guaranteed to lie within the bounding box of
 * the cell.  The four coordinates are chosen randomly from a uniform
 * distribution, and then the rectangle is flipped to insure that its
 * upper-right is above and to the right of its lower-left.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Fills in the rectangle pointed to by 'r'.
 *
 * ----------------------------------------------------------------------------
 */
void
plowGenRect(bbox, r)
    register Rect *bbox;	/* Bounding box of the cell being plowed */
    register Rect *r;		/* Fill in this rectangle */
{
    register int temp;

    r->r_xbot = plowGenRandom(bbox->r_xbot, bbox->r_xtop);
    r->r_xtop = plowGenRandom(bbox->r_xbot, bbox->r_xtop);
    r->r_ybot = plowGenRandom(bbox->r_ybot, bbox->r_ytop);
    r->r_ytop = plowGenRandom(bbox->r_ybot, bbox->r_ytop);
    if (r->r_xbot == r->r_xtop) r->r_xtop = r->r_xbot + 1;
    if (r->r_ybot == r->r_ytop) r->r_ytop = r->r_ybot + 1;
    if (r->r_xbot > r->r_xtop)
    {
	temp = r->r_xtop;
	r->r_xtop = r->r_xbot;
	r->r_xbot = temp;
    }
    if (r->r_ybot > r->r_ytop)
    {
	temp = r->r_ytop;
	r->r_ytop = r->r_ybot;
	r->r_ybot = temp;
    }
}

/*
 * ----------------------------------------------------------------------------
 *
 * plowGenRandom --
 *
 * Generate a random integer chosen from the integers lo, lo+1, ..., hi,
 * with each integer having equal probability.
 *
 * Results:
 *	Returns the integer described above.
 *
 * Side effects:
 *	None.
 *
 * ----------------------------------------------------------------------------
 */

int
plowGenRandom(lo, hi)
    int lo, hi;		/* Inclusive bounds for the integer we'll generate */
{
    int range = hi - lo + 1;
#ifdef	SYSV
    int r = rand();
#else
    int r = random();
#endif	/* SYSV */

    return ((r % range) + lo);
}

/*
 * ----------------------------------------------------------------------------
 *
 * plowFileDiff --
 *
 * Compare two files for equality.
 *
 * Results:
 *	Returns TRUE if they are identical and the same length,
 *	FALSE if they differ.
 *
 * Side effects:
 *	None.
 *
 * ----------------------------------------------------------------------------
 */

bool
plowFileDiff(file1, file2)
    char *file1;
    char *file2;
{
    char b1[BUFSIZ], b2[BUFSIZ];
    int f1, f2=0;
    int n1, n2;
    bool ret = FALSE;

    if ((f1 = open(file1, O_RDONLY, 0)) < 0) goto done;
    if ((f2 = open(file2, O_RDONLY, 0)) < 0) goto done;

    while ((n1 = read(f1, b1, BUFSIZ)) > 0)
    {
	n2 = read(f2, b2, BUFSIZ);
	if (n1 != n2 || bcmp(b1, b2, n1) != 0)
	    goto done;
    }
    ret = TRUE;

done:
    (void) close(f1);
    (void) close(f2);
    return (ret);
}
