ABC: A System for Sequential Synthesis and Verification
 
Loading...
Searching...
No Matches
Functions
acecPool.c File Reference
#include "acecInt.h"
#include "misc/vec/vecWec.h"
#include "misc/extra/extra.h"
Include dependency graph for acecPool.c:

Go to the source code of this file.

Functions

ABC_NAMESPACE_IMPL_START Vec_Int_t * Acec_ManCreateCarryMap (Gia_Man_t *p, Vec_Int_t *vAdds)
 DECLARATIONS ///.
 
int Acec_ManCheckCarryMap (Gia_Man_t *p, int Carry, Vec_Int_t *vAdds, Vec_Int_t *vCarryMap)
 
Vec_Int_t * Acec_ManCollectCarryRoots (Gia_Man_t *p, Vec_Int_t *vAdds)
 
Vec_Int_t * Acec_ManCollectXorRoots (Gia_Man_t *p, Vec_Int_t *vXors)
 
void Acec_ManCountXorTreeInputs_rec (Gia_Man_t *p, int Node, Vec_Int_t *vXors, Vec_Int_t *vXorMap, Vec_Bit_t *vIsCarryRoot, Vec_Int_t *vCarryRootSet, Vec_Int_t *vXorSet)
 
Vec_Wec_t * Acec_ManCollectCarryRootSets (Gia_Man_t *p, Vec_Int_t *vAdds, Vec_Int_t *vCarryMap, Vec_Int_t *vXors, Vec_Int_t *vXorRoots, Vec_Int_t *vCarryRoots)
 
int Acec_ManCompareTwo (int *pPair0, int *pPair1)
 
void Acec_ManCollectInsOuts (Gia_Man_t *p, Vec_Int_t *vAdds, Vec_Int_t *vBoxes, Vec_Int_t *vBoxRanks, Vec_Bit_t *vBoxIns, Vec_Bit_t *vBoxOuts, Vec_Int_t *vResIns, Vec_Int_t *vResOuts)
 
void Acec_ManCollectBoxSets_rec (Gia_Man_t *p, int Carry, int iRank, Vec_Int_t *vAdds, Vec_Int_t *vCarryMap, Vec_Int_t *vBoxes, Vec_Int_t *vBoxRanks)
 
Vec_Wec_t * Acec_ManCollectBoxSets (Gia_Man_t *p, Vec_Int_t *vAdds, Vec_Int_t *vXors)
 
void Acec_ManPrintRanks2 (Vec_Int_t *vPairs)
 
void Acec_ManPrintRanks (Vec_Int_t *vPairs)
 
void Acec_ManProfile (Gia_Man_t *p, int fVerbose)
 
Vec_Bit_t * Acec_ManPoolGetPointed (Gia_Man_t *p, Vec_Int_t *vAdds)
 
Vec_Int_t * Acec_ManPoolTopMost (Gia_Man_t *p, Vec_Int_t *vAdds)
 
void Acec_ManPool (Gia_Man_t *p)
 

Function Documentation

◆ Acec_ManCheckCarryMap()

int Acec_ManCheckCarryMap ( Gia_Man_t * p,
int Carry,
Vec_Int_t * vAdds,
Vec_Int_t * vCarryMap )

Definition at line 56 of file acecPool.c.

57{
58 int iBox = Vec_IntEntry( vCarryMap, Carry );
59 assert( iBox >= 0 );
60 return Vec_IntEntry( vCarryMap, Vec_IntEntry(vAdds, 6*iBox+0) ) >= 0 ||
61 Vec_IntEntry( vCarryMap, Vec_IntEntry(vAdds, 6*iBox+1) ) >= 0 ||
62 Vec_IntEntry( vCarryMap, Vec_IntEntry(vAdds, 6*iBox+2) ) >= 0;
63}
assert
#define assert(ex)
Definition util_old.h:213
Here is the caller graph for this function:

◆ Acec_ManCollectBoxSets()

Vec_Wec_t * Acec_ManCollectBoxSets ( Gia_Man_t * p,
Vec_Int_t * vAdds,
Vec_Int_t * vXors )

Definition at line 241 of file acecPool.c.

