PageRenderTime 51ms CodeModel.GetById 21ms RepoModel.GetById 0ms app.codeStats 0ms

/src/base/abc/abcUtil.c

https://bitbucket.org/alanmi/abc/
C | 2935 lines | 1741 code | 122 blank | 1072 comment | 313 complexity | aac5066405751703941b7c80364bff0e MD5 | raw file
Possible License(s): BSD-3-Clause

Large files files are truncated, but you can click here to view the full file

    

  1. /**CFile****************************************************************
    2. 

    3. 

  3.   FileName    [abcUtil.c]
    4. 

    5. 

  5.   SystemName  [ABC: Logic synthesis and verification system.]
    6. 

    7. 

  7.   PackageName [Network and node package.]
    8. 

    9. 

  9.   Synopsis    [Various utilities.]
    10. 

    11. 

  11.   Author      [Alan Mishchenko]
    12. 

  12.   
    13. 

  13.   Affiliation [UC Berkeley]
    14. 

    15. 

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

    17. 

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

    19. 

  19. ***********************************************************************/
    20. 

  20. 

  21. #include "abc.h"
    22. 

  22. #include "base/main/main.h"
    23. 

  23. #include "map/mio/mio.h"
    24. 

  24. #include "bool/dec/dec.h"
    25. 

  25. #include "opt/fxu/fxu.h"

    26. 

  26. 

    27. 

  27. #ifdef ABC_USE_CUDD

    28. 

  28. #include "bdd/extrab/extraBdd.h"

    29. 

  29. #endif

    30. 

  30. 

  31. ABC_NAMESPACE_IMPL_START
    32. 

  32. 

  33. 

  34. ////////////////////////////////////////////////////////////////////////
    35. 

  35. ///                        DECLARATIONS                              ///
    36. 

  36. ////////////////////////////////////////////////////////////////////////
    37. 

  37. 

  38. ////////////////////////////////////////////////////////////////////////
    39. 

  39. ///                     FUNCTION DEFINITIONS                         ///
    40. 

  40. ////////////////////////////////////////////////////////////////////////
    41. 

  41. 

  42. /**Function*************************************************************
    43. 

    44. 

  44.   Synopsis    [Frees one attribute manager.]
    45. 

    46. 

  46.   Description []
    47. 

  47.                
    48. 

  48.   SideEffects []
    49. 

    50. 

  50.   SeeAlso     []
    51. 

    52. 

  52. ***********************************************************************/
    53. 

  53. void * Abc_NtkAttrFree( Abc_Ntk_t * pNtk, int Attr, int fFreeMan ) 
    54. 

  54. {  
    55. 

  55.     void * pUserMan;
    56. 

  56.     Vec_Att_t * pAttrMan;
    57. 

  57.     pAttrMan = (Vec_Att_t *)Vec_PtrEntry( pNtk->vAttrs, Attr );
    58. 

  58.     Vec_PtrWriteEntry( pNtk->vAttrs, Attr, NULL );
    59. 

  59.     pUserMan = Vec_AttFree( pAttrMan, fFreeMan );
    60. 

  60.     return pUserMan;
    61. 

  61. }
    62. 

  62. 

  63. /**Function*************************************************************
    64. 

    65. 

  65.   Synopsis    [Order CI/COs.]
    66. 

    67. 

  67.   Description []
    68. 

  68.                
    69. 

  69.   SideEffects []
    70. 

    71. 

  71.   SeeAlso     []
    72. 

    73. 

  73. ***********************************************************************/
    74. 

  74. void Abc_NtkOrderCisCos( Abc_Ntk_t * pNtk )
    75. 

  75. {
    76. 

  76.     Abc_Obj_t * pObj, * pTerm;
    77. 

  77.     int i, k;
    78. 

  78.     Vec_PtrClear( pNtk->vCis );
    79. 

  79.     Vec_PtrClear( pNtk->vCos );
    80. 

  80.     Abc_NtkForEachPi( pNtk, pObj, i )
    81. 

  81.         Vec_PtrPush( pNtk->vCis, pObj );
    82. 

  82.     Abc_NtkForEachPo( pNtk, pObj, i )
    83. 

  83.         Vec_PtrPush( pNtk->vCos, pObj );
    84. 

  84.     Abc_NtkForEachBox( pNtk, pObj, i )
    85. 

  85.     {
    86. 

  86.         if ( Abc_ObjIsLatch(pObj) )
    87. 

  87.             continue;
    88. 

  88.         Abc_ObjForEachFanin( pObj, pTerm, k )
    89. 

  89.             Vec_PtrPush( pNtk->vCos, pTerm );
    90. 

  90.         Abc_ObjForEachFanout( pObj, pTerm, k )
    91. 

  91.             Vec_PtrPush( pNtk->vCis, pTerm );
    92. 

  92.     }
    93. 

  93.     Abc_NtkForEachBox( pNtk, pObj, i )
    94. 

  94.     {
    95. 

  95.         if ( !Abc_ObjIsLatch(pObj) )
    96. 

  96.             continue;
    97. 

  97.         Abc_ObjForEachFanin( pObj, pTerm, k )
    98. 

  98.             Vec_PtrPush( pNtk->vCos, pTerm );
    99. 

  99.         Abc_ObjForEachFanout( pObj, pTerm, k )
    100. 

  100.             Vec_PtrPush( pNtk->vCis, pTerm );
    101. 

  101.     }
    102. 

  102. }
    103. 

  103. 

  104. /**Function*************************************************************
    105. 

    106. 

  106.   Synopsis    [Reads the number of cubes of the node.]
    107. 

    108. 

  108.   Description []
    109. 

  109.                
    110. 

  110.   SideEffects []
    111. 

    112. 

  112.   SeeAlso     []
    113. 

    114. 

  114. ***********************************************************************/
    115. 

  115. int Abc_NtkGetCubeNum( Abc_Ntk_t * pNtk )
    116. 

  116. {
    117. 

  117.     Abc_Obj_t * pNode;
    118. 

  118.     int i, nCubes = 0;
    119. 

  119.     assert( Abc_NtkHasSop(pNtk) );
    120. 

  120.     Abc_NtkForEachNode( pNtk, pNode, i )
    121. 

  121.     {
    122. 

  122.         if ( Abc_NodeIsConst(pNode) )
    123. 

  123.             continue;
    124. 

  124.         assert( pNode->pData );
    125. 

  125.         nCubes += Abc_SopGetCubeNum( (char *)pNode->pData );
    126. 

  126.     }
    127. 

  127.     return nCubes;
    128. 

  128. }
    129. 

  129. 

  130. /**Function*************************************************************
    131. 

    132. 

  132.   Synopsis    [Reads the number of cubes of the node.]
    133. 

    134. 

  134.   Description []
    135. 

  135.                
    136. 

  136.   SideEffects []
    137. 

    138. 

  138.   SeeAlso     []
    139. 

    140. 

  140. ***********************************************************************/
    141. 

  141. int Abc_NtkGetCubePairNum( Abc_Ntk_t * pNtk )
    142. 

  142. {
    143. 

  143.     Abc_Obj_t * pNode;
    144. 

  144.     int i;

    145. 

  145.     word nCubes, nCubePairs = 0;
    146. 

  146.     assert( Abc_NtkHasSop(pNtk) );
    147. 

  147.     Abc_NtkForEachNode( pNtk, pNode, i )
    148. 

  148.     {
    149. 

  149.         if ( Abc_NodeIsConst(pNode) )
    150. 

  150.             continue;
    151. 

  151.         assert( pNode->pData );
    152. 

  152.         nCubes = (word)Abc_SopGetCubeNum( (char *)pNode->pData );

    153. 

  153.         if ( nCubes > 1 )

    154. 

  154.             nCubePairs += nCubes * (nCubes - 1) / 2;
    155. 

  155.     }
    156. 

  156.     return (int)(nCubePairs > (1<<30) ? (1<<30) : nCubePairs);
    157. 

  157. }
    158. 

  158. 

  159. /**Function*************************************************************
    160. 

    161. 

  161.   Synopsis    [Reads the number of literals in the SOPs of the nodes.]
    162. 

    163. 

  163.   Description []
    164. 

  164.                
    165. 

  165.   SideEffects []
    166. 

    167. 

  167.   SeeAlso     []
    168. 

    169. 

  169. ***********************************************************************/
    170. 

  170. int Abc_NtkGetLitNum( Abc_Ntk_t * pNtk )
    171. 

  171. {
    172. 

  172.     Abc_Obj_t * pNode;
    173. 

  173.     int i, nLits = 0;
    174. 

  174.     assert( Abc_NtkHasSop(pNtk) );
    175. 

  175.     Abc_NtkForEachNode( pNtk, pNode, i )
    176. 

  176.     {
    177. 

  177.         assert( pNode->pData );
    178. 

  178.         nLits += Abc_SopGetLitNum( (char *)pNode->pData );
    179. 

  179.     }
    180. 

  180.     return nLits;
    181. 

  181. }
    182. 

  182. 

  183. /**Function*************************************************************
    184. 

    185. 

  185.   Synopsis    [Counts the number of literals in the factored forms.]
    186. 

    187. 

  187.   Description []
    188. 

  188.                
    189. 

  189.   SideEffects []
    190. 

    191. 

  191.   SeeAlso     []
    192. 

    193. 

  193. ***********************************************************************/
    194. 

  194. int Abc_NtkGetLitFactNum( Abc_Ntk_t * pNtk )
    195. 

  195. {
    196. 

  196.     Dec_Graph_t * pFactor;
    197. 

  197.     Abc_Obj_t * pNode;
    198. 

  198.     int nNodes, i;
    199. 

  199.     assert( Abc_NtkHasSop(pNtk) );
    200. 

  200.     nNodes = 0;
    201. 

  201.     Abc_NtkForEachNode( pNtk, pNode, i )
    202. 

  202.     {
    203. 

  203.         if ( Abc_NodeIsConst(pNode) )
    204. 

  204.             continue;
    205. 

  205.         pFactor = Dec_Factor( (char *)pNode->pData );
    206. 

  206.         nNodes += 1 + Dec_GraphNodeNum(pFactor);
    207. 

  207.         Dec_GraphFree( pFactor );
    208. 

  208.     }
    209. 

  209.     return nNodes;
    210. 

  210. }
    211. 

  211. 

  212. /**Function*************************************************************
    213. 

    214. 

  214.   Synopsis    [Counts the number of nodes with more than 1 reference.]
    215. 

    216. 

  216.   Description []
    217. 

  217.                
    218. 

  218.   SideEffects []
    219. 

    220. 

  220.   SeeAlso     []
    221. 

    222. 

  222. ***********************************************************************/
    223. 

  223. int Abc_NtkGetMultiRefNum( Abc_Ntk_t * pNtk )
    224. 

  224. {
    225. 

  225.     Abc_Obj_t * pNode;
    226. 

  226.     int nNodes, i;
    227. 

  227.     assert( Abc_NtkIsStrash(pNtk) );
    228. 

  228.     nNodes = 0;
    229. 

  229.     Abc_NtkForEachNode( pNtk, pNode, i )
    230. 

  230.         nNodes += (int)(Abc_ObjFanoutNum(pNode) > 1);
    231. 

  231.     return nNodes;
    232. 

  232. }
    233. 

  233. 

  234. /**Function*************************************************************
    235. 

    236. 

  236.   Synopsis    [Reads the number of BDD nodes.]
    237. 

    238. 

  238.   Description []
    239. 

  239.                
    240. 

  240.   SideEffects []
    241. 

    242. 

  242.   SeeAlso     []
    243. 

    244. 

  244. ***********************************************************************/
    245. 

  245. int Abc_NtkGetBddNodeNum( Abc_Ntk_t * pNtk )
    246. 

  246. {

    247. 

  247.     int nNodes = 0;

    248. 

  248. #ifdef ABC_USE_CUDD

    249. 

  249.     Abc_Obj_t * pNode;

    250. 

  250.     int i;
    251. 

  251.     assert( Abc_NtkIsBddLogic(pNtk) );
    252. 

  252.     Abc_NtkForEachNode( pNtk, pNode, i )
    253. 

  253.     {
    254. 

  254.         assert( pNode->pData );
    255. 

  255.         if ( Abc_ObjFaninNum(pNode) < 2 )
    256. 

  256.             continue;
    257. 

  257.         nNodes += pNode->pData? -1 + Cudd_DagSize( (DdNode *)pNode->pData ) : 0;
    258. 

  258.     }
    259. 

  259. #endif

    260. 

  260.     return nNodes;
    261. 

  261. }
    262. 

  262. 

  263. /**Function*************************************************************
    264. 

    265. 

  265.   Synopsis    [Reads the number of BDD nodes.]
    266. 

    267. 

  267.   Description []
    268. 

  268.                
    269. 

  269.   SideEffects []
    270. 

    271. 

  271.   SeeAlso     []
    272. 

    273. 

  273. ***********************************************************************/
    274. 

  274. int Abc_NtkGetAigNodeNum( Abc_Ntk_t * pNtk )
    275. 

  275. {
    276. 

  276.     Abc_Obj_t * pNode;
    277. 

  277.     int i, nNodes = 0;
    278. 

  278.     assert( Abc_NtkIsAigLogic(pNtk) );
    279. 

  279.     Abc_NtkForEachNode( pNtk, pNode, i )
    280. 

  280.     {
    281. 

  281.         assert( pNode->pData );
    282. 

  282.         if ( Abc_ObjFaninNum(pNode) < 2 )
    283. 

  283.             continue;
    284. 

  284. //printf( "%d ", Hop_DagSize( pNode->pData ) );
    285. 

  285.         nNodes += pNode->pData? Hop_DagSize( (Hop_Obj_t *)pNode->pData ) : 0;
    286. 

  286.     }
    287. 

  287.     return nNodes;
    288. 

  288. }
    289. 

  289. 

  290. /**Function*************************************************************
    291. 

    292. 

  292.   Synopsis    [Reads the number of BDD nodes.]
    293. 

    294. 

  294.   Description []
    295. 

  295.                
    296. 

  296.   SideEffects []
    297. 

    298. 

  298.   SeeAlso     []
    299. 

    300. 

  300. ***********************************************************************/
    301. 

  301. int Abc_NtkGetClauseNum( Abc_Ntk_t * pNtk )
    302. 

  302. {

    303. 

  303.     int nClauses = 0;

    304. 

  304. #ifdef ABC_USE_CUDD

    305. 

  305.     extern int Abc_CountZddCubes( DdManager * dd, DdNode * zCover );
    306. 

  306.     Abc_Obj_t * pNode;
    307. 

  307.     DdNode * bCover, * zCover, * bFunc;
    308. 

  308.     DdManager * dd = (DdManager *)pNtk->pManFunc;
    309. 

  309.     int i;
    310. 

  310.     assert( Abc_NtkIsBddLogic(pNtk) );
    311. 

  311.     Abc_NtkForEachNode( pNtk, pNode, i )
    312. 

  312.     {
    313. 

  313.         assert( pNode->pData );
    314. 

  314.         bFunc = (DdNode *)pNode->pData;
    315. 

  315. 

  316.         bCover = Cudd_zddIsop( dd, bFunc, bFunc, &zCover );  
    317. 

  317.         Cudd_Ref( bCover );
    318. 

  318.         Cudd_Ref( zCover );
    319. 

  319.         nClauses += Abc_CountZddCubes( dd, zCover );
    320. 

  320.         Cudd_RecursiveDeref( dd, bCover );
    321. 

  321.         Cudd_RecursiveDerefZdd( dd, zCover );
    322. 

  322. 

  323.         bCover = Cudd_zddIsop( dd, Cudd_Not(bFunc), Cudd_Not(bFunc), &zCover );  
    324. 

  324.         Cudd_Ref( bCover );
    325. 

  325.         Cudd_Ref( zCover );
    326. 

  326.         nClauses += Abc_CountZddCubes( dd, zCover );
    327. 

  327.         Cudd_RecursiveDeref( dd, bCover );
    328. 

  328.         Cudd_RecursiveDerefZdd( dd, zCover );
    329. 

  329.     }

    330. 

  330. #endif
    331. 

  331.     return nClauses;
    332. 

  332. }
    333. 

  333. 

  334. /**Function*************************************************************
    335. 

    336. 

  336.   Synopsis    [Computes the area of the mapped circuit.]
    337. 

    338. 

  338.   Description []
    339. 

  339.                
    340. 

  340.   SideEffects []
    341. 

    342. 

  342.   SeeAlso     []
    343. 

    344. 

  344. ***********************************************************************/
    345. 

  345. double Abc_NtkGetMappedArea( Abc_Ntk_t * pNtk )
    346. 

  346. {
    347. 

  347.     Abc_Obj_t * pObj;
    348. 

  348.     double TotalArea;
    349. 

  349.     int i;
    350. 

  350.     assert( Abc_NtkHasMapping(pNtk) );
    351. 

  351.     TotalArea = 0.0;
    352. 

  352.     Abc_NtkForEachNode( pNtk, pObj, i )
    353. 

  353.     {

    354. 

  354.         if ( Abc_ObjIsBarBuf(pObj) )

    355. 

  355.             continue;
    356. 

  356. //        assert( pObj->pData );
    357. 

  357.         if ( pObj->pData == NULL )
    358. 

  358.         {
    359. 

  359.             printf( "Node without mapping is encountered.\n" );
    360. 

  360.             continue;
    361. 

  361.         }
    362. 

  362.         TotalArea += Mio_GateReadArea( (Mio_Gate_t *)pObj->pData );
    363. 

  363.         // assuming that twin gates follow each other
    364. 

  364.         if ( Abc_NtkFetchTwinNode(pObj) )
    365. 

  365.             i++;
    366. 

  366.     }
    367. 

  367.     return TotalArea;
    368. 

  368. }
    369. 

  369. 

  370. /**Function*************************************************************
    371. 

    372. 

  372.   Synopsis    [Counts the number of exors.]
    373. 

    374. 

  374.   Description []
    375. 

  375.                
    376. 

  376.   SideEffects []
    377. 

    378. 

  378.   SeeAlso     []
    379. 

    380. 

  380. ***********************************************************************/
    381. 

  381. int Abc_NtkGetExorNum( Abc_Ntk_t * pNtk )
    382. 

  382. {
    383. 

  383.     Abc_Obj_t * pNode;
    384. 

  384.     int i, Counter = 0;
    385. 

  385.     Abc_NtkForEachNode( pNtk, pNode, i )
    386. 

  386.         Counter += pNode->fExor;
    387. 

  387.     return Counter;
    388. 

  388. }
    389. 

  389. 

    390. 

  390. /**Function*************************************************************

    391. 

  391. 

    392. 

  392.   Synopsis    [Counts the number of exors.]

    393. 

  393. 

    394. 

  394.   Description []

    395. 

  395.                

    396. 

  396.   SideEffects []

    397. 

  397. 

    398. 

  398.   SeeAlso     []

    399. 

  399. 

    400. 

  400. ***********************************************************************/

    401. 

  401. int Abc_NtkGetMuxNum( Abc_Ntk_t * pNtk )

    402. 

  402. {

    403. 

  403.     Abc_Obj_t * pNode;

    404. 

  404.     int i, Counter = 0;

    405. 

  405.     Abc_NtkForEachNode( pNtk, pNode, i )

    406. 

  406.         Counter += Abc_NodeIsMuxType(pNode);

    407. 

  407.     return Counter;

    408. 

  408. }

    409. 

  409. 

    410. 

  410. /**Function*************************************************************

    411. 

  411. 

    412. 

  412.   Synopsis    [Counts the number of exors.]

    413. 

  413. 

    414. 

  414.   Description []

    415. 

  415.                

    416. 

  416.   SideEffects []

    417. 

  417. 

    418. 

  418.   SeeAlso     []

    419. 

  419. 

    420. 

  420. ***********************************************************************/

    421. 

  421. int Abc_NtkGetBufNum( Abc_Ntk_t * pNtk )

    422. 

  422. {

    423. 

  423.     Abc_Obj_t * pNode;

    424. 

  424.     int i, Counter = 0;

    425. 

  425.     Abc_NtkForEachNode( pNtk, pNode, i )

    426. 

  426.         Counter += (Abc_ObjFaninNum(pNode) == 1);

    427. 

  427.     return Counter;

    428. 

  428. }

    429. 

  429. 

    430. 

  430. /**Function*************************************************************

    431. 

  431. 

    432. 

  432.   Synopsis    [Counts the number of exors.]

    433. 

  433. 

    434. 

  434.   Description []

    435. 

  435.                

    436. 

  436.   SideEffects []

    437. 

  437. 

    438. 

  438.   SeeAlso     []

    439. 

  439. 

    440. 

  440. ***********************************************************************/

    441. 

  441. int Abc_NtkGetLargeNodeNum( Abc_Ntk_t * pNtk )

    442. 

  442. {

    443. 

  443.     Abc_Obj_t * pNode;

    444. 

  444.     int i, Counter = 0;

    445. 

  445.     Abc_NtkForEachNode( pNtk, pNode, i )

    446. 

  446.         Counter += (Abc_ObjFaninNum(pNode) > 1);

    447. 

  447.     return Counter;

    448. 

  448. }

    449. 

  449. 

  450. /**Function*************************************************************
    451. 

    452. 

  452.   Synopsis    [Returns 1 if it is an AIG with choice nodes.]
    453. 

    454. 

  454.   Description []
    455. 

  455.                
    456. 

  456.   SideEffects []
    457. 

    458. 

  458.   SeeAlso     []
    459. 

    460. 

  460. ***********************************************************************/
    461. 

  461. int Abc_NtkGetChoiceNum( Abc_Ntk_t * pNtk )
    462. 

  462. {
    463. 

  463.     Abc_Obj_t * pNode;
    464. 

  464.     int i, Counter;
    465. 

  465.     if ( !Abc_NtkIsStrash(pNtk) )
    466. 

  466.         return 0;
    467. 

  467.     Counter = 0;
    468. 

  468.     Abc_NtkForEachNode( pNtk, pNode, i )
    469. 

  469.         Counter += Abc_AigNodeIsChoice( pNode );
    470. 

  470.     return Counter;
    471. 

  471. }
    472. 

  472. 

  473. /**Function*************************************************************
    474. 

    475. 

  475.   Synopsis    [Reads the maximum number of fanins.]
    476. 

    477. 

  477.   Description []
    478. 

  478.                
    479. 

  479.   SideEffects []
    480. 

    481. 

  481.   SeeAlso     []
    482. 

    483. 

  483. ***********************************************************************/
    484. 

  484. int Abc_NtkGetFaninMax( Abc_Ntk_t * pNtk )

    485. 

  485. {

    486. 

  486.     Abc_Obj_t * pNode;

    487. 

  487.     int i, nFaninsMax = 0;

    488. 

  488.     Abc_NtkForEachNode( pNtk, pNode, i )

    489. 

  489.     {

    490. 

  490.         if ( nFaninsMax < Abc_ObjFaninNum(pNode) )

    491. 

  491.             nFaninsMax = Abc_ObjFaninNum(pNode);

    492. 

  492.     }

    493. 

  493.     return nFaninsMax;

    494. 

  494. }

    495. 

  495. int Abc_NtkGetFanoutMax( Abc_Ntk_t * pNtk )

    496. 

  496. {

    497. 

  497.     Abc_Obj_t * pNode;

    498. 

  498.     int i, nFaninsMax = 0;

    499. 

  499.     Abc_NtkForEachNode( pNtk, pNode, i )

    500. 

  500.     {

    501. 

  501.         if ( nFaninsMax < Abc_ObjFanoutNum(pNode) )

    502. 

  502.             nFaninsMax = Abc_ObjFanoutNum(pNode);

    503. 

  503.     }

    504. 

  504.     return nFaninsMax;

    505. 

  505. }

    506. 

  506. 

  507. /**Function*************************************************************
    508. 

    509. 

  509.   Synopsis    [Reads the total number of all fanins.]
    510. 

    511. 

  511.   Description []
    512. 

  512.                
    513. 

  513.   SideEffects []
    514. 

    515. 

  515.   SeeAlso     []
    516. 

    517. 

  517. ***********************************************************************/
    518. 

  518. int Abc_NtkGetTotalFanins( Abc_Ntk_t * pNtk )
    519. 

  519. {
    520. 

  520.     Abc_Obj_t * pNode;
    521. 

  521.     int i, nFanins = 0;
    522. 

  522.     Abc_NtkForEachNode( pNtk, pNode, i )
    523. 

  523.         nFanins += Abc_ObjFaninNum(pNode);
    524. 

  524.     return nFanins;
    525. 

  525. }
    526. 

  526. 

  527. /**Function*************************************************************
    528. 

    529. 

  529.   Synopsis    [Cleans the copy field of all objects.]
    530. 

    531. 

  531.   Description []
    532. 

  532.                
    533. 

  533.   SideEffects []
    534. 

    535. 

  535.   SeeAlso     []
    536. 

    537. 

  537. ***********************************************************************/
    538. 

  538. void Abc_NtkCleanCopy( Abc_Ntk_t * pNtk )
    539. 

  539. {
    540. 

  540.     Abc_Obj_t * pObj;
    541. 

  541.     int i;
    542. 

  542.     Abc_NtkForEachObj( pNtk, pObj, i )
    543. 

  543.         pObj->pCopy = NULL;
    544. 

  544. }
    545. 

  545. void Abc_NtkCleanCopy_rec( Abc_Ntk_t * pNtk )

    546. 

  546. {

    547. 

  547.     Abc_Obj_t * pObj; 

    548. 

  548.     int i;

    549. 

  549.     Abc_NtkCleanCopy( pNtk );

    550. 

  550.     Abc_NtkForEachBox( pNtk, pObj, i )

    551. 

  551.         Abc_NtkCleanCopy_rec( Abc_ObjModel(pObj) );

    552. 

  552. }

    553. 

  553. 

  554. /**Function*************************************************************
    555. 

    556. 

  556.   Synopsis    [Cleans the copy field of all objects.]
    557. 

    558. 

  558.   Description []
    559. 

  559.                
    560. 

  560.   SideEffects []
    561. 

    562. 

  562.   SeeAlso     []
    563. 

    564. 

  564. ***********************************************************************/
    565. 

  565. void Abc_NtkCleanData( Abc_Ntk_t * pNtk )
    566. 

  566. {
    567. 

  567.     Abc_Obj_t * pObj;
    568. 

  568.     int i;
    569. 

  569.     Abc_NtkForEachObj( pNtk, pObj, i )
    570. 

  570.         pObj->pData = NULL;
    571. 

  571. }
    572. 

  572. 

  573. /**Function*************************************************************
    574. 

    575. 

  575.   Synopsis    [Cleans the copy field of all objects.]
    576. 

    577. 

  577.   Description []
    578. 

  578.                
    579. 

  579.   SideEffects []
    580. 

    581. 

  581.   SeeAlso     []
    582. 

    583. 

  583. ***********************************************************************/
    584. 

  584. void Abc_NtkFillTemp( Abc_Ntk_t * pNtk )
    585. 

  585. {
    586. 

  586.     Abc_Obj_t * pObj;
    587. 

  587.     int i;
    588. 

  588.     Abc_NtkForEachObj( pNtk, pObj, i )
    589. 

  589.         pObj->iTemp = -1;
    590. 

  590. }
    591. 

  591. 

  592. /**Function*************************************************************
    593. 

    594. 

  594.   Synopsis    [Counts the number of nodes having non-trivial copies.]
    595. 

    596. 

  596.   Description []
    597. 

  597.                
    598. 

  598.   SideEffects []
    599. 

    600. 

  600.   SeeAlso     []
    601. 

    602. 

  602. ***********************************************************************/
    603. 

  603. int Abc_NtkCountCopy( Abc_Ntk_t * pNtk )
    604. 

  604. {
    605. 

  605.     Abc_Obj_t * pObj;
    606. 

  606.     int i, Counter = 0;
    607. 

  607.     Abc_NtkForEachObj( pNtk, pObj, i )
    608. 

  608.     {
    609. 

  609.         if ( Abc_ObjIsNode(pObj) )
    610. 

  610.             Counter += (pObj->pCopy != NULL);
    611. 

  611.     }
    612. 

  612.     return Counter;
    613. 

  613. }
    614. 

  614. 

  615. /**Function*************************************************************
    616. 

    617. 

  617.   Synopsis    [Saves copy field of the objects.]
    618. 

    619. 

  619.   Description []
    620. 

  620.                
    621. 

  621.   SideEffects []
    622. 

    623. 

  623.   SeeAlso     []
    624. 

    625. 

  625. ***********************************************************************/
    626. 

  626. Vec_Ptr_t * Abc_NtkSaveCopy( Abc_Ntk_t * pNtk )
    627. 

  627. {
    628. 

  628.     Vec_Ptr_t * vCopies;
    629. 

  629.     Abc_Obj_t * pObj;
    630. 

  630.     int i;
    631. 

  631.     vCopies = Vec_PtrStart( Abc_NtkObjNumMax(pNtk) );
    632. 

  632.     Abc_NtkForEachObj( pNtk, pObj, i )
    633. 

  633.         Vec_PtrWriteEntry( vCopies, i, pObj->pCopy );
    634. 

  634.     return vCopies;
    635. 

  635. }
    636. 

  636. 

  637. /**Function*************************************************************
    638. 

    639. 

  639.   Synopsis    [Loads copy field of the objects.]
    640. 

    641. 

  641.   Description []
    642. 

  642.                
    643. 

  643.   SideEffects []
    644. 

    645. 

  645.   SeeAlso     []
    646. 

    647. 

  647. ***********************************************************************/
    648. 

  648. void Abc_NtkLoadCopy( Abc_Ntk_t * pNtk, Vec_Ptr_t * vCopies )
    649. 

  649. {
    650. 

  650.     Abc_Obj_t * pObj;
    651. 

  651.     int i;
    652. 

  652.     Abc_NtkForEachObj( pNtk, pObj, i )
    653. 

  653.         pObj->pCopy = (Abc_Obj_t *)Vec_PtrEntry( vCopies, i );
    654. 

  654. }
    655. 

  655. 

  656. /**Function*************************************************************
    657. 

    658. 

  658.   Synopsis    [Cleans the copy field of all objects.]
    659. 

    660. 

  660.   Description []
    661. 

  661.                
    662. 

  662.   SideEffects []
    663. 

    664. 

  664.   SeeAlso     []
    665. 

    666. 

  666. ***********************************************************************/
    667. 

  667. void Abc_NtkCleanNext( Abc_Ntk_t * pNtk )
    668. 

  668. {
    669. 

  669.     Abc_Obj_t * pObj;
    670. 

  670.     int i;
    671. 

  671.     Abc_NtkForEachObj( pNtk, pObj, i )
    672. 

  672.         pObj->pNext = NULL;
    673. 

  673. }
    674. 

  674. void Abc_NtkCleanNext_rec( Abc_Ntk_t * pNtk )

    675. 

  675. {

    676. 

  676.     Abc_Obj_t * pObj; 

    677. 

  677.     int i;

    678. 

  678.     Abc_NtkCleanNext( pNtk );

    679. 

  679.     Abc_NtkForEachBox( pNtk, pObj, i )

    680. 

  680.         Abc_NtkCleanNext_rec( Abc_ObjModel(pObj) );

    681. 

  681. }

    682. 

  682. 

  683. /**Function*************************************************************
    684. 

    685. 

  685.   Synopsis    [Cleans the copy field of all objects.]
    686. 

    687. 

  687.   Description []
    688. 

  688.                
    689. 

  689.   SideEffects []
    690. 

    691. 

  691.   SeeAlso     []
    692. 

    693. 

  693. ***********************************************************************/
    694. 

  694. void Abc_NtkCleanMarkA( Abc_Ntk_t * pNtk )
    695. 

  695. {
    696. 

  696.     Abc_Obj_t * pObj;
    697. 

  697.     int i;
    698. 

  698.     Abc_NtkForEachObj( pNtk, pObj, i )
    699. 

  699.         pObj->fMarkA = 0;
    700. 

  700. }
    701. 

  701. 

  702. /**Function*************************************************************
    703. 

    704. 

  704.   Synopsis    [Cleans the copy field of all objects.]
    705. 

    706. 

  706.   Description []
    707. 

  707.                
    708. 

  708.   SideEffects []
    709. 

    710. 

  710.   SeeAlso     []
    711. 

    712. 

  712. ***********************************************************************/
    713. 

  713. void Abc_NtkCleanMarkB( Abc_Ntk_t * pNtk )
    714. 

  714. {
    715. 

  715.     Abc_Obj_t * pObj;
    716. 

  716.     int i;
    717. 

  717.     Abc_NtkForEachObj( pNtk, pObj, i )
    718. 

  718.         pObj->fMarkB = 0;
    719. 

  719. }
    720. 

  720. 

  721. /**Function*************************************************************
    722. 

    723. 

  723.   Synopsis    [Cleans the copy field of all objects.]
    724. 

    725. 

  725.   Description []
    726. 

  726.                
    727. 

  727.   SideEffects []
    728. 

    729. 

  729.   SeeAlso     []
    730. 

    731. 

  731. ***********************************************************************/
    732. 

  732. void Abc_NtkCleanMarkC( Abc_Ntk_t * pNtk )
    733. 

  733. {
    734. 

  734.     Abc_Obj_t * pObj;
    735. 

  735.     int i;
    736. 

  736.     Abc_NtkForEachObj( pNtk, pObj, i )
    737. 

  737.         pObj->fMarkC = 0;
    738. 

  738. }
    739. 

  739. 

  740. /**Function*************************************************************
    741. 

    742. 

  742.   Synopsis    [Cleans the copy field of all objects.]
    743. 

    744. 

  744.   Description []
    745. 

  745.                
    746. 

  746.   SideEffects []
    747. 

    748. 

  748.   SeeAlso     []
    749. 

    750. 

  750. ***********************************************************************/
    751. 

  751. void Abc_NtkCleanMarkAB( Abc_Ntk_t * pNtk )
    752. 

  752. {
    753. 

  753.     Abc_Obj_t * pObj;
    754. 

  754.     int i;
    755. 

  755.     Abc_NtkForEachObj( pNtk, pObj, i )
    756. 

  756.         pObj->fMarkA = pObj->fMarkB = 0;
    757. 

  757. }
    758. 

  758. 

  759. /**Function*************************************************************
    760. 

    761. 

  761.   Synopsis    [Cleans the copy field of all objects.]
    762. 

    763. 

  763.   Description []
    764. 

  764.                
    765. 

  765.   SideEffects []
    766. 

    767. 

  767.   SeeAlso     []
    768. 

    769. 

  769. ***********************************************************************/
    770. 

  770. void Abc_NtkCleanMarkABC( Abc_Ntk_t * pNtk )
    771. 

  771. {
    772. 

  772.     Abc_Obj_t * pObj;
    773. 

  773.     int i;
    774. 

  774.     Abc_NtkForEachObj( pNtk, pObj, i )
    775. 

  775.         pObj->fMarkA = pObj->fMarkB = pObj->fMarkC = 0;
    776. 

  776. }
    777. 

  777. 

  778. /**Function*************************************************************
    779. 

    780. 

  780.   Synopsis    [Returns the index of the given fanin.]
    781. 

    782. 

  782.   Description []
    783. 

  783.                
    784. 

  784.   SideEffects []
    785. 

    786. 

  786.   SeeAlso     []
    787. 

    788. 

  788. ***********************************************************************/
    789. 

  789. int Abc_NodeFindFanin( Abc_Obj_t * pNode, Abc_Obj_t * pFanin )
    790. 

  790. {
    791. 

  791.     Abc_Obj_t * pThis;
    792. 

  792.     int i;
    793. 

  793.     Abc_ObjForEachFanin( pNode, pThis, i )
    794. 

  794.         if ( pThis == pFanin )
    795. 

  795.             return i;
    796. 

  796.     return -1;
    797. 

  797. }
    798. 

  798. 

  799. /**Function*************************************************************
    800. 

    801. 

  801.   Synopsis    [Checks if the internal node has CO fanout.]
    802. 

    803. 

  803.   Description []
    804. 

  804.                
    805. 

  805.   SideEffects []
    806. 

    807. 

  807.   SeeAlso     []
    808. 

    809. 

  809. ***********************************************************************/
    810. 

  810. Abc_Obj_t * Abc_NodeFindCoFanout( Abc_Obj_t * pNode )
    811. 

  811. {
    812. 

  812.     Abc_Obj_t * pFanout;
    813. 

  813.     int i;
    814. 

  814.     Abc_ObjForEachFanout( pNode, pFanout, i )
    815. 

  815.         if ( Abc_ObjIsCo(pFanout) )
    816. 

  816.             return pFanout;
    817. 

  817.     return NULL;
    818. 

  818. }
    819. 

  819. 

  820. /**Function*************************************************************
    821. 

    822. 

  822.   Synopsis    [Checks if the internal node has CO fanout.]
    823. 

    824. 

  824.   Description []
    825. 

  825.                
    826. 

  826.   SideEffects []
    827. 

    828. 

  828.   SeeAlso     []
    829. 

    830. 

  830. ***********************************************************************/
    831. 

  831. Abc_Obj_t * Abc_NodeFindNonCoFanout( Abc_Obj_t * pNode )
    832. 

  832. {
    833. 

  833.     Abc_Obj_t * pFanout;
    834. 

  834.     int i;
    835. 

  835.     Abc_ObjForEachFanout( pNode, pFanout, i )
    836. 

  836.         if ( !Abc_ObjIsCo(pFanout) )
    837. 

  837.             return pFanout;
    838. 

  838.     return NULL;
    839. 

  839. }
    840. 

  840. 

  841. /**Function*************************************************************
    842. 

    843. 

  843.   Synopsis    [Checks if the internal node has CO drivers with the same name.]
    844. 

    845. 

  845.   Description [Checks if the internal node can borrow its name from CO fanouts. 
    846. 

  846.   This is possible if all COs with non-complemented fanin edge pointing to this 
    847. 

  847.   node have the same name.]
    848. 

  848.                
    849. 

  849.   SideEffects []
    850. 

    851. 

  851.   SeeAlso     []
    852. 

    853. 

  853. ***********************************************************************/
    854. 

  854. Abc_Obj_t * Abc_NodeHasUniqueCoFanout( Abc_Obj_t * pNode )
    855. 

  855. {
    856. 

  856.     Abc_Obj_t * pFanout, * pFanoutCo;
    857. 

  857.     int i;
    858. 

  858.     pFanoutCo = NULL;
    859. 

  859.     Abc_ObjForEachFanout( pNode, pFanout, i )
    860. 

  860.     {
    861. 

  861.         if ( !Abc_ObjIsCo(pFanout) )
    862. 

  862.             continue;
    863. 

  863.         if ( Abc_ObjFaninC0(pFanout) )
    864. 

  864.             continue;
    865. 

  865.         if ( pFanoutCo == NULL )
    866. 

  866.         {
    867. 

  867.             assert( Abc_ObjFaninNum(pFanout) == 1 );
    868. 

  868.             assert( Abc_ObjFanin0(pFanout) == pNode );
    869. 

  869.             pFanoutCo = pFanout;
    870. 

  870.             continue;
    871. 

  871.         }
    872. 

  872.         if ( strcmp( Abc_ObjName(pFanoutCo), Abc_ObjName(pFanout) ) ) // they have diff names
    873. 

  873.             return NULL;
    874. 

  874.     }
    875. 

  875.     return pFanoutCo;
    876. 

  876. }
    877. 

  877. 

  878. /**Function*************************************************************
    879. 

    880. 

  880.   Synopsis    [Fixes the CO driver problem.]
    881. 

    882. 

  882.   Description []
    883. 

  883.                
    884. 

  884.   SideEffects []
    885. 

    886. 

  886.   SeeAlso     []
    887. 

    888. 

  888. ***********************************************************************/
    889. 

  889. void Abc_NtkFixCoDriverProblem( Abc_Obj_t * pDriver, Abc_Obj_t * pNodeCo, int fDuplicate )
    890. 

  890. {
    891. 

  891.     Abc_Ntk_t * pNtk = pDriver->pNtk;
    892. 

  892.     Abc_Obj_t * pDriverNew, * pFanin;
    893. 

  893.     int k;
    894. 

  894.     if ( fDuplicate && !Abc_ObjIsCi(pDriver) )
    895. 

  895.     {
    896. 

  896.         pDriverNew = Abc_NtkDupObj( pNtk, pDriver, 0 ); 
    897. 

  897.         Abc_ObjForEachFanin( pDriver, pFanin, k )
    898. 

  898.             Abc_ObjAddFanin( pDriverNew, pFanin );
    899. 

  899.         if ( Abc_ObjFaninC0(pNodeCo) )
    900. 

  900.         {
    901. 

  901.             // change polarity of the duplicated driver
    902. 

  902.             Abc_NodeComplement( pDriverNew );
    903. 

  903.             Abc_ObjXorFaninC( pNodeCo, 0 );
    904. 

  904.         }
    905. 

  905.     }
    906. 

  906.     else
    907. 

  907.     {
    908. 

  908.         // add inverters and buffers when necessary
    909. 

  909.         if ( Abc_ObjFaninC0(pNodeCo) )
    910. 

  910.         {
    911. 

  911.             pDriverNew = Abc_NtkCreateNodeInv( pNtk, pDriver );
    912. 

  912.             Abc_ObjXorFaninC( pNodeCo, 0 );
    913. 

  913.         }
    914. 

  914.         else
    915. 

  915.             pDriverNew = Abc_NtkCreateNodeBuf( pNtk, pDriver );        
    916. 

  916.     }
    917. 

  917.     // update the fanin of the PO node
    918. 

  918.     Abc_ObjPatchFanin( pNodeCo, pDriver, pDriverNew );
    919. 

  919.     assert( Abc_ObjFanoutNum(pDriverNew) == 1 );
    920. 

  920.     // remove the old driver if it dangles
    921. 

  921.     // (this happens when the duplicated driver had only one complemented fanout)
    922. 

  922.     if ( Abc_ObjFanoutNum(pDriver) == 0 )
    923. 

  923.         Abc_NtkDeleteObj( pDriver );
    924. 

  924. }
    925. 

  925. 

  926. /**Function*************************************************************
    927. 

    928. 

  928.   Synopsis    [Returns 1 if COs of a logic network are simple.]
    929. 

    930. 

  930.   Description [The COs of a logic network are simple under three conditions:
    931. 

  931.   (1) The edge from CO to its driver is not complemented.
    932. 

  932.   (2) If CI is a driver of a CO, they have the same name.]
    933. 

  933.   (3) If two COs share the same driver, they have the same name.]
    934. 

  934.                
    935. 

  935.   SideEffects []
    936. 

    937. 

  937.   SeeAlso     []
    938. 

    939. 

  939. ***********************************************************************/
    940. 

  940. int Abc_NtkLogicHasSimpleCos( Abc_Ntk_t * pNtk )
    941. 

  941. {
    942. 

  942.     Abc_Obj_t * pNode, * pDriver;
    943. 

  943.     int i;
    944. 

  944.     assert( Abc_NtkIsLogic(pNtk) );
    945. 

  945.     Abc_NtkIncrementTravId( pNtk );
    946. 

  946.     Abc_NtkForEachCo( pNtk, pNode, i ) 
    947. 

  947.     {
    948. 

  948.         // if the driver is complemented, this is an error
    949. 

  949.         pDriver = Abc_ObjFanin0(pNode);
    950. 

  950.         if ( Abc_ObjFaninC0(pNode) )
    951. 

  951.             return 0;
    952. 

  952.         // if the driver is a CI and has different name, this is an error
    953. 

  953.         if ( Abc_ObjIsCi(pDriver) && strcmp(Abc_ObjName(pDriver), Abc_ObjName(pNode)) )
    954. 

  954.             return 0;
    955. 

  955.         // if the driver is visited for the first time, remember the CO name
    956. 

  956.         if ( !Abc_NodeIsTravIdCurrent(pDriver) )
    957. 

  957.         {
    958. 

  958.             pDriver->pNext = (Abc_Obj_t *)Abc_ObjName(pNode);
    959. 

  959.             Abc_NodeSetTravIdCurrent(pDriver);
    960. 

  960.             continue;
    961. 

  961.         }
    962. 

  962.         // the driver has second CO - if they have different name, this is an error
    963. 

  963.         if ( strcmp((char *)pDriver->pNext, Abc_ObjName(pNode)) ) // diff names
    964. 

  964.             return 0;
    965. 

  965.     }
    966. 

  966.     return 1;
    967. 

  967. }
    968. 

  968. 

  969. /**Function*************************************************************
    970. 

    971. 

  971.   Synopsis    [Transforms the network to have simple COs.]
    972. 

    973. 

  973.   Description [The COs of a logic network are simple under three conditions:
    974. 

  974.   (1) The edge from CO to its driver is not complemented.
    975. 

  975.   (2) If CI is a driver of a CO, they have the same name.]
    976. 

  976.   (3) If two COs share the same driver, they have the same name.
    977. 

  977.   In some cases, such as FPGA mapping, we prevent the increase in delay
    978. 

  978.   by duplicating the driver nodes, rather than adding invs/bufs.]
    979. 

  979.                
    980. 

  980.   SideEffects []
    981. 

    982. 

  982.   SeeAlso     []
    983. 

    984. 

  984. ***********************************************************************/
    985. 

  985. int Abc_NtkLogicMakeSimpleCos2( Abc_Ntk_t * pNtk, int fDuplicate )
    986. 

  986. {
    987. 

  987.     Abc_Obj_t * pNode, * pDriver;
    988. 

  988.     int i, nDupGates = 0;
    989. 

  989.     assert( Abc_NtkIsLogic(pNtk) );
    990. 

  990.     Abc_NtkIncrementTravId( pNtk );
    991. 

  991.     Abc_NtkForEachCo( pNtk, pNode, i ) 
    992. 

  992.     {
    993. 

  993.         // if the driver is complemented, this is an error
    994. 

  994.         pDriver = Abc_ObjFanin0(pNode);
    995. 

  995.         if ( Abc_ObjFaninC0(pNode) )
    996. 

  996.         {
    997. 

  997.             Abc_NtkFixCoDriverProblem( pDriver, pNode, fDuplicate );
    998. 

  998.             nDupGates++;
    999. 

  999.             continue;
    1000. 

  1000.         }
    1001. 

  1001.         // if the driver is a CI and has different name, this is an error
    1002. 

  1002.         if ( Abc_ObjIsCi(pDriver) && strcmp(Abc_ObjName(pDriver), Abc_ObjName(pNode)) )
    1003. 

  1003.         {
    1004. 

  1004.             Abc_NtkFixCoDriverProblem( pDriver, pNode, fDuplicate );
    1005. 

  1005.             nDupGates++;
    1006. 

  1006.             continue;
    1007. 

  1007.         }
    1008. 

  1008.         // if the driver is visited for the first time, remember the CO name
    1009. 

  1009.         if ( !Abc_NodeIsTravIdCurrent(pDriver) )
    1010. 

  1010.         {
    1011. 

  1011.             pDriver->pNext = (Abc_Obj_t *)Abc_ObjName(pNode);
    1012. 

  1012.             Abc_NodeSetTravIdCurrent(pDriver);
    1013. 

  1013.             continue;
    1014. 

  1014.         }
    1015. 

  1015.         // the driver has second CO - if they have different name, this is an error
    1016. 

  1016.         if ( strcmp((char *)pDriver->pNext, Abc_ObjName(pNode)) ) // diff names
    1017. 

  1017.         {
    1018. 

  1018.             Abc_NtkFixCoDriverProblem( pDriver, pNode, fDuplicate );
    1019. 

  1019.             nDupGates++;
    1020. 

  1020.             continue;
    1021. 

  1021.         }
    1022. 

  1022.     }
    1023. 

  1023.     assert( Abc_NtkLogicHasSimpleCos(pNtk) );
    1024. 

  1024.     return nDupGates;
    1025. 

  1025. }
    1026. 

  1026. 

  1027. 

    1028. 

  1028. /**Function*************************************************************

    1029. 

  1029. 

    1030. 

  1030.   Synopsis    [Transforms the network to have simple COs.]

    1031. 

  1031. 

    1032. 

  1032.   Description []

    1033. 

  1033.                

    1034. 

  1034.   SideEffects []

    1035. 

  1035. 

    1036. 

  1036.   SeeAlso     []

    1037. 

  1037. 

    1038. 

  1038. ***********************************************************************/

    1039. 

  1039. void Abc_NtkLogicMakeSimpleCosTest( Abc_Ntk_t * pNtk, int fDuplicate )

    1040. 

  1040. {

    1041. 

  1041.     int nObjs = Abc_NtkObjNumMax(pNtk);

    1042. 

  1042.     unsigned * pType = ABC_CALLOC( unsigned, nObjs );

    1043. 

  1043.     Abc_Obj_t * pNode;

    1044. 

  1044.     int i, Counts[4] = {0}, Consts[2] = {0}, Inputs[2] = {0};

    1045. 

  1045.     // collect info

    1046. 

  1046.     Abc_NtkForEachCo( pNtk, pNode, i ) 

    1047. 

  1047.     {

    1048. 

  1048.         if ( Abc_ObjFaninId0(pNode) == 0 )

    1049. 

  1049.             Consts[Abc_ObjFaninC0(pNode)]++;

    1050. 

  1050.         if ( Abc_ObjIsCi(Abc_ObjFanin0(pNode)) )

    1051. 

  1051.             Inputs[Abc_ObjFaninC0(pNode)]++;

    1052. 

  1052.         pType[Abc_ObjFaninId0(pNode)] |= (1 << Abc_ObjFaninC0(pNode));

    1053. 

  1053.     }

    1054. 

  1054.     // count the numbers

    1055. 

  1055.     for ( i = 0; i < nObjs; i++ )

    1056. 

  1056.         Counts[pType[i]]++;

    1057. 

  1057.     for ( i = 0; i < 4; i++ )

    1058. 

  1058.         printf( "%d = %d     ", i, Counts[i] );

    1059. 

  1059.     for ( i = 0; i < 2; i++ )

    1060. 

  1060.         printf( "c%d = %d     ", i, Consts[i] );

    1061. 

  1061.     for ( i = 0; i < 2; i++ )

    1062. 

  1062.         printf( "i%d = %d    ", i, Inputs[i] );

    1063. 

  1063.     printf( "\n" );

    1064. 

  1064.     ABC_FREE( pType );

    1065. 

  1065. }

    1066. 

  1066. 

  1067. /**Function*************************************************************
    1068. 

    1069. 

  1069.   Synopsis    [Transforms the network to have simple COs.]
    1070. 

    1071. 

  1071.   Description []
    1072. 

  1072.                
    1073. 

  1073.   SideEffects []
    1074. 

    1075. 

  1075.   SeeAlso     []
    1076. 

    1077. 

  1077. ***********************************************************************/
    1078. 

  1078. int Abc_NtkLogicMakeSimpleCos( Abc_Ntk_t * pNtk, int fDuplicate )
    1079. 

  1079. {
    1080. 

  1080.     Vec_Ptr_t * vDrivers, * vCoTerms;
    1081. 

  1081.     Abc_Obj_t * pNode, * pDriver, * pDriverNew, * pFanin;
    1082. 

  1082.     int i, k, LevelMax, nTotal = 0;
    1083. 

  1083.     assert( Abc_NtkIsLogic(pNtk) );
    1084. 

  1084.     LevelMax = Abc_NtkLevel(pNtk);

    1085. 

  1085. //    Abc_NtkLogicMakeSimpleCosTest( pNtk, fDuplicate );

    1086. 

  1086. 

    1087. 

  1087.     // fix constant drivers

    1088. 

  1088.     Abc_NtkForEachCo( pNtk, pNode, i ) 

    1089. 

  1089.     {

    1090. 

  1090.         pDriver = Abc_ObjFanin0(pNode);

    1091. 

  1091.         if ( !Abc_NodeIsConst(pDriver) )

    1092. 

  1092.             continue;

    1093. 

  1093.         pDriverNew = (Abc_ObjFaninC0(pNode) == Abc_NodeIsConst0(pDriver)) ? Abc_NtkCreateNodeConst1(pNtk) : Abc_NtkCreateNodeConst0(pNtk);

    1094. 

  1094.         if ( Abc_ObjFaninC0(pNode) )

    1095. 

  1095.             Abc_ObjXorFaninC( pNode, 0 );

    1096. 

  1096.         Abc_ObjPatchFanin( pNode, pDriver, pDriverNew );

    1097. 

  1097.         if ( Abc_ObjFanoutNum(pDriver) == 0 )

    1098. 

  1098.             Abc_NtkDeleteObj( pDriver );

    1099. 

  1099.     }

    1100. 

  1100. 

  1101.     // collect drivers pointed by complemented edges
    1102. 

  1102.     vDrivers = Vec_PtrAlloc( 100 );
    1103. 

  1103.     Abc_NtkIncrementTravId( pNtk );
    1104. 

  1104.     Abc_NtkForEachCo( pNtk, pNode, i ) 
    1105. 

  1105.     {
    1106. 

  1106.         if ( !Abc_ObjFaninC0(pNode) )
    1107. 

  1107.             continue;
    1108. 

  1108.         pDriver = Abc_ObjFanin0(pNode);
    1109. 

  1109.         if ( Abc_NodeIsTravIdCurrent(pDriver) )
    1110. 

  1110.             continue;
    1111. 

  1111.         Abc_NodeSetTravIdCurrent(pDriver);
    1112. 

  1112.         Vec_PtrPush( vDrivers, pDriver );
    1113. 

  1113.     }
    1114. 

  1114.     // fix complemented drivers
    1115. 

  1115.     if ( Vec_PtrSize(vDrivers) > 0 )
    1116. 

  1116.     {
    1117. 

  1117.         int nDupGates = 0, nDupInvs = 0, nDupChange = 0;
    1118. 

  1118.         Vec_Ptr_t * vFanouts = Vec_PtrAlloc( 100 );
    1119. 

  1119.         Vec_PtrForEachEntry( Abc_Obj_t *, vDrivers, pDriver, i )
    1120. 

  1120.         {
    1121. 

  1121.             int fHasDir = 0, fHasInv = 0, fHasOther = 0;
    1122. 

  1122.             Abc_ObjForEachFanout( pDriver, pNode, k )
    1123. 

  1123.             {
    1124. 

  1124.                 if ( !Abc_ObjIsCo(pNode) )
    1125. 

  1125.                 {
    1126. 

  1126.                     assert( !Abc_ObjFaninC0(pNode) );
    1127. 

  1127.                     fHasOther = 1;
    1128. 

  1128.                     continue;
    1129. 

  1129.                 }
    1130. 

  1130.                 if ( Abc_ObjFaninC0(pNode) )
    1131. 

  1131.                     fHasInv = 1;
    1132. 

  1132.                 else //if ( Abc_ObjFaninC0(pNode) )
    1133. 

  1133.                     fHasDir = 1;
    1134. 

  1134.             }
    1135. 

  1135.             assert( fHasInv );
    1136. 

  1136.             if ( Abc_ObjIsCi(pDriver) || fHasDir || (fHasOther && Abc_NtkHasMapping(pNtk)) ) // cannot change
    1137. 

  1137.             {
    1138. 

  1138.                 // duplicate if critical
    1139. 

  1139.                 if ( fDuplicate && Abc_ObjIsNode(pDriver) && Abc_ObjLevel(pDriver) == LevelMax )
    1140. 

  1140.                 {
    1141. 

  1141.                     pDriverNew = Abc_NtkDupObj( pNtk, pDriver, 0 ); 
    1142. 

  1142.                     Abc_ObjForEachFanin( pDriver, pFanin, k )
    1143. 

  1143.                         Abc_ObjAddFanin( pDriverNew, pFanin );
    1144. 

  1144.                     Abc_NodeComplement( pDriverNew );
    1145. 

  1145.                     nDupGates++;
    1146. 

  1146.                 }
    1147. 

  1147.                 else // add inverter
    1148. 

  1148.                 {
    1149. 

  1149.                     pDriverNew = Abc_NtkCreateNodeInv( pNtk, pDriver );
    1150. 

  1150.                     nDupInvs++;
    1151. 

  1151.                 }
    1152. 

  1152.                 // collect CO fanouts to be redirected to the new node
    1153. 

  1153.                 Vec_PtrClear( vFanouts );
    1154. 

  1154.                 Abc_ObjForEachFanout( pDriver, pNode, k )
    1155. 

  1155.                     if ( Abc_ObjIsCo(pNode) && Abc_ObjFaninC0(pNode) )
    1156. 

  1156.                         Vec_PtrPush( vFanouts, pNode );
    1157. 

  1157.                 assert( Vec_PtrSize(vFanouts) > 0 );
    1158. 

  1158.                 Vec_PtrForEachEntry( Abc_Obj_t *, vFanouts, pNode, k )
    1159. 

  1159.                 {
    1160. 

  1160.                     Abc_ObjXorFaninC( pNode, 0 );
    1161. 

  1161.                     Abc_ObjPatchFanin( pNode, pDriver, pDriverNew );
    1162. 

  1162.                     assert( Abc_ObjIsCi(pDriver) || Abc_ObjFanoutNum(pDriver) > 0 );
    1163. 

  1163.                 }
    1164. 

  1164.             }
    1165. 

  1165.             else // can change
    1166. 

  1166.             {
    1167. 

  1167.                 // change polarity of the driver
    1168. 

  1168.                 assert( Abc_ObjIsNode(pDriver) );
    1169. 

  1169.                 Abc_NodeComplement( pDriver );
    1170. 

  1170.                 Abc_ObjForEachFanout( pDriver, pNode, k )
    1171. 

  1171.                 {
    1172. 

  1172.                     if ( Abc_ObjIsCo(pNode) )
    1173. 

  1173.                     {
    1174. 

  1174.                         assert( Abc_ObjFaninC0(pNode) );
    1175. 

  1175.                         Abc_ObjXorFaninC( pNode, 0 );
    1176. 

  1176.                     }
    1177. 

  1177.                     else if ( Abc_ObjIsNode(pNode) )
    1178. 

  1178.                         Abc_NodeComplementInput( pNode, pDriver );
    1179. 

  1179.                     else assert( 0 );
    1180. 

  1180.                 }
    1181. 

  1181.                 nDupChange++;
    1182. 

  1182.             }
    1183. 

  1183.         }
    1184. 

  1184.         Vec_PtrFree( vFanouts );
    1185. 

  1185. //        printf( "Resolving inverted CO drivers: Invs = %d. Dups = %d. Changes = %d.\n",
    1186. 

  1186. //            nDupInvs, nDupGates, nDupChange );
    1187. 

  1187.         nTotal += nDupInvs + nDupGates;
    1188. 

  1188.     }
    1189. 

  1189.     Vec_PtrFree( vDrivers );
    1190. 

  1190. 

  1191.     // collect COs that needs fixing by adding buffers or duplicating
    1192. 

  1192.     vCoTerms = Vec_PtrAlloc( 100 );
    1193. 

  1193.     Abc_NtkIncrementTravId( pNtk );
    1194. 

  1194.     Abc_NtkForEachCo( pNtk, pNode, i )
    1195. 

  1195.     {
    1196. 

  1196.         // if the driver is a CI and has different name, this is an error
    1197. 

  1197.         pDriver = Abc_ObjFanin0(pNode);
    1198. 

  1198.         if ( Abc_ObjIsCi(pDriver) && strcmp(Abc_ObjName(pDriver), Abc_ObjName(pNode)) )
    1199. 

  1199.         {
    1200. 

  1200.             Vec_PtrPush( vCoTerms, pNode );
    1201. 

  1201.             continue;
    1202. 

  1202.         }
    1203. 

  1203.         // if the driver is visited for the first time, remember the CO name
    1204. 

  1204.         if ( !Abc_NodeIsTravIdCurrent(pDriver) )
    1205. 

  1205.         {
    1206. 

  1206.             pDriver->pNext = (Abc_Obj_t *)Abc_ObjName(pNode);
    1207. 

  1207.             Abc_NodeSetTravIdCurrent(pDriver);
    1208. 

  1208.             continue;
    1209. 

  1209.         }
    1210. 

  1210.         // the driver has second CO - if they have different name, this is an error
    1211. 

  1211.         if ( strcmp((char *)pDriver->pNext, Abc_ObjName(pNode)) ) // diff names
    1212. 

  1212.         {
    1213. 

  1213.             Vec_PtrPush( vCoTerms, pNode );
    1214. 

  1214.             continue;
    1215. 

  1215.         }
    1216. 

  1216.     }
    1217. 

  1217.     // fix duplication problem
    1218. 

  1218.     if ( Vec_PtrSize(vCoTerms) > 0 )
    1219. 

  1219.     {
    1220. 

  1220.         int nDupBufs = 0, nDupGates = 0;
    1221. 

  1221.         Vec_PtrForEachEntry( Abc_Obj_t *, vCoTerms, pNode, i )
    1222. 

  1222.         {
    1223. 

  1223.             pDriver = Abc_ObjFanin0(pNode);
    1224. 

  1224.             // duplicate if critical
    1225. 

  1225.             if ( fDuplicate && Abc_ObjIsNode(pDriver) && (Abc_NtkHasMapping(pNtk) || Abc_ObjLevel(pDriver) == LevelMax) )
    1226. 

  1226.             {
    1227. 

  1227.                 pDriverNew = Abc_NtkDupObj( pNtk, pDriver, 0 ); 
    1228. 

  1228.                 Abc_ObjForEachFanin( pDriver, pFanin, k )
    1229. 

  1229.                     Abc_ObjAddFanin( pDriverNew, pFanin );
    1230. 

  1230.                 nDupGates++;
    1231. 

  1231.             }
    1232. 

  1232.             else // add buffer
    1233. 

  1233.             {
    1234. 

  1234.                 pDriverNew = Abc_NtkCreateNodeBuf( pNtk, pDriver );
    1235. 

  1235.                 Abc_ObjAssignName( pDriverNew, Abc_ObjName(pDriver), "_buf" );

    1236. 

  1236.                 nDupBufs++;
    1237. 

  1237.             }
    1238. 

  1238.             // swing the PO
    1239. 

  1239.             Abc_ObjPatchFanin( pNode, pDriver, pDriverNew );
    1240. 

  1240.             assert( Abc_ObjIsCi(pDriver) || Abc_ObjFanoutNum(pDriver) > 0 );
    1241. 

  1241.         }
    1242. 

  1242. //        printf( "Resolving shared CO drivers: Bufs = %d. Dups = %d.\n", nDupBufs, nDupGates );
    1243. 

  1243.         nTotal += nDupBufs + nDupGates;
    1244. 

  1244.     }
    1245. 

  1245.     Vec_PtrFree( vCoTerms );
    1246. 

  1246.     return nTotal;
    1247. 

  1247. }
    1248. 

  1248. 

  1249. /**Function*************************************************************
    1250. 

    1251. 

  1251.   Synopsis    [Inserts a new node in the order by levels.]
    1252. 

    1253. 

  1253.   Description []
    1254. 

  1254.                
    1255. 

  1255.   SideEffects []
    1256. 

    1257. 

  1257.   SeeAlso     []
    1258. 

    1259. 

  1259. ***********************************************************************/
    1260. 

  1260. void Abc_VecObjPushUniqueOrderByLevel( Vec_Ptr_t * p, Abc_Obj_t * pNode )
    1261. 

  1261. {
    1262. 

  1262.     Abc_Obj_t * pNode1, * pNode2;
    1263. 

  1263.     int i;
    1264. 

  1264.     if ( Vec_PtrPushUnique(p, pNode) )
    1265. 

  1265.         return;
    1266. 

  1266.     // find the p of the node
    1267. 

  1267.     for ( i = p->nSize-1; i > 0; i-- )
    1268. 

  1268.     {
    1269. 

  1269.         pNode1 = (Abc_Obj_t *)p->pArray[i  ];
    1270. 

  1270.         pNode2 = (Abc_Obj_t *)p->pArray[i-1];
    1271. 

  1271.         if ( Abc_ObjRegular(pNode1)->Level <= Abc_ObjRegular(pNode2)->Level )
    1272. 

  1272.             break;
    1273. 

  1273.         p->pArray[i  ] = pNode2;
    1274. 

  1274.         p->pArray[i-1] = pNode1;
    1275. 

  1275.     }
    1276. 

  1276. }
    1277. 

  1277. 

  1278. 

  1279. 

  1280. /**Function*************************************************************
    1281. 

    1282. 

  1282.   Synopsis    [Returns 1 if the node is the root of EXOR/NEXOR.]
    1283. 

    1284. 

  1284.   Description []
    1285. 

  1285.                
    1286. 

  1286.   SideEffects []
    1287. 

    1288. 

  1288.   SeeAlso     []
    1289. 

    1290. 

  1290. ***********************************************************************/
    1291. 

  1291. int Abc_NodeIsExorType( Abc_Obj_t * pNode )
    1292. 

  1292. {
    1293. 

  1293.     Abc_Obj_t * pNode0, * pNode1;
    1294. 

  1294.     // check that the node is regular
    1295. 

  1295.     assert( !Abc_ObjIsComplement(pNode) );
    1296. 

  1296.     // if the node is not AND, this is not EXOR
    1297. 

  1297.     if ( !Abc_AigNodeIsAnd(pNode) )
    1298. 

  1298.         return 0;
    1299. 

  1299.     // if the children are not complemented, this is not EXOR
    1300. 

  1300.     if ( !Abc_ObjFaninC0(pNode) || !Abc_ObjFaninC1(pNode) )
    1301. 

  1301.         return 0;
    1302. 

  1302.     // get children
    1303. 

  1303.     pNode0 = Abc_ObjFanin0(pNode);
    1304. 

  1304.     pNode1 = Abc_ObjFanin1(pNode);
    1305. 

  1305.     // if the children are not ANDs, this is not EXOR
    1306. 

  1306.     if ( Abc_ObjFaninNum(pNode0) != 2 || Abc_ObjFaninNum(pNode1) != 2 )
    1307. 

  1307.         return 0;
    1308. 

  1308.     // this is AIG, which means the fanins should be ordered
    1309. 

  1309.     assert( Abc_ObjFaninId0(pNode0) != Abc_ObjFaninId1(pNode1) || 
    1310. 

  1310.             Abc_ObjFaninId0(pNode1) != Abc_ObjFaninId1(pNode0) );
    1311. 

  1311.     // if grand children are not the same, this is not EXOR
    1312. 

  1312.     if ( Abc_ObjFaninId0(pNode0) != Abc_ObjFaninId0(pNode1) ||
    1313. 

  1313.          Abc_ObjFaninId1(pNode0) != Abc_ObjFaninId1(pNode1) )
    1314. 

  1314.          return 0;
    1315. 

  1315.     // finally, if the complemented edges are matched, this is not EXOR
    1316. 

  1316.     if ( Abc_ObjFaninC0(pNode0) == Abc_ObjFaninC0(pNode1) || 
    1317. 

  1317.          Abc_ObjFaninC1(pNode0) == Abc_ObjFaninC1(pNode1) )
    1318. 

  1318.          return 0;
    1319. 

  1319.     return 1;
    1320. 

  1320. }
    1321. 

  1321. 

  1322. /**Function*************************************************************
    1323. 

    1324. 

  1324.   Synopsis    [Returns 1 if the node is the root of MUX or EXOR/NEXOR.]
    1325. 

    1326. 

  1326.   Description []
    1327. 

  1327.                
    1328. 

  1328.   SideEffects []
    1329. 

    1330. 

  1330.   SeeAlso     []
    1331. 

    1332. 

  1332. ***********************************************************************/
    1333. 

  1333. int Abc_NodeIsMuxType( Abc_Obj_t * pNode )
    1334. 

  1334. {
    1335. 

  1335.     Abc_Obj_t * pNode0, * pNode1;
    1336. 

  1336.     // check that the node is regular
    1337. 

  1337.     assert( !Abc_ObjIsComplement(pNode) );
    1338. 

  1338.     // if the node is not AND, this is not MUX
    1339. 

  1339.     if ( !Abc_AigNodeIsAnd(pNode) )
    1340. 

  1340.         return 0;
    1341. 

  1341.     // if the children are not complemented, this is not MUX
    1342. 

  1342.     if ( !Abc_ObjFaninC0(pNode) || !Abc_ObjFaninC1(pNode) )
    1343. 

  1343.         return 0;
    1344. 

  1344.     // get children
    1345. 

  1345.     pNode0 = Abc_ObjFanin0(pNode);
    1346. 

  1346.     pNode1 = Abc_ObjFanin1(pNode);
    1347. 

  1347.     // if the children are not ANDs, this is not MUX
    1348. 

  1348.     if ( !Abc_AigNodeIsAnd(pNode0) || !Abc_AigNodeIsAnd(pNode1) )
    1349. 

  1349.         return 0;
    1350. 

  1350.     // otherwise the node is MUX iff it has a pair of equal grandchildren with opposite polarity
    1351. 

  1351.     return (Abc_ObjFaninId0(pNode0) == Abc_ObjFaninId0(pNode1) && (Abc_ObjFaninC0(pNode0) ^ Abc_ObjFaninC0(pNode1))) || 
    1352. 

  1352.            (Abc_ObjFaninId0(pNode0) == Abc_ObjFaninId1(pNode1) && (Abc_ObjFaninC0(pNode0) ^ Abc_ObjFaninC1(pNode1))) ||
    1353. 

  1353.            (Abc_ObjFaninId1(pNode0) == Abc_ObjFaninId0(pNode1) && (Abc_ObjFaninC1(pNode0) ^ Abc_ObjFaninC0(pNode1))) ||
    1354. 

  1354.            (Abc_ObjFaninId1(pNode0) == Abc_ObjFaninId1(pNode1) && (Abc_ObjFaninC1(pNode0) ^ Abc_ObjFaninC1(pNode1)));
    1355. 

  1355. }
    1356. 

  1356. 

  1357. /**Function*************************************************************
    1358. 

    1359. 

  1359.   Synopsis    [Returns 1 if the node is the root of MUX or EXOR/NEXOR.]
    1360. 

    1361. 

  1361.   Description []
    1362. 

  1362.                
    1363. 

  1363.   SideEffects []
    1364. 

    1365. 

  1365.   SeeAlso     []
    1366. 

    1367. 

  1367. ***********************************************************************/
    1368. 

  1368. int Abc_NtkCountMuxes( Abc_Ntk_t * pNtk )
    1369. 

  1369. {
    1370. 

  1370.     Abc_Obj_t * pNode;
    1371. 

  1371.     int i;
    1372. 

  1372.     int Counter = 0;
    1373. 

  1373.     Abc_NtkForEachNode( pNtk, pNode, i )
    1374. 

  1374.         Counter += Abc_NodeIsMuxType( pNode );
    1375. 

  1375.     return Counter;
    1376. 

  1376. }
    1377. 

  1377. 

  1378. /**Function*************************************************************
    1379. 

    1380. 

  1380.   Synopsis    [Returns 1 if the node is the control type of the MUX.]
    1381. 

    1382. 

  1382.   Description []
    1383. 

  1383.                
    1384. 

  1384.   SideEffects []
    1385. 

    1386. 

  1386.   SeeAlso     []
    1387. 

    1388. 

  1388. ***********************************************************************/
    1389. 

  1389. int Abc_NodeIsMuxControlType( Abc_Obj_t * pNode )
    1390. 

  1390. {
    1391. 

  1391.     Abc_Obj_t * pNode0, * pNode1;
    1392. 

  1392.     // check that the node is regular
    1393. 

  1393.     assert( !Abc_ObjIsComplement(pNode) );
    1394. 

  1394.     // skip the node that do not have two fanouts
    1395. 

  1395.     if ( Abc_ObjFanoutNum(pNode) != 2 )
    1396. 

  1396.         return 0;
    1397. 

  1397.     // get the fanouts
    1398. 

  1398.     pNode0 = Abc_ObjFanout( pNode, 0 );
    1399. 

  1399.     pNode1 = Abc_ObjFanout( pNode, 1 );
    1400. 

  1400.     // if they have more than one fanout, we are not interested
    1401. 

  1401.     if ( Abc_ObjFanoutNum(pNode0) != 1 ||  Abc_ObjFanoutNum(pNode1) != 1 )
    1402. 

  1402.         return 0;
    1403. 

  1403.     // if the fanouts have the same fanout, this is MUX or EXOR (or a redundant gate (CA)(CB))
    1404. 

  1404.     return Abc_ObjFanout0(pNode0) == Abc_ObjFanout0(pNode1);
    1405. 

  1405. }
    1406. 

  1406. 

  1407. /**Function*************************************************************
    1408. 

    1409. 

  1409.   Synopsis    [Recognizes what nodes are control and data inputs of a MUX.]
    1410. 

    1411. 

  1411.   Description [If the node is a MUX, returns the control variable C.
    1412. 

  1412.   Assigns nodes T and E to be the then and else variables of the MUX. 
    1413. 

  1413.   Node C is never complemented. Nodes T and E can be complemented.
    1414. 

  1414.   This function also recognizes EXOR/NEXOR gates as MUXes.]
    1415. 

  1415.                
    1416. 

  1416.   SideEffects []
    1417. 

    1418. 

  1418.   SeeAlso     []
    1419. 

    1420. 

  1420. ***********************************************************************/
    1421. 

  1421. Abc_Obj_t * Abc_NodeRecognizeMux( Abc_Obj_t * pNode, Abc_Obj_t ** ppNodeT, Abc_Obj_t ** ppNodeE )
    1422. 

  1422. {
    1423. 

  1423.     Abc_Obj_t * pNode0, * pNode1;
    1424. 

  1424.     assert( !Abc_ObjIsComplement(pNode) );
    1425. 

  1425.     assert( Abc_NodeIsMuxType(pNode) );
    1426. 

  1426.     // get children
    1427. 

  1427.     pNode0 = Abc_ObjFanin0(pNode);
    1428. 

  1428.     pNode1 = Abc_ObjFanin1(pNode);
    1429. 

  1429.     // find the control variable
    1430. 

  1430. //    if ( pNode1->p1 == Fraig_Not(pNode2->p1) )
    1431. 

  1431.     if ( Abc_ObjFaninId0(pNode0) == Abc_ObjFaninId0(pNode1) && (Abc_ObjFaninC0(pNode0) ^ Abc_ObjFaninC0(pNode1)) )
    1432. 

  1432.     {
    1433. 

  1433. //        if ( Fraig_IsComplement(pNode1->p1) )
    1434. 

  1434.         if ( Abc_ObjFaninC0(pNode0) )
    1435. 

  1435.         { // pNode2->p1 is positive phase of C
    1436. 

  1436.             *ppNodeT = Abc_ObjNot(Abc_ObjChild1(pNode1));//pNode2->p2);
    1437. 

  1437.             *ppNodeE = Abc_ObjNot(Abc_ObjChild1(pNode0));//pNode1->p2);
    1438. 

  1438.             return Abc_ObjChild0(pNode1);//pNode2->p1;
    1439. 

  1439.         }
    1440. 

  1440.         else
    1441. 

  1441.         { // pNode1->p1 is positive phase of C
    1442. 

  1442.             *ppNodeT = Abc_ObjNot(Abc_ObjChild1(pNode0));//pNode1->p2);
    1443. 

  1443.             *ppNodeE = Abc_ObjNot(Abc_ObjChild1(pNode1));//pNode2->p2);
    1444. 

  1444.             return Abc_ObjChild0(pNode0);//pNode1->p1;
    1445. 

  1445.         }
    1446. 

  1446.     }
    1447. 

  1447. //    else if ( pNode1->p1 == Fraig_Not(pNode2->p2) )
    1448. 

  1448.     else if ( Abc_ObjFaninId0(pNode0) == Abc_ObjFaninId1(pNode1) && (Abc_ObjFaninC0(pNode0) ^ Abc_ObjFaninC1(pNode1)) )
    1449. 

  1449.     {
    1450. 

  1450. //        if ( Fraig_IsComplement(pNode1->p1) )
    1451. 

  1451.         if ( Abc_ObjFaninC0(pNode0) )
    1452. 

  1452.         { // pNode2->p2 is positive phase of C
    1453. 

  1453.             *ppNodeT = Abc_ObjNot(Abc_ObjChild0(pNode1));//pNode2->p1);
    1454. 

  1454.             *ppNodeE = Abc_ObjNot(Abc_ObjChild1(pNode0));//pNode1->p2);
    1455. 

  1455.             return Abc_ObjChild1(pNode1);//pNode2->p2;
    1456. 

  1456.         }
    1457. 

  1457.         else
    1458. 

  1458.         { // pNode1->p1 is positive phase of C
    1459. 

  1459.             *ppNodeT = Abc_ObjNot(Abc_ObjChild1(pNode0));//pNode1->p2);
    1460. 

  1460.             *ppNodeE = Abc_ObjNot(Abc_ObjChild0(pNode1));//pNode2->p1);
    1461. 

  1461.             return Abc_ObjChild0(pNode0);//pNode1->p1;
    1462. 

  1462.         }
    1463. 

  1463.     }
    1464. 

  1464. //    else if ( pNode1->p2 == Fraig_Not(pNode2->p1) )
    1465. 

  1465.     else if ( Abc_ObjFaninId1(pNode0) == Abc_ObjFaninId0(pNode1) && (Abc_ObjFaninC1(pNode0) ^ Abc_ObjFaninC0(pNode1)) )
    1466. 

  1466.     {
    1467. 

  1467. //        if ( Fraig_IsComplement(pNode1->p2) )
    1468. 

  1468.         if ( Abc_ObjFaninC1(pNode0) )
    1469. 

  1469.         { // pNode2->p1 is positive phase of C
    1470. 

  1470.             *ppNodeT = Abc_ObjNot(Abc_ObjChild1(pNode1));//pNode2->p2);
    1471. 

  1471.             *ppNodeE = Abc_ObjNot(Abc_ObjChild0(pNode0));//pNode1->p1);
    1472. 

  1472.             return Abc_ObjChild0(pNode1);//pNode2->p1;
    1473. 

  1473.         }
    1474. 

  1474.         else
    1475. 

  1475.         { // pNode1->p2 is positive phase of C
    1476. 

  1476.             *ppNodeT = Abc_ObjNot(Abc_ObjChild0(pNode0));//pNode1->p1);
    1477. 

  1477.             *ppNodeE = Abc_ObjNot(Abc_ObjChild1(pNode1));//pNode2->p2);
    1478. 

  1478.             return Abc_ObjChild1(pNode0);//pNode1->p2;
    1479. 

  1479.         }
    1480. 

  1480.     }
    1481. 

  1481. //    else if ( pNode1->p2 == Fraig_Not(pNode2->p2) )
    1482. 

  1482.     else if ( Abc_ObjFaninId1(pNode0) == Abc_ObjFaninId1(pNode1) && (Abc_ObjFaninC1(pNode0) ^ Abc_ObjFaninC1(pNode1)) )
    1483. 

  1483.     {
    1484. 

  1484. //        if ( Fraig_IsComplement(pNode1->p2) )
    1485. 

  1485.         if ( Abc_ObjFaninC1(pNode0) )
    1486. 

  1486.         { // pNode2->p2 is positive phase of C
    1487. 

  1487.             *ppNodeT = Abc_ObjNot(Abc_ObjChild0(pNode1));//pNode2->p1);
    1488. 

  1488.             *ppNodeE = Abc_ObjNot(Abc_ObjChild0(pNode0));//pNode1->p1);
    1489. 

  1489.             return Abc_ObjChild1(pNode1);//pNode2->p2;
    1490. 

  1490.         }
    1491. 

  1491.         else
    1492. 

  1492.         { // pNode1->p2 is positive phase of C
    1493. 

  1493.             *ppNodeT = Abc_ObjNot(Abc_ObjChild0(pNode0));//pNode1->p1);
    1494. 

  1494.             *ppNodeE = Abc_ObjNot(Abc_ObjChild0(pNode1));//pNode2->p1);
    1495. 

  1495.             return Abc_ObjChild1(pNode0);//pNode1->p2;
    1496. 

  1496.         }
    1497. 

  1497.     }
    1498. 

  1498.     assert( 0 ); // this is not MUX
    1499. 

  1499.     return NULL;
    1500. 

  1500. }
    1501. 

  1501. 

  1502. /**Function*************************************************************
    1503. 

    1504. 

  1504.   Synopsis    [Prepares two network for a two-argument command similar to "verify".]
    1505. 

    1506. 

  1506.   Description []
    1507. 

  1507.                
    1508. 

  1508.   SideEffects []
    1509. 

    1510. 

  1510.   SeeAlso     []
    1511. 

    1512. 

  1512. ***********************************************************************/
    1513. 

  1513. int Abc_NtkPrepareTwoNtks( FILE * pErr, Abc_Ntk_t * pNtk, char ** argv, int argc, 
    1514. 

  1514.     Abc_Ntk_t ** ppNtk1, Abc_Ntk_t ** ppNtk2, int * pfDelete1, int * pfDelete2 )
    1515. 

  1515. {
    1516. 

  1516.     int fCheck = 1;
    1517. 

  1517.     FILE * pFile;
    1518. 

  1518.     Abc_Ntk_t * pNtk1, * pNtk2, * pNtkTemp;
    1519. 

  1519.     int util_optind = 0;
    1520. 

  1520. 

  1521.     *pfDelete1 = 0;
    1522. 

  1522.     *pfDelete2 = 0;
    1523. 

  1523.     if ( argc == util_optind ) 
    1524. 

  1524.     { // use the spec
    1525. 

  1525.         if ( pNtk == NULL )
    1526. 

  1526.         {
    1527. 

  1527.             fprintf( pErr, "Empty current network.\n" );
    1528. 

  1528.             return 0;
    1529. 

  1529.         }
    1530. 

  1530.         if ( pNtk->pSpec == NULL )
    1531. 

  1531.         {
    1532. 

  1532.             fprintf( pErr, "The external spec is not given.\n" );
    1533. 

  1533.             return 0;
    1534. 

  1534.         }
    1535. 

  1535.         pFile = fopen( pNtk->pSpec, "r" );
    1536. 

  1536.         if ( pFile == NULL )
    1537. 

  1537.         {
    1538. 

  1538.             fprintf( pErr, "Cannot open the external spec file \"%s\".\n", pNtk->pSpec );
    1539. 

  1539.             return 0;
    1540. 

  1540.         }
    1541. 

  1541.         else
    1542. 

  1542.             fclose( pFile );
    1543. 

  1543.         pNtk1 = Abc_NtkDup(pNtk);
    1544. 

  1544.         pNtk2 = Io_Read( pNtk->pSpec, Io_ReadFileType(pNtk->pSpec), fCheck, 0 );
    1545. 

  1545.         if ( pNtk2 == NULL )
    1546. 

  1546.             return 0;
    1547. 

  1547.         *pfDelete1 = 1;
    1548. 

  1548.         *pfDelete2 = 1;
    1549. 

  1549.     }
    1550. 

  1550.     else if ( argc == util_optind + 1 ) 
    1551. 

  1551.     {
    1552. 

  1552.         if ( pNtk == NULL )
    1553. 

  1553.         {
    1554. 

  1554.             fprintf( pErr, "Empty current network.\n" );
    1555. 

  1555.             return 0;
    1556. 

  1556.         }
    1557. 

  1557.         pNtk1 = Abc_NtkDup(pNtk);
    1558. 

  1558.         pNtk2 = Io_Read( argv[util_optind], Io_ReadFileType(argv[util_optind]), fCheck, 0 );
    1559. 

  1559.         if ( pNtk2 == NULL )
    1560. 

  1560.             return 0;
    1561. 

  1561.         *pfDelete1 = 1;
    1562. 

  1562.         *pfDelete2 = 1;
    1563. 

  1563.     }
    1564. 

  1564.     else if ( argc == util_optind + 2 ) 
    1565. 

  1565.     {
    1566. 

  1566.         pNtk1 = Io_Read( argv[util_optind], Io_ReadFileType(argv[util_optind]), fCheck, 0 );
    1567. 

  1567.         if ( pNtk1 == NULL )
    1568. 

  1568.             return 0;
    1569. 

  1569.         pNtk2 = Io_Read( argv[util_optind+1], Io_ReadFileType(argv[util_optind+1]), fCheck, 0 );
    1570. 

  1570.         if ( pNtk2 == NULL )
    1571. 

  1571.         {
    1572. 

  1572.             Abc_NtkDelete( pNtk1 );
    1573. 

  1573.             return 0;
    1574. 

  1574.         }
    1575. 

  1575.         *pfDelete1 = 1;
    1576. 

  1576.         *pfDelete2 = 1;
    1577. 

  1577.     }
    1578. 

  1578.     else
    1579. 

  1579.     {
    1580. 

  1580.         fprintf( pErr, "Wrong number of arguments.\n" );
    1581. 

  1581.         return 0;
    1582. 

  1582.     }
    1583. 

  1583. 

  1584.     // make sure the networks are strashed
    1585. 

  1585.     if ( !Abc_NtkIsStrash(pNtk1) )
    1586. 

  1586.     {
    1587. 

  1587.         pNtkTemp = Abc_NtkStrash( pNtk1, 0, 1, 0 );
    1588. 

  1588.         if ( *pfDelete1 )
    1589. 

  1589.             Abc_NtkDelete( pNtk1 );
    1590. 

  1590.         pNtk1 = pNtkTemp;
    1591. 

  1591.         *pfDelete1 = 1;
    1592. 

  1592.     }
    1593. 

  1593.     if ( !Abc_NtkIsStrash(pNtk2) )
    1594. 

  1594.     {
    1595. 

  1595.         pNtkTemp = Abc_NtkStrash( pNtk2, 0, 1, 0 );
    1596. 

  1596.         if ( *pfDelete2 )
    1597. 

  1597.             Abc_NtkDelete( pNtk2 );
    1598. 

  1598.         pNtk2 = pNtkTemp;
    1599. 

  1599.         *pfDelete2 = 1;
    1600. 

  1600.     }
    1601. 

  1601. 

  1602.     *ppNtk1 = pNtk1;
    1603. 

  1603.     *ppNtk2 = pNtk2;
    1604. 

  1604.     return 1;
    1605. 

  1605. }
    1606. 

  1606. 

  1607. 

  1608. /**Function*************************************************************
    1609. 

    1610. 

  1610.   Synopsis    [Returns 1 if it is an AIG with choice nodes.]
    1611. 

    1612. 

  1612.   Description []
    1613. 

  1613.                
    1614. 

  1614.   SideEffects []
    1615. 

    1616. 

  1616.   SeeAlso     []
    1617. 

    1618. 

  1618. ***********************************************************************/
    1619. 

  1619. void Abc_NodeCollectFanins( Abc_Obj_t * pNode, Vec_Ptr_t * vNodes )
    1620. 

  1620. {
    1621. 

  1621.     Abc_Obj_t * pFanin;
    1622. 

  1622.     int i;
    1623. 

  1623.     Vec_PtrClear(vNodes);
    1624. 

  1624.     Abc_ObjForEachFanin( pNode, pFanin, i )
    1625. 

  1625.         Vec_PtrPush( vNodes, pFanin );
    1626. 

  1626. }
    1627. 

  1627. 

  1628. /**Function*************************************************************
    1629. 

    1630. 

  1630.   Synopsis    [Returns 1 if it is an AIG with choice nodes.]
    1631. 

    1632. 

  1632.   Description []
    1633. 

  1633.                
    1634. 

  1634.   SideEffects []
    1635. 

    1636. 

  1636.   SeeAlso     []
    1637. 

    1638. 

  1638. ***********************************************************************/
    1639. 

  1639. void Abc_NodeCollectFanouts( Abc_Obj_t * pNode, Vec_Ptr_t * vNodes )
    1640. 

  1640. {
    1641. 

  1641.     Abc_Obj_t * pFanout;
    1642. 

  1642.     int i;
    1643. 

  1643.     Vec_PtrClear(vNodes);
    1644. 

  1644.     Abc_ObjForEachFanout( pNode, pFanout, i )
    1645. 

  1645.         Vec_PtrPush( vNodes, pFanout );
    1646. 

  1646. }
    1647. 

  1647. 

  1648. /**Function*************************************************************
    1649. 

    1650. 

  1650.   Synopsis    [Collects all latches in the network.]
    1651. 

    1652. 

  1652.   Description []
    1653. 

  1653.                
    1654. 

  1654.   SideEffects []
    1655. 

    1656. 

  1656.   SeeAlso     []
    1657. 

    1658. 

  1658. ***********************************************************************/
    1659. 

  1659. Vec_Ptr_t * Abc_NtkCollectLatches( Abc_Ntk_t * pNtk )
    1660. 

  1660. {
    1661. 

  1661.     Vec_Ptr_t * vLatches;
    1662. 

  1662.     Abc_Obj_t * pObj;
    1663. 

  1663.     int i;
    1664. 

  1664.     vLatches = Vec_PtrAlloc( 10 );
    1665. 

  1665.     Abc_NtkForEachObj( pNtk, pObj, i )
    1666. 

  1666.         Vec_PtrPush( vLatches, pObj );
    1667. 

  1667.     return vLatches;
    1668. 

  1668. }
    1669. 

  1669. 

  1670. /**Function*************************************************************
    1671. 

    1672. 

  1672.   Synopsis    [Procedure used for sorting the nodes in increasing order of levels.]
    1673. 

    1674. 

  1674.   Description []
    1675. 

  1675.                
    1676. 

  1676.   SideEffects []
    1677. 

    1678. 

  1678.   SeeAlso     []
    1679. 

    1680. 

  1680. ***********************************************************************/
    1681. 

  1681. int Abc_NodeCompareLevelsIncrease( Abc_Obj_t ** pp1, Abc_Obj_t ** pp2 )
    1682. 

  1682. {
    1683. 

  1683.     int Diff = Abc_ObjRegular(*pp1)->Level - Abc_ObjRegular(*pp2)->Level;
    1684. 

  1684.     if ( Diff < 0 )
    1685. 

  1685.         return -1;
    1686. 

  1686.     if ( Diff > 0 ) 
    1687. 

  1687.         return 1;
    1688. 

  1688.     Diff = Abc_ObjRegular(*pp1)->Id - Abc_ObjRegular(*pp2)->Id;
    1689. 

  1689.     if ( Diff < 0 )
    1690. 

  1690.         return -1;
    1691. 

  1691.     if ( Diff > 0 ) 
    1692. 

  1692.         return 1;
    1693. 

  1693.     return 0; 
    1694. 

  1694. }
    1695. 

  1695. 

  1696. /**Function*************************************************************
    1697. 

    1698. 

  1698.   Syno…
    1699.

Large files files are truncated, but you can click here to view the full file