abcMini.c 7.37 KB
Newer Older
Alan Mishchenko committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
/**CFile****************************************************************

  FileName    [abcMini.c]

  SystemName  [ABC: Logic synthesis and verification system.]

  PackageName [Network and node package.]

  Synopsis    [Interface to the minimalistic AIG package.]

  Author      [Alan Mishchenko]
  
  Affiliation [UC Berkeley]

  Date        [Ver. 1.0. Started - June 20, 2005.]

  Revision    [$Id: abcMini.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]

***********************************************************************/

21
#include "base/abc/abc.h"
22
#include "base/main/main.h"
23
#include "aig/miniaig/miniaig.h"
Alan Mishchenko committed
24

25 26 27
ABC_NAMESPACE_IMPL_START


Alan Mishchenko committed
28 29 30 31 32 33 34 35
////////////////////////////////////////////////////////////////////////
///                        DECLARATIONS                              ///
////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////
///                     FUNCTION DEFINITIONS                         ///
////////////////////////////////////////////////////////////////////////

36

Alan Mishchenko committed
37 38
/**Function*************************************************************

39
  Synopsis    [Converts the network from the AIG manager into ABC.]
Alan Mishchenko committed
40 41 42 43 44 45 46 47

  Description []
               
  SideEffects []

  SeeAlso     []

***********************************************************************/
48
Abc_Obj_t * Abc_NodeFanin0Copy( Abc_Ntk_t * pNtk, Vec_Int_t * vCopies, Mini_Aig_t * p, int Id )
Alan Mishchenko committed
49
{
50
    int Lit = Mini_AigNodeFanin0( p, Id );
51 52
    int AbcLit = Abc_LitNotCond( Vec_IntEntry(vCopies, Abc_Lit2Var(Lit)), Abc_LitIsCompl(Lit) );
    return Abc_ObjFromLit( pNtk, AbcLit );
53 54 55 56
}
Abc_Obj_t * Abc_NodeFanin1Copy( Abc_Ntk_t * pNtk, Vec_Int_t * vCopies, Mini_Aig_t * p, int Id )
{
    int Lit = Mini_AigNodeFanin1( p, Id );
57 58
    int AbcLit = Abc_LitNotCond( Vec_IntEntry(vCopies, Abc_Lit2Var(Lit)), Abc_LitIsCompl(Lit) );
    return Abc_ObjFromLit( pNtk, AbcLit );
59 60 61 62 63 64 65 66
}
Abc_Ntk_t * Abc_NtkFromMiniAig( Mini_Aig_t * p )
{
    Abc_Ntk_t * pNtk;
    Abc_Obj_t * pObj;
    Vec_Int_t * vCopies;
    int i, nNodes;
    // get the number of nodes
67
    nNodes = Mini_AigNodeNum(p);
68 69
    // create ABC network
    pNtk = Abc_NtkAlloc( ABC_NTK_STRASH, ABC_FUNC_AIG, 1 );
70
    pNtk->pName = Abc_UtilStrsav( "MiniAig" );
71
    // create mapping from MiniAIG objects into ABC objects
72
    vCopies = Vec_IntAlloc( nNodes );
73
    Vec_IntPush( vCopies, Abc_LitNot(Abc_ObjToLit(Abc_AigConst1(pNtk))) );
74 75
    // iterate through the objects
    for ( i = 1; i < nNodes; i++ )
Alan Mishchenko committed
76
    {
77 78 79 80 81 82 83
        if ( Mini_AigNodeIsPi( p, i ) )
            pObj = Abc_NtkCreatePi(pNtk);
        else if ( Mini_AigNodeIsPo( p, i ) )
            Abc_ObjAddFanin( (pObj = Abc_NtkCreatePo(pNtk)), Abc_NodeFanin0Copy(pNtk, vCopies, p, i) );
        else if ( Mini_AigNodeIsAnd( p, i ) )
            pObj = Abc_AigAnd((Abc_Aig_t *)pNtk->pManFunc, Abc_NodeFanin0Copy(pNtk, vCopies, p, i), Abc_NodeFanin1Copy(pNtk, vCopies, p, i));
        else assert( 0 );
84
        Vec_IntPush( vCopies, Abc_ObjToLit(pObj) );
Alan Mishchenko committed
85
    }
86
    assert( Vec_IntSize(vCopies) == nNodes );
87 88 89 90 91 92
    Abc_AigCleanup( (Abc_Aig_t *)pNtk->pManFunc );
    Vec_IntFree( vCopies );
    Abc_NtkAddDummyPiNames( pNtk );
    Abc_NtkAddDummyPoNames( pNtk );
    if ( !Abc_NtkCheck( pNtk ) )
        fprintf( stdout, "Abc_NtkFromMini(): Network check has failed.\n" );
93 94 95 96 97 98 99 100
    // add latches
    if ( Mini_AigRegNum(p) > 0 )
    {
        extern Abc_Ntk_t * Abc_NtkRestrashWithLatches( Abc_Ntk_t * pNtk, int nLatches );
        Abc_Ntk_t * pTemp;
        pNtk = Abc_NtkRestrashWithLatches( pTemp = pNtk, Mini_AigRegNum(p) );
        Abc_NtkDelete( pTemp );
    }
101
    return pNtk;
Alan Mishchenko committed
102 103 104 105
}