242{
243 Vec_Int_t * vCarryMap = Acec_ManCreateCarryMap( p, vAdds );
244 Vec_Int_t * vCarryRoots = Acec_ManCollectCarryRoots( p, vAdds );
245 Vec_Int_t * vXorRoots = Acec_ManCollectXorRoots( p, vXors );
246 Vec_Wec_t * vBoxSets = Acec_ManCollectCarryRootSets( p, vAdds, vCarryMap, vXors, vXorRoots, vCarryRoots );
247 Vec_Int_t * vBoxRanks = Vec_IntStart( Vec_IntSize(vAdds)/6 );
248 Vec_Bit_t * vBoxIns = Vec_BitStart( Gia_ManObjNum(p) );
249 Vec_Bit_t * vBoxOuts = Vec_BitStart( Gia_ManObjNum(p) ); int i, k, Root;
250 Vec_IntFree( vCarryRoots );
251 Vec_IntFree( vXorRoots );
252 // collect boxes for each carry set
253 assert( Vec_WecSize(vBoxSets) % 5 == 0 );
254 for ( i = 0; 5*i < Vec_WecSize(vBoxSets); i++ )
255 {
256 Vec_Int_t * vRoots = Vec_WecEntry( vBoxSets, 5*i+1 );
257 Vec_Int_t * vBoxes = Vec_WecEntry( vBoxSets, 5*i+2 );
258 Vec_Int_t * vIns = Vec_WecEntry( vBoxSets, 5*i+3 );
259 Vec_Int_t * vOuts = Vec_WecEntry( vBoxSets, 5*i+4 );
260 Vec_IntForEachEntry( vRoots, Root, k )
261 Acec_ManCollectBoxSets_rec( p, Root, 1, vAdds, vCarryMap, vBoxes, vBoxRanks );
262 Acec_ManCollectInsOuts( p, vAdds, vBoxes, vBoxRanks, vBoxIns, vBoxOuts, vIns, vOuts );
263 }
264 Vec_IntFree( vBoxRanks );
265 Vec_BitFree( vBoxIns );
266 Vec_BitFree( vBoxOuts );
267 Vec_IntFree( vCarryMap );
268 return vBoxSets;
269}
Acec_ManCreateCarryMap
ABC_NAMESPACE_IMPL_START Vec_Int_t * Acec_ManCreateCarryMap(Gia_Man_t *p, Vec_Int_t *vAdds)
DECLARATIONS ///.
Definition acecPool.c:48
Acec_ManCollectBoxSets_rec
void Acec_ManCollectBoxSets_rec(Gia_Man_t *p, int Carry, int iRank, Vec_Int_t *vAdds, Vec_Int_t *vCarryMap, Vec_Int_t *vBoxes, Vec_Int_t *vBoxRanks)
Definition acecPool.c:229
Acec_ManCollectCarryRoots
Vec_Int_t * Acec_ManCollectCarryRoots(Gia_Man_t *p, Vec_Int_t *vAdds)
Definition acecPool.c:64
Acec_ManCollectInsOuts
void Acec_ManCollectInsOuts(Gia_Man_t *p, Vec_Int_t *vAdds, Vec_Int_t *vBoxes, Vec_Int_t *vBoxRanks, Vec_Bit_t *vBoxIns, Vec_Bit_t *vBoxOuts, Vec_Int_t *vResIns, Vec_Int_t *vResOuts)
Definition acecPool.c:185
Acec_ManCollectXorRoots
Vec_Int_t * Acec_ManCollectXorRoots(Gia_Man_t *p, Vec_Int_t *vXors)
Definition acecPool.c:82
Acec_ManCollectCarryRootSets
Vec_Wec_t * Acec_ManCollectCarryRootSets(Gia_Man_t *p, Vec_Int_t *vAdds, Vec_Int_t *vCarryMap, Vec_Int_t *vXors, Vec_Int_t *vXorRoots, Vec_Int_t *vCarryRoots)
Definition acecPool.c:117
Vec_Int_t
typedefABC_NAMESPACE_IMPL_START struct Vec_Int_t_ Vec_Int_t
DECLARATIONS ///.
Definition bblif.c:37
p
Cube * p
Definition exorList.c:222
Vec_Bit_t
typedefABC_NAMESPACE_HEADER_START struct Vec_Bit_t_ Vec_Bit_t
INCLUDES ///.
Definition vecBit.h:42
Vec_IntForEachEntry
#define Vec_IntForEachEntry(vVec, Entry, i)
MACRO DEFINITIONS ///.
Definition vecInt.h:54
Vec_Wec_t
typedefABC_NAMESPACE_HEADER_START struct Vec_Wec_t_ Vec_Wec_t
INCLUDES ///.
Definition vecWec.h:42
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Acec_ManCollectBoxSets_rec()

