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
|
/**CFile****************************************************************
FileName [mioFunc.c]
PackageName [MVSIS 1.3: Multi-valued logic synthesis system.]
Synopsis [File reading/writing for technology mapping.]
Author [MVSIS Group]
Affiliation [UC Berkeley]
Date [Ver. 1.0. Started - September 8, 2003.]
Revision [$Id: mioFunc.c,v 1.4 2004/06/28 14:20:25 alanmi Exp $]
***********************************************************************/
#include "mioInt.h"
#include "parse.h"
////////////////////////////////////////////////////////////////////////
/// DECLARATIONS ///
////////////////////////////////////////////////////////////////////////
// these symbols (and no other) can appear in the formulas
#define MIO_SYMB_AND '*'
#define MIO_SYMB_OR1 '+'
#define MIO_SYMB_OR2 '|'
#define MIO_SYMB_XOR '^'
#define MIO_SYMB_NOT '!'
#define MIO_SYMB_AFTNOT '\''
#define MIO_SYMB_OPEN '('
#define MIO_SYMB_CLOSE ')'
static int Mio_GateParseFormula( Mio_Gate_t * pGate );
static int Mio_GateCollectNames( char * pFormula, char * pPinNames[] );
////////////////////////////////////////////////////////////////////////
/// FUNCTION DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
/**Function*************************************************************
Synopsis [Deriving the functionality of the gates.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Mio_LibraryParseFormulas( Mio_Library_t * pLib )
{
Mio_Gate_t * pGate;
// count the gates
pLib->nGates = 0;
Mio_LibraryForEachGate( pLib, pGate )
pLib->nGates++;
// start a temporary BDD manager
pLib->dd = Cudd_Init( 20, 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
// introduce ZDD variables
Cudd_zddVarsFromBddVars( pLib->dd, 2 );
// for each gate, derive its function
Mio_LibraryForEachGate( pLib, pGate )
if ( Mio_GateParseFormula( pGate ) )
return 1;
return 0;
}
/**Function*************************************************************
Synopsis [Deriving the functionality of the gates.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Mio_GateParseFormula( Mio_Gate_t * pGate )
{
DdManager * dd = pGate->pLib->dd;
char * pPinNames[100];
char * pPinNamesCopy[100];
Mio_Pin_t * pPin, ** ppPin;
int nPins, iPin, i;
// set the maximum delay of the gate; count pins
pGate->dDelayMax = 0.0;
nPins = 0;
Mio_GateForEachPin( pGate, pPin )
{
// set the maximum delay of the gate
if ( pGate->dDelayMax < pPin->dDelayBlockMax )
pGate->dDelayMax = pPin->dDelayBlockMax;
// count the pin
nPins++;
}
// check for the gate with const function
if ( nPins == 0 )
{
if ( strcmp( pGate->pForm, MIO_STRING_CONST0 ) == 0 )
{
pGate->bFunc = b0;
pGate->pSop = Abc_SopRegister( pGate->pLib->pMmFlex, " 0\n" );
pGate->pLib->pGate0 = pGate;
}
else if ( strcmp( pGate->pForm, MIO_STRING_CONST1 ) == 0 )
{
pGate->bFunc = b1;
pGate->pSop = Abc_SopRegister( pGate->pLib->pMmFlex, " 1\n" );
pGate->pLib->pGate1 = pGate;
}
else
{
printf( "Cannot parse formula \"%s\" of gate \"%s\".\n", pGate->pForm, pGate->pName );
return 1;
}
Cudd_Ref( pGate->bFunc );
return 0;
}
// collect the names as they appear in the formula
nPins = Mio_GateCollectNames( pGate->pForm, pPinNames );
if ( nPins == 0 )
{
printf( "Cannot read formula \"%s\" of gate \"%s\".\n", pGate->pForm, pGate->pName );
return 1;
}
// set the number of inputs
pGate->nInputs = nPins;
// consider the case when all the pins have identical pin info
if ( strcmp( pGate->pPins->pName, "*" ) == 0 )
{
// get the topmost (generic) pin
pPin = pGate->pPins;
FREE( pPin->pName );
// create individual pins from the generic pin
ppPin = &pPin->pNext;
for ( i = 1; i < nPins; i++ )
{
// get the new pin
*ppPin = Mio_PinDup( pPin );
// set its name
(*ppPin)->pName = pPinNames[i];
// prepare the next place in the list
ppPin = &((*ppPin)->pNext);
}
*ppPin = NULL;
// set the name of the topmost pin
pPin->pName = pPinNames[0];
}
else
{
// reorder the variable names to appear the save way as the pins
iPin = 0;
Mio_GateForEachPin( pGate, pPin )
{
// find the pin with the name pPin->pName
for ( i = 0; i < nPins; i++ )
{
if ( pPinNames[i] && strcmp( pPinNames[i], pPin->pName ) == 0 )
{
// free pPinNames[i] because it is already available as pPin->pName
// setting pPinNames[i] to NULL is useful to make sure that
// this name is not assigned to two pins in the list
FREE( pPinNames[i] );
pPinNamesCopy[iPin++] = pPin->pName;
break;
}
if ( i == nPins )
{
printf( "Cannot find pin name \"%s\" in the formula \"%s\" of gate \"%s\".\n",
pPin->pName, pGate->pForm, pGate->pName );
return 1;
}
}
}
// check for the remaining names
for ( i = 0; i < nPins; i++ )
if ( pPinNames[i] )
{
printf( "Name \"%s\" appears in the formula \"%s\" of gate \"%s\" but there is no such pin.\n",
pPinNames[i], pGate->pForm, pGate->pName );
return 1;
}
// copy the names back
memcpy( pPinNames, pPinNamesCopy, nPins * sizeof(char *) );
}
// expand the manager if necessary
if ( dd->size < nPins )
{
Cudd_Quit( dd );
dd = Cudd_Init( nPins + 10, 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
Cudd_zddVarsFromBddVars( dd, 2 );
}
// derive the formula as the BDD
pGate->bFunc = Parse_FormulaParser( stdout, pGate->pForm, nPins, 0, pPinNames, dd, dd->vars );
Cudd_Ref( pGate->bFunc );
// derive the cover (SOP)
pGate->pSop = Abc_ConvertBddToSop( pGate->pLib->pMmFlex, dd, pGate->bFunc, pGate->bFunc, nPins, 0, pGate->pLib->vCube, -1 );
return 0;
}
/**Function*************************************************************
Synopsis [Collect the pin names in the formula.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Mio_GateCollectNames( char * pFormula, char * pPinNames[] )
{
char Buffer[1000];
char * pTemp;
int nPins, i;
// save the formula as it was
strcpy( Buffer, pFormula );
// remove the non-name symbols
for ( pTemp = Buffer; *pTemp; pTemp++ )
if ( *pTemp == MIO_SYMB_AND || *pTemp == MIO_SYMB_OR1 || *pTemp == MIO_SYMB_OR2
|| *pTemp == MIO_SYMB_XOR || *pTemp == MIO_SYMB_NOT || *pTemp == MIO_SYMB_OPEN
|| *pTemp == MIO_SYMB_CLOSE || *pTemp == MIO_SYMB_AFTNOT )
*pTemp = ' ';
// save the names
nPins = 0;
pTemp = strtok( Buffer, " " );
while ( pTemp )
{
for ( i = 0; i < nPins; i++ )
if ( strcmp( pTemp, pPinNames[i] ) == 0 )
break;
if ( i == nPins )
{ // cannot find this name; save it
pPinNames[nPins++] = Extra_UtilStrsav(pTemp);
}
// get the next name
pTemp = strtok( NULL, " " );
}
return nPins;
}
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
////////////////////////////////////////////////////////////////////////
|
