cvrespresso.c

主要进行大规模的电路综合

  SeeAlso       []
******************************************************************************/
void
CvrSetdownCdata(
    void)
{
    FREE(cdata.part_zeros);
    FREE(cdata.var_zeros);
    FREE(cdata.parts_active);
    FREE(cdata.is_unate);
}

/**Function********************************************************************
  Synopsis      [setup the Espresso cube structure.]
  Description   [directly write to the global variable "cube"]
  SideEffects   []
  SeeAlso       []
******************************************************************************/
void
CvrSetupCube(
    int num_vars,
    int *part_size)
{
    register int i, var;
    register pcube p;
    
    
    cube.num_vars  = num_vars;
    if (!fCvrCubeAllocated) {
        cube.part_size  = ALLOC(int, nCvrCubeAllocated);
        cube.first_part = ALLOC(int, nCvrCubeAllocated);
        cube.last_part  = ALLOC(int, nCvrCubeAllocated);
        cube.first_word = ALLOC(int, nCvrCubeAllocated);
        cube.last_word  = ALLOC(int, nCvrCubeAllocated);
        cube.var_mask   = ALLOC(pset,nCvrCubeAllocated);
        cube.sparse     = ALLOC(int, nCvrCubeAllocated);
        cube.temp       = ALLOC(pset,CUBE_TEMP);
        fCvrCubeAllocated = 1;
    }
    if (num_vars > nCvrCubeAllocated) {
        cube.part_size  = REALLOC(int, cube.part_size,  num_vars);
        cube.first_part = REALLOC(int, cube.first_part, num_vars);
        cube.last_part  = REALLOC(int, cube.last_part,  num_vars);
        cube.first_word = REALLOC(int, cube.first_word, num_vars);
        cube.last_word  = REALLOC(int, cube.last_word,  num_vars);
        cube.var_mask   = REALLOC(pset,cube.var_mask,   num_vars);
        cube.sparse     = REALLOC(int, cube.sparse,     num_vars);
        nCvrCubeAllocated = num_vars;
    }
    
    /* reset the num_binary_vars */
    cube.num_binary_vars = 0;
    for (i=0; i<cube.num_vars; ++i) {
        cube.part_size[i] = part_size[i];
    }
    i=0; while (cube.part_size[i++]==2 && i<=num_vars)
        (cube.num_binary_vars)++;
    
    cube.num_mv_vars = cube.num_vars - cube.num_binary_vars;
    cube.output = -1;
    /*cube.output = cube.num_mv_vars > 0 ? cube.num_vars - 1 : -1;*/
    
    cube.size = 0;
    for(var = 0; var < cube.num_vars; var++) {
        if (var < cube.num_binary_vars) {
            cube.part_size[var] = 2;
        }
        cube.first_part[var] = cube.size;
        cube.first_word[var] = WHICH_WORD(cube.size);
        cube.size += ABS(cube.part_size[var]);
        cube.last_part[var] = cube.size - 1;
        cube.last_word[var] = WHICH_WORD(cube.size - 1);
    }
    
    /* the cubes have been freed in CvrSetdownCube() */
    cube.binary_mask = set_new(cube.size);
    cube.mv_mask = set_new(cube.size);
    
    for(var = 0; var < cube.num_vars; var++) {
        p = cube.var_mask[var] = set_new(cube.size);
        for(i = cube.first_part[var]; i <= cube.last_part[var]; i++)
            set_insert(p, i);
        if (var < cube.num_binary_vars) {
            INLINEset_or(cube.binary_mask, cube.binary_mask, p);
            cube.sparse[var] = 0;
        } else {
            INLINEset_or(cube.mv_mask, cube.mv_mask, p);
            cube.sparse[var] = 1;
        }
    }
    if (cube.num_binary_vars == 0)
        cube.inword = -1;
    else {
        cube.inword = cube.last_word[cube.num_binary_vars - 1];
        cube.inmask = cube.binary_mask[cube.inword] & DISJOINT;
    }
    
    for(i = 0; i < CUBE_TEMP; i++) {
        cube.temp[i] = set_new(cube.size);
    }
    cube.fullset  = set_fill(set_new(cube.size), cube.size);
    cube.emptyset = set_new(cube.size);
    
    return;
}

/**Function********************************************************************
  Synopsis      [Free cubes]
  Description   [Free cubes but not the arrays.]
  SideEffects   []
  SeeAlso       []
******************************************************************************/
void
CvrSetdownCube( void )
{
    int i, var;
    
    if (cube.binary_mask) free_cube(cube.binary_mask);
    if (cube.mv_mask)     free_cube(cube.mv_mask);
    if (cube.fullset)     free_cube(cube.fullset);
    if (cube.emptyset)    free_cube(cube.emptyset);
    for(var = 0; var < cube.num_vars; var++) {
        if (cube.var_mask[var]) {
            free_cube(cube.var_mask[var]);
            cube.var_mask[var] = (pcube)NULL;
        }
    }
    
    if (cube.temp) {
        for(i = 0; i < CUBE_TEMP; i++) {
            if (cube.temp[i]) {
                free_cube(cube.temp[i]);
                cube.temp[i] = (pcube)NULL;
            }
        }
    }
    
    cube.binary_mask = cube.mv_mask  = (pcube) NULL;
    cube.fullset     = cube.emptyset = (pcube) NULL;
    
    return;
}