/**Function*************************************************************

106
  Synopsis    [Converts the network from ABC into the AIG manager.]
Alan Mishchenko committed
107 108 109 110 111 112 113 114

  Description []
               
  SideEffects []

  SeeAlso     []

***********************************************************************/
115 116 117 118 119 120 121 122
int Abc_NodeFanin0Copy2( Abc_Obj_t * pObj )
{
    return Abc_LitNotCond( Abc_ObjFanin0(pObj)->iTemp, Abc_ObjFaninC0(pObj) );
}
int Abc_NodeFanin1Copy2( Abc_Obj_t * pObj )
{
    return Abc_LitNotCond( Abc_ObjFanin1(pObj)->iTemp, Abc_ObjFaninC1(pObj) );
}
123
Mini_Aig_t * Abc_NtkToMiniAig( Abc_Ntk_t * pNtk )
Alan Mishchenko committed
124
{
125
    Mini_Aig_t * p;
Alan Mishchenko committed
126 127
    Abc_Obj_t * pObj;
    int i;
128
    assert( Abc_NtkIsStrash(pNtk) );
Alan Mishchenko committed
129
    // create the manager
130 131 132 133 134
    p = Mini_AigStart();
    // create mapping from MiniAIG into ABC objects
    Abc_NtkCleanCopy( pNtk );
    Abc_AigConst1(pNtk)->iTemp = Mini_AigLitConst1();
    // create primary inputs
Alan Mishchenko committed
135
    Abc_NtkForEachCi( pNtk, pObj, i )
136 137
        pObj->iTemp = Mini_AigCreatePi(p);
    // create internal nodes
Alan Mishchenko committed
138
    Abc_NtkForEachNode( pNtk, pObj, i )
139 140
        pObj->iTemp = Mini_AigAnd( p, Abc_NodeFanin0Copy2(pObj), Abc_NodeFanin1Copy2(pObj) );
    // create primary outputs
Alan Mishchenko committed
141
    Abc_NtkForEachCo( pNtk, pObj, i )
142
        pObj->iTemp = Mini_AigCreatePo( p, Abc_NodeFanin0Copy2(pObj) );
143 144
    // set registers
    Mini_AigSetRegNum( p, Abc_NtkLatchNum(pNtk) );
145
    return p;
Alan Mishchenko committed
146 147 148 149
}

/**Function*************************************************************

150
  Synopsis    [Procedures to update internal ABC network using AIG node array.]
Alan Mishchenko committed
151 152 153 154 155 156 157 158

  Description []
               
  SideEffects []

  SeeAlso     []

***********************************************************************/
159
void Abc_NtkInputMiniAig( Abc_Frame_t * pAbc, void * p )
Alan Mishchenko committed
160
{
161 162 163
    Abc_Ntk_t * pNtk;
    if ( pAbc == NULL )
        printf( "ABC framework is not initialized by calling Abc_Start()\n" );
164
    pNtk = Abc_NtkFromMiniAig( (Mini_Aig_t *)p );
165 166
    Abc_FrameReplaceCurrentNetwork( pAbc, pNtk );
//    Abc_NtkDelete( pNtk );
Alan Mishchenko committed
167
}
168 169 170 171 172 173 174 175 176 177
void * Abc_NtkOutputMiniAig( Abc_Frame_t * pAbc )
{
    Abc_Ntk_t * pNtk;
    if ( pAbc == NULL )
        printf( "ABC framework is not initialized by calling Abc_Start()\n" );
    pNtk = Abc_FrameReadNtk( pAbc );
    if ( pNtk == NULL )
        printf( "Current network in ABC framework is not defined.\n" );
    return Abc_NtkToMiniAig( pNtk );
}
178 179 180 181 182 183 184 185 186 187 188
void Abc_NtkSetFlopNum( Abc_Frame_t * pAbc, int nFlops )
{
    extern void Abc_NtkMakeSeq( Abc_Ntk_t * pNtk, int nFlops );
    Abc_Ntk_t * pNtk;
    if ( pAbc == NULL )
        printf( "ABC framework is not initialized by calling Abc_Start()\n" );
    pNtk = Abc_FrameReadNtk( pAbc );
    if ( pNtk == NULL )
        printf( "Current network in ABC framework is not defined.\n" );
    Abc_NtkMakeSeq( pNtk, nFlops );
}
189

190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207
/**Function*************************************************************

  Synopsis    [Testing the above code.]

  Description []
               
  SideEffects []

  SeeAlso     []

***********************************************************************/
void Abc_NtkMiniAigTest( Abc_Ntk_t * pNtk )
{
    Abc_Ntk_t * pNtkNew;
    Mini_Aig_t * p;
    p = Abc_NtkToMiniAig( pNtk );
    pNtkNew = Abc_NtkFromMiniAig( p );
    Mini_AigStop( p );
208
    Abc_NtkPrintStats( pNtkNew, 0, 0, 0, 0, 0, 0, 0, 0, 0 );
209
    Abc_NtkDelete( pNtkNew );
210 211 212 213 214 215 216 217 218 219

    // test dumping
    p = Abc_NtkToMiniAig( pNtk );
    Mini_AigDump( p, "miniaig.data" );
    Mini_AigPrintStats( p );
    Mini_AigStop( p );

    p = Mini_AigLoad( "miniaig.data" );
    Mini_AigPrintStats( p );
    Mini_AigStop( p );
220 221 222 223 224 225 226 227 228 229 230
}

/*
    if ( pNtk )
    {
        extern void Abc_NtkMiniAigTest( Abc_Ntk_t * pNtk );
        Abc_NtkMiniAigTest( pNtk );

    }
*/

Alan Mishchenko committed
231 232 233 234 235
////////////////////////////////////////////////////////////////////////
///                       END OF FILE                                ///
////////////////////////////////////////////////////////////////////////


236 237
ABC_NAMESPACE_IMPL_END