void Acec_ManCollectBoxSets_rec ( Gia_Man_t * p,
int Carry,
int iRank,
Vec_Int_t * vAdds,
Vec_Int_t * vCarryMap,
Vec_Int_t * vBoxes,
Vec_Int_t * vBoxRanks )

Definition at line 229 of file acecPool.c.

230{
231 int iBox = Vec_IntEntry( vCarryMap, Carry );
232 if ( iBox == -1 )
233 return;
234 Acec_ManCollectBoxSets_rec( p, Vec_IntEntry(vAdds, 6*iBox+0), iRank+1, vAdds, vCarryMap, vBoxes, vBoxRanks );
235 Acec_ManCollectBoxSets_rec( p, Vec_IntEntry(vAdds, 6*iBox+1), iRank+1, vAdds, vCarryMap, vBoxes, vBoxRanks );
236 if ( Vec_IntEntry(vAdds, 6*iBox+2) )
237 Acec_ManCollectBoxSets_rec( p, Vec_IntEntry(vAdds, 6*iBox+2), iRank+1, vAdds, vCarryMap, vBoxes, vBoxRanks );
238 Vec_IntPush( vBoxes, iBox );
239 Vec_IntWriteEntry( vBoxRanks, iBox, iRank );
240}
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Acec_ManCollectCarryRoots()

Vec_Int_t * Acec_ManCollectCarryRoots ( Gia_Man_t * p,
Vec_Int_t * vAdds )

Definition at line 64 of file acecPool.c.

65{
66 Vec_Int_t * vCarryRoots = Vec_IntAlloc( 100 );
67 Vec_Bit_t * vIns = Vec_BitStart( Gia_ManObjNum(p) ); int i;
68 // marks box inputs
69 for ( i = 0; 6*i < Vec_IntSize(vAdds); i++ )
70 {
71 Vec_BitWriteEntry( vIns, Vec_IntEntry(vAdds, 6*i+0), 1 );
72 Vec_BitWriteEntry( vIns, Vec_IntEntry(vAdds, 6*i+1), 1 );
73 Vec_BitWriteEntry( vIns, Vec_IntEntry(vAdds, 6*i+2), 1 );
74 }
75 // collect roots
76 for ( i = 0; 6*i < Vec_IntSize(vAdds); i++ )
77 if ( !Vec_BitEntry(vIns, Vec_IntEntry(vAdds, 6*i+4)) )
78 Vec_IntPush( vCarryRoots, Vec_IntEntry(vAdds, 6*i+4) );
79 Vec_BitFree( vIns );
80 return vCarryRoots;
81}
Here is the caller graph for this function:

◆ Acec_ManCollectCarryRootSets()

Vec_Wec_t * Acec_ManCollectCarryRootSets ( Gia_Man_t * p,
Vec_Int_t * vAdds,
Vec_Int_t * vCarryMap,
Vec_Int_t * vXors,
Vec_Int_t * vXorRoots,
Vec_Int_t * vCarryRoots )

Definition at line 117 of file acecPool.c.

