1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
|
/**CFile****************************************************************
FileName [amapInt.h]
SystemName [ABC: Logic synthesis and verification system.]
PackageName [Technology mapper for standard cells.]
Synopsis [Internal declarations.]
Author [Alan Mishchenko]
Affiliation [UC Berkeley]
Date [Ver. 1.0. Started - June 20, 2005.]
Revision [$Id: amapInt.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
***********************************************************************/
#ifndef ABC__map__amap__amapInt_h
#define ABC__map__amap__amapInt_h
////////////////////////////////////////////////////////////////////////
/// INCLUDES ///
////////////////////////////////////////////////////////////////////////
#include "misc/extra/extra.h"
#include "aig/aig/aig.h"
#include "amap.h"
////////////////////////////////////////////////////////////////////////
/// PARAMETERS ///
////////////////////////////////////////////////////////////////////////
ABC_NAMESPACE_HEADER_START
// the largest gate size in the library
// (gates above this size will be ignored)
#define AMAP_MAXINS 15
#define AMAP_STRING_CONST0 "CONST0"
#define AMAP_STRING_CONST1 "CONST1"
// object types
typedef enum {
AMAP_OBJ_NONE, // 0: non-existent object
AMAP_OBJ_CONST1, // 1: constant 1
AMAP_OBJ_PI, // 2: primary input
AMAP_OBJ_PO, // 3: primary output
AMAP_OBJ_AND, // 4: AND node
AMAP_OBJ_XOR, // 5: XOR node
AMAP_OBJ_MUX, // 6: MUX node
AMAP_OBJ_VOID // 7: unused object
} Amap_Type_t;
////////////////////////////////////////////////////////////////////////
/// BASIC TYPES ///
////////////////////////////////////////////////////////////////////////
typedef struct Amap_Pin_t_ Amap_Pin_t;
typedef struct Amap_Gat_t_ Amap_Gat_t;
typedef struct Amap_Nod_t_ Amap_Nod_t;
typedef struct Amap_Set_t_ Amap_Set_t;
typedef struct Amap_Man_t_ Amap_Man_t;
typedef struct Amap_Obj_t_ Amap_Obj_t;
typedef struct Amap_Cut_t_ Amap_Cut_t;
typedef struct Amap_Mat_t_ Amap_Mat_t;
struct Amap_Man_t_
{
// user data
Amap_Par_t * pPars;
Amap_Lib_t * pLib;
// internal parameters
float fEpsilonInternal;
float fAreaInv;
int fUseXor;
int fUseMux;
// internal AIG with choices
Vec_Ptr_t * vPis;
Vec_Ptr_t * vPos;
Vec_Ptr_t * vObjs;
Aig_MmFixed_t * pMemObj;
Aig_MmFlex_t * pMemCuts;
Aig_MmFlex_t * pMemCutBest;
Aig_MmFlex_t * pMemTemp;
Amap_Obj_t * pConst1;
int nObjs[AMAP_OBJ_VOID];
int nLevelMax;
int nChoicesGiven;
int nChoicesAdded;
// mapping data-structures
Vec_Int_t * vTemp;
int * pMatsTemp;
Amap_Cut_t ** ppCutsTemp;
Amap_Cut_t * pCutsPi;
Vec_Ptr_t * vCuts0;
Vec_Ptr_t * vCuts1;
Vec_Ptr_t * vCuts2;
// statistics
int nCutsUsed;
int nCutsTried;
int nCutsTried3;
int nBytesUsed;
};
struct Amap_Lib_t_
{
char * pName; // library name
Vec_Ptr_t * vGates; // represenation of gates
Vec_Ptr_t * vSorted; // gates sorted for area-only mapping
Vec_Ptr_t * vSelect; // gates selected for area-only mapping
Amap_Gat_t * pGate0; // the constant zero gate
Amap_Gat_t * pGate1; // the constant one gate
Amap_Gat_t * pGateBuf; // the buffer
Amap_Gat_t * pGateInv; // the inverter
Aig_MmFlex_t * pMemGates; // memory manager for objects
int fHasXor; // XOR/NXOR gates are present
int fHasMux; // MUX/NMUX gates are present
// structural representation
int fVerbose; // enable detailed statistics
Amap_Nod_t * pNodes; // representation nodes
int nNodes; // the number of nodes used
int nNodesAlloc; // the number of nodes allocated
Vec_Ptr_t * vRules; // the rule of AND gate
Vec_Ptr_t * vRulesX; // the rule of XOR gate
Vec_Int_t * vRules3; // the rule of MUX gate
int ** pRules; // simplified representation
int ** pRulesX; // simplified representation
Aig_MmFlex_t * pMemSet; // memory manager for sets
int nSets; // the number of sets created
};
struct Amap_Pin_t_
{
char * pName;
int Phase;
double dLoadInput;
double dLoadMax;
double dDelayBlockRise;
double dDelayFanoutRise;
double dDelayBlockFall;
double dDelayFanoutFall;
double dDelayBlockMax;
};
struct Amap_Gat_t_
{
Amap_Lib_t * pLib; // library
Amap_Gat_t * pTwin; // twin gate
char * pName; // the name of the gate
char * pOutName; // name of the output
double dArea; // the area of the gate
char * pForm; // the formula describing functionality
unsigned * pFunc; // truth table
unsigned Id : 23; // unique number of the gate
unsigned fMux : 1; // denotes MUX-gates
unsigned nPins : 8; // number of inputs
Amap_Pin_t Pins[0]; // description of inputs
};
struct Amap_Set_t_
{
Amap_Set_t * pNext;
unsigned iGate : 16;
unsigned fInv : 1;
unsigned nIns : 15;
char Ins[AMAP_MAXINS];// mapping from gate inputs into fanins
};
struct Amap_Nod_t_
{
unsigned Id : 16; // ID of the node
unsigned nSuppSize: 8; // support size
unsigned Type : 8; // the type of node
short iFan0; // fanin0
short iFan1; // fanin1
short iFan2; // fanin2
short Unused; //
Amap_Set_t * pSets; // implementable gates
};
struct Amap_Cut_t_
{
unsigned iMat : 16;
unsigned fInv : 1;
unsigned nFans : 15;
int Fans[0];
};
struct Amap_Mat_t_
{
Amap_Cut_t * pCut; // the cut
Amap_Set_t * pSet; // the set
float Area; // area flow / exact area of the node
float AveFan; // edge flow of the node
float Delay; // delay of the node
};
struct Amap_Obj_t_
{
unsigned Type : 3;
unsigned Id : 29;
unsigned IdPio : 29;
unsigned fPhase : 1;
unsigned fRepr : 1;
unsigned fPolar : 1; // pCutBest->fInv ^ pSetBest->fInv
unsigned Level : 12; // 20 (July 16, 2009)
unsigned nCuts : 20; // 12 (July 16, 2009)
int nRefs;
int Equiv;
int Fan[3];
union {
void * pData;
int iData;
};
// match of the node
float EstRefs; // the number of estimated fanouts
int nFouts[2]; // the number of refs in each polarity
Amap_Mat_t Best; // the best match of the node
};
static inline Amap_Obj_t * Amap_Regular( Amap_Obj_t * p ) { return (Amap_Obj_t *)((ABC_PTRUINT_T)(p) & ~01); }
static inline Amap_Obj_t * Amap_Not( Amap_Obj_t * p ) { return (Amap_Obj_t *)((ABC_PTRUINT_T)(p) ^ 01); }
static inline Amap_Obj_t * Amap_NotCond( Amap_Obj_t * p, int c ) { return (Amap_Obj_t *)((ABC_PTRUINT_T)(p) ^ (c)); }
static inline int Amap_IsComplement( Amap_Obj_t * p ) { return (int )(((ABC_PTRUINT_T)p) & 01); }
static inline int Amap_ManPiNum( Amap_Man_t * p ) { return p->nObjs[AMAP_OBJ_PI]; }
static inline int Amap_ManPoNum( Amap_Man_t * p ) { return p->nObjs[AMAP_OBJ_PO]; }
static inline int Amap_ManAndNum( Amap_Man_t * p ) { return p->nObjs[AMAP_OBJ_AND]; }
static inline int Amap_ManXorNum( Amap_Man_t * p ) { return p->nObjs[AMAP_OBJ_XOR]; }
static inline int Amap_ManMuxNum( Amap_Man_t * p ) { return p->nObjs[AMAP_OBJ_MUX]; }
static inline int Amap_ManObjNum( Amap_Man_t * p ) { return Vec_PtrSize(p->vObjs); }
static inline int Amap_ManNodeNum( Amap_Man_t * p ) { return p->nObjs[AMAP_OBJ_AND] + p->nObjs[AMAP_OBJ_XOR] + p->nObjs[AMAP_OBJ_MUX]; }
static inline Amap_Obj_t * Amap_ManConst1( Amap_Man_t * p ) { return p->pConst1; }
static inline Amap_Obj_t * Amap_ManPi( Amap_Man_t * p, int i ) { return (Amap_Obj_t *)Vec_PtrEntry( p->vPis, i ); }
static inline Amap_Obj_t * Amap_ManPo( Amap_Man_t * p, int i ) { return (Amap_Obj_t *)Vec_PtrEntry( p->vPos, i ); }
static inline Amap_Obj_t * Amap_ManObj( Amap_Man_t * p, int i ) { return (Amap_Obj_t *)Vec_PtrEntry( p->vObjs, i ); }
static inline int Amap_ObjIsConst1( Amap_Obj_t * pObj ) { return pObj->Type == AMAP_OBJ_CONST1; }
static inline int Amap_ObjIsPi( Amap_Obj_t * pObj ) { return pObj->Type == AMAP_OBJ_PI; }
static inline int Amap_ObjIsPo( Amap_Obj_t * pObj ) { return pObj->Type == AMAP_OBJ_PO; }
static inline int Amap_ObjIsAnd( Amap_Obj_t * pObj ) { return pObj->Type == AMAP_OBJ_AND; }
static inline int Amap_ObjIsXor( Amap_Obj_t * pObj ) { return pObj->Type == AMAP_OBJ_XOR; }
static inline int Amap_ObjIsMux( Amap_Obj_t * pObj ) { return pObj->Type == AMAP_OBJ_MUX; }
static inline int Amap_ObjIsNode( Amap_Obj_t * pObj ) { return pObj->Type == AMAP_OBJ_AND || pObj->Type == AMAP_OBJ_XOR || pObj->Type == AMAP_OBJ_MUX; }
static inline int Amap_ObjToLit( Amap_Obj_t * pObj ) { return Abc_Var2Lit( Amap_Regular(pObj)->Id, Amap_IsComplement(pObj) ); }
static inline Amap_Obj_t * Amap_ObjFanin0( Amap_Man_t * p, Amap_Obj_t * pObj ) { return Amap_ManObj(p, Abc_Lit2Var(pObj->Fan[0])); }
static inline Amap_Obj_t * Amap_ObjFanin1( Amap_Man_t * p, Amap_Obj_t * pObj ) { return Amap_ManObj(p, Abc_Lit2Var(pObj->Fan[1])); }
static inline Amap_Obj_t * Amap_ObjFanin2( Amap_Man_t * p, Amap_Obj_t * pObj ) { return Amap_ManObj(p, Abc_Lit2Var(pObj->Fan[2])); }
static inline int Amap_ObjFaninC0( Amap_Obj_t * pObj ) { return Abc_LitIsCompl(pObj->Fan[0]); }
static inline int Amap_ObjFaninC1( Amap_Obj_t * pObj ) { return Abc_LitIsCompl(pObj->Fan[1]); }
static inline int Amap_ObjFaninC2( Amap_Obj_t * pObj ) { return Abc_LitIsCompl(pObj->Fan[2]); }
static inline void * Amap_ObjCopy( Amap_Obj_t * pObj ) { return pObj->pData; }
static inline int Amap_ObjLevel( Amap_Obj_t * pObj ) { return pObj->Level; }
static inline void Amap_ObjSetLevel( Amap_Obj_t * pObj, int Level ) { pObj->Level = Level; }
static inline void Amap_ObjSetCopy( Amap_Obj_t * pObj, void * pCopy ) { pObj->pData = pCopy; }
static inline Amap_Obj_t * Amap_ObjChoice( Amap_Man_t * p, Amap_Obj_t * pObj ) { return pObj->Equiv? Amap_ManObj(p, pObj->Equiv) : NULL; }
static inline void Amap_ObjSetChoice( Amap_Obj_t * pObj, Amap_Obj_t * pEqu){ assert(pObj->Equiv==0); if (pObj->Id != pEqu->Id) pObj->Equiv = pEqu->Id; }
static inline int Amap_ObjPhaseReal( Amap_Obj_t * pObj ) { return Amap_Regular(pObj)->fPhase ^ Amap_IsComplement(pObj); }
static inline int Amap_ObjRefsTotal( Amap_Obj_t * pObj ) { return pObj->nFouts[0] + pObj->nFouts[1]; }
static inline Amap_Gat_t * Amap_LibGate( Amap_Lib_t * p, int i ) { return (Amap_Gat_t *)Vec_PtrEntry(p->vGates, i); }
static inline Amap_Nod_t * Amap_LibNod( Amap_Lib_t * p, int i ) { return p->pNodes + i; }
// returns pointer to the next cut (internal cuts only)
static inline Amap_Cut_t * Amap_ManCutNext( Amap_Cut_t * pCut )
{ return (Amap_Cut_t *)(((int *)pCut)+pCut->nFans+1); }
// returns pointer to the place of the next cut (temporary cuts only)
static inline Amap_Cut_t ** Amap_ManCutNextP( Amap_Cut_t * pCut )
{ return (Amap_Cut_t **)(((int *)pCut)+pCut->nFans+1); }
extern void Kit_DsdPrintFromTruth( unsigned * pTruth, int nVars );
////////////////////////////////////////////////////////////////////////
/// MACRO DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
// iterator over the primary inputs
#define Amap_ManForEachPi( p, pObj, i ) \
Vec_PtrForEachEntry( Amap_Obj_t *, p->vPis, pObj, i )
// iterator over the primary outputs
#define Amap_ManForEachPo( p, pObj, i ) \
Vec_PtrForEachEntry( Amap_Obj_t *, p->vPos, pObj, i )
// iterator over all objects, including those currently not used
#define Amap_ManForEachObj( p, pObj, i ) \
Vec_PtrForEachEntry( Amap_Obj_t *, p->vObjs, pObj, i ) if ( (pObj) == NULL ) {} else
// iterator over all nodes
#define Amap_ManForEachNode( p, pObj, i ) \
Vec_PtrForEachEntry( Amap_Obj_t *, p->vObjs, pObj, i ) if ( (pObj) == NULL || !Amap_ObjIsNode(pObj) ) {} else
// iterator through all gates of the library
#define Amap_LibForEachGate( pLib, pGate, i ) \
Vec_PtrForEachEntry( Amap_Gat_t *, pLib->vGates, pGate, i )
// iterator through all pins of the gate
#define Amap_GateForEachPin( pGate, pPin ) \
for ( pPin = pGate->Pins; pPin < pGate->Pins + pGate->nPins; pPin++ )
// iterator through all cuts of the node
#define Amap_NodeForEachCut( pNode, pCut, i ) \
for ( i = 0, pCut = (Amap_Cut_t *)pNode->pData; i < (int)pNode->nCuts; \
i++, pCut = Amap_ManCutNext(pCut) )
// iterator through all sets of one library node
#define Amap_LibNodeForEachSet( pNod, pSet ) \
for ( pSet = pNod->pSets; pSet; pSet = pSet->pNext )
// iterates through each fanin of the match
#define Amap_MatchForEachFaninCompl( p, pM, pFanin, fCompl, i ) \
for ( i = 0; i < (int)(pM)->pCut->nFans && \
((pFanin = Amap_ManObj((p), Abc_Lit2Var((pM)->pCut->Fans[Abc_Lit2Var((pM)->pSet->Ins[i])]))), 1) && \
((fCompl = Abc_LitIsCompl((pM)->pSet->Ins[i]) ^ Abc_LitIsCompl((pM)->pCut->Fans[Abc_Lit2Var((pM)->pSet->Ins[i])])), 1); \
i++ )
// iterates through each fanin of the match
#define Amap_MatchForEachFanin( p, pM, pFanin, i ) \
for ( i = 0; i < (int)(pM)->pCut->nFans && \
((pFanin = Amap_ManObj((p), Abc_Lit2Var((pM)->pCut->Fans[Abc_Lit2Var((pM)->pSet->Ins[i])]))), 1); \
i++ )
////////////////////////////////////////////////////////////////////////
/// FUNCTION DECLARATIONS ///
////////////////////////////////////////////////////////////////////////
/*=== amapCore.c ==========================================================*/
/*=== amapGraph.c ==========================================================*/
extern Amap_Obj_t * Amap_ManCreatePi( Amap_Man_t * p );
extern Amap_Obj_t * Amap_ManCreatePo( Amap_Man_t * p, Amap_Obj_t * pFan0 );
extern Amap_Obj_t * Amap_ManCreateAnd( Amap_Man_t * p, Amap_Obj_t * pFan0, Amap_Obj_t * pFan1 );
extern Amap_Obj_t * Amap_ManCreateXor( Amap_Man_t * p, Amap_Obj_t * pFan0, Amap_Obj_t * pFan1 );
extern Amap_Obj_t * Amap_ManCreateMux( Amap_Man_t * p, Amap_Obj_t * pFanC, Amap_Obj_t * pFan1, Amap_Obj_t * pFan0 );
extern void Amap_ManCreateChoice( Amap_Man_t * p, Amap_Obj_t * pObj );
extern void Amap_ManCreate( Amap_Man_t * p, Aig_Man_t * pAig );
/*=== amapLib.c ==========================================================*/
extern Amap_Lib_t * Amap_LibAlloc();
extern int Amap_LibNumPinsMax( Amap_Lib_t * p );
extern void Amap_LibWrite( FILE * pFile, Amap_Lib_t * pLib, int fPrintDsd );
extern Vec_Ptr_t * Amap_LibSelectGates( Amap_Lib_t * p, int fVerbose );
/*=== amapMan.c ==========================================================*/
extern Amap_Man_t * Amap_ManStart( int nNodes );
extern void Amap_ManStop( Amap_Man_t * p );
/*=== amapMatch.c ==========================================================*/
extern void Amap_ManMap( Amap_Man_t * p );
/*=== amapMerge.c ==========================================================*/
extern void Amap_ManMerge( Amap_Man_t * p );
/*=== amapOutput.c ==========================================================*/
extern Vec_Ptr_t * Amap_ManProduceMapped( Amap_Man_t * p );
/*=== amapParse.c ==========================================================*/
extern int Amap_LibParseEquations( Amap_Lib_t * p, int fVerbose );
/*=== amapPerm.c ==========================================================*/
/*=== amapRead.c ==========================================================*/
extern Amap_Lib_t * Amap_LibReadBuffer( char * pBuffer, int fVerbose );
extern Amap_Lib_t * Amap_LibReadFile( char * pFileName, int fVerbose );
/*=== amapRule.c ==========================================================*/
extern short * Amap_LibTableFindNode( Amap_Lib_t * p, int iFan0, int iFan1, int fXor );
extern void Amap_LibCreateRules( Amap_Lib_t * p, int fVeryVerbose );
/*=== amapUniq.c ==========================================================*/
extern int Amap_LibFindNode( Amap_Lib_t * pLib, int iFan0, int iFan1, int fXor );
extern int Amap_LibFindMux( Amap_Lib_t * p, int iFan0, int iFan1, int iFan2 );
extern int Amap_LibCreateVar( Amap_Lib_t * p );
extern int Amap_LibCreateNode( Amap_Lib_t * p, int iFan0, int iFan1, int fXor );
extern int Amap_LibCreateMux( Amap_Lib_t * p, int iFan0, int iFan1, int iFan2 );
extern int ** Amap_LibLookupTableAlloc( Vec_Ptr_t * vVec, int fVerbose );
ABC_NAMESPACE_HEADER_END
#endif
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
////////////////////////////////////////////////////////////////////////
|