/**Function********************************************************************
  Synopsis      [Free cubes]
  Description   [Free cubes but not the arrays.]
  SideEffects   []
  SeeAlso       []
******************************************************************************/
void
Cvr_CoverEspressoSetup(
    Vm_VarMap_t *pVm)
{
    int *part_size, nVars, i;
    
    /* derive part_size */
    nVars = Vm_VarMapReadVarsInNum(pVm);
    part_size = ALLOC(int, nVars);
    for (i=0; i<nVars; ++i) {
        part_size[i] = Vm_VarMapReadValues(pVm, i);
    }
    CvrSetupCube(nVars, part_size);
    CvrSetupCdata(&cube);
    FREE( part_size );
    
    return;
}

/**Function********************************************************************
  Synopsis      [Free cubes]
  Description   [Free cubes but not the arrays.]
  SideEffects   []
  SeeAlso       []
******************************************************************************/
void
Cvr_CoverEspressoSetdown(
    Vm_VarMap_t *pVm)
{
    CvrSetdownCube( );
    CvrSetdownCdata( );
    return;
}

/**Function********************************************************************
  Synopsis    [Print out an array of Isets]
  Description [Print out an array of Isets]
  SideEffects []
  SeeAlso     []
******************************************************************************/
void
_PsetFamilyArrayPrint(
    FILE        *pFile,
    pset_family *pcovers,
    int          size,
    bool         verbose) 
{
    int k;

    for (k=0; k<size; ++k) {
        fprintf(pFile, "PART[%d] ", k);
        _PsetFamilyPrint(pFile, pcovers[k], verbose);
    }
}


/**Function********************************************************************
  Synopsis    [Print out an iset]
  Description [Print out an iset]
  SideEffects []
  SeeAlso     []
******************************************************************************/
void
_PsetFamilyPrint(
    FILE        *pFile,
    pset_family psf,
    bool        verbose)
{
    int i;
    pset p;
    if (psf==NULL) {
        printf("NULL\n"); return;
    }
    fprintf(pFile, "wsize=%d\tsf_size=%d\tcount=%d\n",
            psf->wsize, /*psf->sf_size,*/ cube.size, psf->count);
    
    if (psf->sf_size==0 || psf->count==0) {
        if (psf->count>0) { printf(" ---TAUTOLOGY---\n"); }
        else { printf(" ---EMPTY---\n"); }
        return;
    }
    
    if (verbose) {
        foreachi_set(psf, i, p) {
            _PsetPrint(pFile, p, "01");
        }
    }
    
    return;
}


/**Function********************************************************************
  Synopsis    [Print out a cube]
  Description [Print out a cube]
  SideEffects []
  SeeAlso     []
******************************************************************************/
void
_PsetPrint(
    FILE *fp,
    pcube c,
    char *out_map)
{
    register int i, var, ch;


    for(var = 0; var < cube.num_binary_vars; var++) {
	ch = "?01-" [GETINPUT(c, var)];
	putc(ch, fp);
    }
    for(var = cube.num_binary_vars; var < cube.num_vars; var++) {
	putc(' ', fp);
	for(i = cube.first_part[var]; i <= cube.last_part[var]; i++) {
	    ch = "01" [is_in_set(c, i) != 0];
	    putc(ch, fp);
	}
    }
    putc('\n', fp);
}

/**Function********************************************************************
  Synopsis    [reset the default cover of a pset_family array]
  Description [assume all i-sets are available]
  SideEffects []
  SeeAlso     []
******************************************************************************/
void
_PsetFamilyResetDefault( pset_family *pOnset, int nVal ) 
{
    int i, iDef, nCost;
    nCost = -1;
    for ( i=0; i<nVal; ++i ) {
        assert( pOnset[i] );
        if ( pOnset[i]->count > nCost ) {
            iDef = i;
            nCost = pOnset[i]->count;
        }
    }
    sf_free( pOnset[iDef] );
    pOnset[iDef] = NULL;
    return;
}

/**Function********************************************************************
  Synopsis    []
  Description []
  SideEffects []
  SeeAlso     []
******************************************************************************/
bool
Cvr_CoverIsTooLarge( Cvr_Cover_t *pCf ) 
{
    int i, nVals, nBits, nCubes;
    
    nVals = Vm_VarMapReadValuesOutNum( pCf->pVm );
    nBits = Vm_VarMapReadValuesInNum( pCf->pVm );
    nCubes = 0;
    for ( i=0; i<nVals; ++i ) {
        if ( pCf->ppCovers[i] )
            nCubes += Mvc_CoverReadCubeNum( pCf->ppCovers[i] );
    }
    
    return ( (nCubes>=100 && nBits>=50) ||
             (nCubes>=200 && nBits>=30) ||
             (nCubes>=300 && nBits>=20) );
}

/**Function********************************************************************
  Synopsis    []
  Description []
  SideEffects []
  SeeAlso     []
******************************************************************************/
bool
Cvr_IsetIsTooLarge( Vm_VarMap_t *pVm, Mvc_Cover_t *pOnset ) 
{
    int nVals, nBits, nCubes;
    
    nVals  = Vm_VarMapReadValuesOutNum( pVm );
    nBits  = Vm_VarMapReadValuesInNum( pVm );
    nCubes = Mvc_CoverReadCubeNum( pOnset );
    
    return ( (nCubes>=50 && nBits>=50) ||
             (nCubes>=100 && nBits>=30) ||
             (nCubes>=200 && nBits>=20) );
}