118{
119 Vec_Wec_t * vCarryRootSets = Vec_WecAlloc( 100 ); // XorBoxes, CarryRoots, AdderBoxes, Ins/Ranks, Outs/Ranks
120 Vec_Int_t * vCarryRootSet = Vec_IntAlloc( 100 );
121 Vec_Bit_t * vIsCarryRoot = Vec_BitStart( Gia_ManObjNum(p) );
122 Vec_Int_t * vXorSet = Vec_IntAlloc( 100 ), * vLevel;
123 int i, k, XorRoot, CarryRoot;
124 // map XORs into their cuts
125 Vec_Int_t * vXorMap = Vec_IntStartFull( Gia_ManObjNum(p) );
126 for ( i = 0; 4*i < Vec_IntSize(vXors); i++ )
127 Vec_IntWriteEntry( vXorMap, Vec_IntEntry(vXors, 4*i), i );
128 // create carry root marks
129 Vec_IntForEachEntry( vCarryRoots, CarryRoot, i )
130 Vec_BitWriteEntry( vIsCarryRoot, CarryRoot, 1 );
131 // collect carry roots attached to each XOR root
132 Vec_IntForEachEntry( vXorRoots, XorRoot, i )
133 {
134 Vec_IntClear( vXorSet );
135 Vec_IntClear( vCarryRootSet );
136 Gia_ManIncrementTravId( p );
137 Acec_ManCountXorTreeInputs_rec( p, XorRoot, vXors, vXorMap, vIsCarryRoot, vCarryRootSet, vXorSet );
138 // skip trivial
139 Vec_IntForEachEntry( vCarryRootSet, CarryRoot, k )
140 if ( Acec_ManCheckCarryMap(p, CarryRoot, vAdds, vCarryMap) )
141 break;
142 if ( k == Vec_IntSize(vCarryRootSet) )
143 continue;
144 Vec_IntSort( vCarryRootSet, 0 );
145 vLevel = Vec_WecPushLevel( vCarryRootSets );
146 Vec_IntAppend( vLevel, vXorSet );
147 vLevel = Vec_WecPushLevel( vCarryRootSets );
148 Vec_IntAppend( vLevel, vCarryRootSet );
149 vLevel = Vec_WecPushLevel( vCarryRootSets );
150 vLevel = Vec_WecPushLevel( vCarryRootSets );
151 vLevel = Vec_WecPushLevel( vCarryRootSets );
152 // unmark carry root set
153 Vec_IntForEachEntry( vCarryRootSet, CarryRoot, k )
154 {
155 assert( Vec_BitEntry(vIsCarryRoot, CarryRoot) );
156 Vec_BitWriteEntry( vIsCarryRoot, CarryRoot, 0 );
157 }
158 }
159 Vec_IntFree( vCarryRootSet );
160 Vec_IntFree( vXorSet );
161 Vec_IntFree( vXorMap );
162 // collect unmarked carry roots
163 Vec_IntForEachEntry( vCarryRoots, CarryRoot, k )
164 {
165 if ( !Vec_BitEntry(vIsCarryRoot, CarryRoot) )
166 continue;
167 if ( !Acec_ManCheckCarryMap(p, CarryRoot, vAdds, vCarryMap) )
168 continue;
169 vLevel = Vec_WecPushLevel( vCarryRootSets );
170 vLevel = Vec_WecPushLevel( vCarryRootSets );
171 Vec_IntFill( vLevel, 1, CarryRoot );
172 vLevel = Vec_WecPushLevel( vCarryRootSets );
173 vLevel = Vec_WecPushLevel( vCarryRootSets );
174 vLevel = Vec_WecPushLevel( vCarryRootSets );
175 }
176 Vec_BitFree( vIsCarryRoot );
177 return vCarryRootSets;
178}
Acec_ManCountXorTreeInputs_rec
void Acec_ManCountXorTreeInputs_rec(Gia_Man_t *p, int Node, Vec_Int_t *vXors, Vec_Int_t *vXorMap, Vec_Bit_t *vIsCarryRoot, Vec_Int_t *vCarryRootSet, Vec_Int_t *vXorSet)
Definition acecPool.c:100
Acec_ManCheckCarryMap
int Acec_ManCheckCarryMap(Gia_Man_t *p, int Carry, Vec_Int_t *vAdds, Vec_Int_t *vCarryMap)
Definition acecPool.c:56
Gia_ManIncrementTravId
void Gia_ManIncrementTravId(Gia_Man_t *p)
Definition giaUtil.c:190
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Acec_ManCollectInsOuts()

void Acec_ManCollectInsOuts ( Gia_Man_t * p,
Vec_Int_t * vAdds,
Vec_Int_t * vBoxes,
Vec_Int_t * vBoxRanks,
Vec_Bit_t * vBoxIns,
Vec_Bit_t * vBoxOuts,
Vec_Int_t * vResIns,
Vec_Int_t * vResOuts )

Definition at line 185 of file acecPool.c.

186{
187 int i, k, iBox, iObj, Rank, RankMax = 0;
188 // mark box inputs/outputs
189 Vec_IntForEachEntry( vBoxes, iBox, i )
190 {
191 Vec_BitWriteEntry( vBoxIns, Vec_IntEntry(vAdds, 6*iBox+0), 1 );
192 Vec_BitWriteEntry( vBoxIns, Vec_IntEntry(vAdds, 6*iBox+1), 1 );
193 Vec_BitWriteEntry( vBoxIns, Vec_IntEntry(vAdds, 6*iBox+2), 1 );
194 Vec_BitWriteEntry( vBoxOuts, Vec_IntEntry(vAdds, 6*iBox+3), 1 );
195 Vec_BitWriteEntry( vBoxOuts, Vec_IntEntry(vAdds, 6*iBox+4), 1 );
196 }
197 // collect unmarked inputs/output and their ranks
198 Vec_IntForEachEntry( vBoxes, iBox, i )
199 {
200 for ( k = 0; k < 3; k++ )
201 if ( !Vec_BitEntry(vBoxOuts, Vec_IntEntry(vAdds, 6*iBox+k)) )
202 Vec_IntPushTwo( vResIns, Vec_IntEntry(vAdds, 6*iBox+k), Vec_IntEntry(vBoxRanks, iBox) );
203 for ( k = 3; k < 5; k++ )
204 if ( Vec_IntEntry(vAdds, 6*iBox+k) && !Vec_BitEntry(vBoxIns, Vec_IntEntry(vAdds, 6*iBox+k)) )
205 Vec_IntPushTwo( vResOuts, Vec_IntEntry(vAdds, 6*iBox+k), Vec_IntEntry(vBoxRanks, iBox)-(int)(k==4) );
206 }
207 // unmark box inputs/outputs
208 Vec_IntForEachEntry( vBoxes, iBox, i )
209 {
210 Vec_BitWriteEntry( vBoxIns, Vec_IntEntry(vAdds, 6*iBox+0), 0 );
211 Vec_BitWriteEntry( vBoxIns, Vec_IntEntry(vAdds, 6*iBox+1), 0 );
212 Vec_BitWriteEntry( vBoxIns, Vec_IntEntry(vAdds, 6*iBox+2), 0 );
213 Vec_BitWriteEntry( vBoxOuts, Vec_IntEntry(vAdds, 6*iBox+3), 0 );
214 Vec_BitWriteEntry( vBoxOuts, Vec_IntEntry(vAdds, 6*iBox+4), 0 );
215 }
216 // normalize ranks
217 Vec_IntForEachEntryDouble( vResIns, iObj, Rank, k )
218 RankMax = Abc_MaxInt( RankMax, Rank );
219 Vec_IntForEachEntryDouble( vResOuts, iObj, Rank, k )
220 RankMax = Abc_MaxInt( RankMax, Rank );
221 Vec_IntForEachEntryDouble( vResIns, iObj, Rank, k )
222 Vec_IntWriteEntry( vResIns, k+1, 1 + RankMax - Rank );
223 Vec_IntForEachEntryDouble( vResOuts, iObj, Rank, k )
224 Vec_IntWriteEntry( vResOuts, k+1, 1 + RankMax - Rank );
225 // sort by rank
226 qsort( Vec_IntArray(vResIns), (size_t)(Vec_IntSize(vResIns)/2), 8, (int (*)(const void *, const void *))Acec_ManCompareTwo );
227 qsort( Vec_IntArray(vResOuts), (size_t)(Vec_IntSize(vResOuts)/2), 8, (int (*)(const void *, const void *))Acec_ManCompareTwo );
228}
Acec_ManCompareTwo
int Acec_ManCompareTwo(int *pPair0, int *pPair1)
Definition acecPool.c:179
Vec_IntForEachEntryDouble
#define Vec_IntForEachEntryDouble(vVec, Entry1, Entry2, i)
Definition vecInt.h:72
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Acec_ManCollectXorRoots()

Vec_Int_t * Acec_ManCollectXorRoots ( Gia_Man_t * p,
Vec_Int_t * vXors )

Definition at line 82 of file acecPool.c.

83{
84 Vec_Int_t * vXorRoots = Vec_IntAlloc( 100 );
85 Vec_Bit_t * vIns = Vec_BitStart( Gia_ManObjNum(p) ); int i;
86 // marks box inputs
87 for ( i = 0; 4*i < Vec_IntSize(vXors); i++ )
88 {
89 Vec_BitWriteEntry( vIns, Vec_IntEntry(vXors, 4*i+1), 1 );
90 Vec_BitWriteEntry( vIns, Vec_IntEntry(vXors, 4*i+2), 1 );
91 Vec_BitWriteEntry( vIns, Vec_IntEntry(vXors, 4*i+3), 1 );
92 }
93 // collect roots
94 for ( i = 0; 4*i < Vec_IntSize(vXors); i++ )
95 if ( !Vec_BitEntry(vIns, Vec_IntEntry(vXors, 4*i)) )
96 Vec_IntPush( vXorRoots, Vec_IntEntry(vXors, 4*i) );
97 Vec_BitFree( vIns );
98 return vXorRoots;
99}
Here is the caller graph for this function:

◆ Acec_ManCompareTwo()

int Acec_ManCompareTwo ( int * pPair0,
int * pPair1 )

Definition at line 179 of file acecPool.c.

180{
181 if ( pPair0[1] < pPair1[1] ) return -1;
182 if ( pPair0[1] > pPair1[1] ) return 1;
183 return 0;
184}
Here is the caller graph for this function:

◆ Acec_ManCountXorTreeInputs_rec()

void Acec_ManCountXorTreeInputs_rec ( Gia_Man_t * p,
int Node,
Vec_Int_t * vXors,
Vec_Int_t * vXorMap,
Vec_Bit_t * vIsCarryRoot,
Vec_Int_t * vCarryRootSet,
Vec_Int_t * vXorSet )

Definition at line 100 of file acecPool.c.

101{
102 int k, iXorBox;
103 if ( Node == 0 || Gia_ObjIsTravIdCurrentId(p, Node) )
104 return;
105 Gia_ObjSetTravIdCurrentId(p, Node);
106 iXorBox = Vec_IntEntry( vXorMap, Node );
107 if ( iXorBox == -1 )
108 {
109 if ( Vec_BitEntry(vIsCarryRoot, Node) )
110 Vec_IntPush( vCarryRootSet, Node );
111 return;
112 }
113 for ( k = 1; k < 4; k++ )
114 Acec_ManCountXorTreeInputs_rec( p, Vec_IntEntry(vXors, 4*iXorBox+k), vXors, vXorMap, vIsCarryRoot, vCarryRootSet, vXorSet );
115 Vec_IntPush( vXorSet, Vec_IntEntry(vXors, 4*iXorBox) );
116}
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Acec_ManCreateCarryMap()

ABC_NAMESPACE_IMPL_START Vec_Int_t * Acec_ManCreateCarryMap ( Gia_Man_t * p,
Vec_Int_t * vAdds )

DECLARATIONS ///.

CFile****************************************************************

FileName [acecPool.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [CEC for arithmetic circuits.]

Synopsis [Core procedures.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

Id
acecPool.c,v 1.00 2005/06/20 00:00:00 alanmi Exp

] FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 48 of file acecPool.c.

49{
50 // map carries into their boxes
51 Vec_Int_t * vCarryMap = Vec_IntStartFull( Gia_ManObjNum(p) ); int i;
52 for ( i = 0; 6*i < Vec_IntSize(vAdds); i++ )
53 Vec_IntWriteEntry( vCarryMap, Vec_IntEntry(vAdds, 6*i+4), i );
54 return vCarryMap;
55}
Here is the caller graph for this function:

◆ Acec_ManPool()

void Acec_ManPool ( Gia_Man_t * p)

Definition at line 389 of file acecPool.c.

390{
391 Vec_Int_t * vTops, * vTree;
392 Vec_Wec_t * vTrees;
393
394 abctime clk = Abc_Clock();
395 Vec_Int_t * vAdds = Ree_ManComputeCuts( p, NULL, 1 );
396 int i, nFadds = Ree_ManCountFadds( vAdds );
397 printf( "Detected %d FAs and %d HAs. ", nFadds, Vec_IntSize(vAdds)/6-nFadds );
398 Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
399
400 clk = Abc_Clock();
401 nFadds = Ree_ManCountFadds( vAdds );
402 printf( "Detected %d FAs and %d HAs. ", nFadds, Vec_IntSize(vAdds)/6-nFadds );
403 Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
404
405 //Ree_ManPrintAdders( vAdds, 1 );
406
407 // detect topmost nodes
408 vTops = Acec_ManPoolTopMost( p, vAdds );
409 printf( "Detected %d topmost adder%s.\n", Vec_IntSize(vTops), Vec_IntSize(vTops) > 1 ? "s":"" );
410
411 // collect adder trees
412 vTrees = Gia_PolynCoreOrderArray( p, vAdds, vTops );
413 Vec_WecForEachLevel( vTrees, vTree, i )
414 printf( "Adder %5d : Tree with %5d nodes.\n", Vec_IntEntry(vTops, i), Vec_IntSize(vTree) );
415
416 Vec_WecFree( vTrees );
417 Vec_IntFree( vAdds );
418 Vec_IntFree( vTops );
419}
abctime
ABC_INT64_T abctime
Definition abc_global.h:332
Gia_PolynCoreOrderArray
Vec_Wec_t * Gia_PolynCoreOrderArray(Gia_Man_t *pGia, Vec_Int_t *vAdds, Vec_Int_t *vRootBoxes)
Definition acecCo.c:222
Acec_ManPoolTopMost
Vec_Int_t * Acec_ManPoolTopMost(Gia_Man_t *p, Vec_Int_t *vAdds)
Definition acecPool.c:363
Ree_ManComputeCuts
Vec_Int_t * Ree_ManComputeCuts(Gia_Man_t *p, Vec_Int_t **pvXors, int fVerbose)
Definition acecRe.c:408
Ree_ManCountFadds
int Ree_ManCountFadds(Vec_Int_t *vAdds)
Definition acecRe.c:556
Vec_WecForEachLevel
#define Vec_WecForEachLevel(vGlob, vVec, i)
MACRO DEFINITIONS ///.
Definition vecWec.h:55
Here is the call graph for this function:

◆ Acec_ManPoolGetPointed()

Vec_Bit_t * Acec_ManPoolGetPointed ( Gia_Man_t * p,
Vec_Int_t * vAdds )

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 353 of file acecPool.c.

354{
355 Vec_Bit_t * vMarks = Vec_BitStart( Gia_ManObjNum(p) );
356 int i, k;
357 for ( i = 0; 6*i < Vec_IntSize(vAdds); i++ )
358 for ( k = 0; k < 3; k++ )
359 Vec_BitWriteEntry( vMarks, Vec_IntEntry(vAdds, 6*i+k), 1 );
360 return vMarks;
361}
Here is the caller graph for this function:

◆ Acec_ManPoolTopMost()

Vec_Int_t * Acec_ManPoolTopMost ( Gia_Man_t * p,
Vec_Int_t * vAdds )

Definition at line 363 of file acecPool.c.

364{
365 int i, k, iTop, fVerbose = 0;
366 Vec_Int_t * vTops = Vec_IntAlloc( 1000 );
367 Vec_Bit_t * vMarks = Acec_ManPoolGetPointed( p, vAdds );
368
369 for ( i = 0; 6*i < Vec_IntSize(vAdds); i++ )
370 if ( !Vec_BitEntry(vMarks, Vec_IntEntry(vAdds, 6*i+3)) &&
371 !Vec_BitEntry(vMarks, Vec_IntEntry(vAdds, 6*i+4)) )
372 Vec_IntPush( vTops, i );
373
374 if ( fVerbose )
375 Vec_IntForEachEntry( vTops, iTop, i )
376 {
377 printf( "%4d : ", iTop );
378 for ( k = 0; k < 3; k++ )
379 printf( "%4d ", Vec_IntEntry(vAdds, 6*iTop+k) );
380 printf( " -> " );
381 for ( k = 3; k < 5; k++ )
382 printf( "%4d ", Vec_IntEntry(vAdds, 6*iTop+k) );
383 printf( "\n" );
384 }
385
386 Vec_BitFree( vMarks );
387 return vTops;
388}
Acec_ManPoolGetPointed
Vec_Bit_t * Acec_ManPoolGetPointed(Gia_Man_t *p, Vec_Int_t *vAdds)
Definition acecPool.c:353
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Acec_ManPrintRanks()

void Acec_ManPrintRanks ( Vec_Int_t * vPairs)

Definition at line 277 of file acecPool.c.

278{
279 int k, iObj, Count, Rank, RankMax = 0;
280 Vec_Int_t * vCounts = Vec_IntStart( 100 );
281 Vec_IntForEachEntryDouble( vPairs, iObj, Rank, k )
282 {
283 Vec_IntFillExtra( vCounts, Rank+1, 0 );
284 Vec_IntAddToEntry( vCounts, Rank, 1 );
285 RankMax = Abc_MaxInt( RankMax, Rank );
286 }
287 Vec_IntForEachEntryStartStop( vCounts, Count, Rank, 1, RankMax+1 )
288 printf( "%2d=%2d ", Rank, Count );
289 printf( "\n" );
290 Vec_IntFree( vCounts );
291}
Vec_IntForEachEntryStartStop
#define Vec_IntForEachEntryStartStop(vVec, Entry, i, Start, Stop)
Definition vecInt.h:60
Here is the caller graph for this function:

◆ Acec_ManPrintRanks2()

void Acec_ManPrintRanks2 ( Vec_Int_t * vPairs)

Definition at line 270 of file acecPool.c.

271{
272 int k, iObj, Rank;
273 Vec_IntForEachEntryDouble( vPairs, iObj, Rank, k )
274 printf( "%d ", Rank );
275 printf( "\n" );
276}

◆ Acec_ManProfile()

void Acec_ManProfile ( Gia_Man_t * p,
int fVerbose )

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 304 of file acecPool.c.

305{
306 abctime clk = Abc_Clock();
307 Vec_Wec_t * vBoxes; int i;
308 Vec_Int_t * vXors, * vAdds = Ree_ManComputeCuts( p, &vXors, fVerbose );
309
310 //Ree_ManPrintAdders( vAdds, 1 );
311 printf( "Detected %d full-adders and %d half-adders. Found %d XOR-cuts. ", Ree_ManCountFadds(vAdds), Vec_IntSize(vAdds)/6-Ree_ManCountFadds(vAdds), Vec_IntSize(vXors)/4 );
312 Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
313
314 clk = Abc_Clock();
315 vBoxes = Acec_ManCollectBoxSets( p, vAdds, vXors );
316 printf( "Detected %d adder-tree%s. ", Vec_WecSize(vBoxes)/5, Vec_WecSize(vBoxes)/5 > 1 ? "s":"" );
317 Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
318
319 if ( fVerbose )
320 for ( i = 0; 5*i < Vec_WecSize(vBoxes); i++ )
321 {
322 printf( "Tree %3d : ", i );
323 printf( "Xor = %4d ", Vec_IntSize(Vec_WecEntry(vBoxes,5*i+0)) );
324 printf( "Root = %4d ", Vec_IntSize(Vec_WecEntry(vBoxes,5*i+1)) );
325 //printf( "(Top = %5d) ", Vec_IntEntryLast(Vec_WecEntry(vBoxes,5*i+1)) );
326 printf( "Adder = %4d ", Vec_IntSize(Vec_WecEntry(vBoxes,5*i+2)) );
327 printf( "In = %4d ", Vec_IntSize(Vec_WecEntry(vBoxes,5*i+3))/2 );
328 printf( "Out = %4d ", Vec_IntSize(Vec_WecEntry(vBoxes,5*i+4))/2 );
329 printf( "\n" );
330 printf( " Ins: " );
331 Acec_ManPrintRanks( Vec_WecEntry(vBoxes,5*i+3) );
332 printf( " Outs: " );
333 Acec_ManPrintRanks( Vec_WecEntry(vBoxes,5*i+4) );
334 }
335
336 Vec_IntFree( vXors );
337 Vec_IntFree( vAdds );
338 Vec_WecFree( vBoxes );
339}
Acec_ManPrintRanks
void Acec_ManPrintRanks(Vec_Int_t *vPairs)
Definition acecPool.c:277
Acec_ManCollectBoxSets
Vec_Wec_t * Acec_ManCollectBoxSets(Gia_Man_t *p, Vec_Int_t *vAdds, Vec_Int_t *vXors)
Definition acecPool.c:241
Here is the call graph for this function: