ABC: A System for Sequential Synthesis and Verification
 
Loading...
Searching...
No Matches
Functions
ifLibLut.c File Reference
#include "if.h"
#include "base/main/mainInt.h"
Include dependency graph for ifLibLut.c:

Go to the source code of this file.

Functions

ABC_NAMESPACE_IMPL_START If_LibLut_t * If_LibLutReadString (char *pStr)
 DECLARATIONS ///.
 
int Abc_FrameSetLutLibrary (Abc_Frame_t *pAbc, char *pLutLibString)
 
int Abc_FrameSetLutLibraryTest (Abc_Frame_t *pAbc)
 
If_LibLut_t * If_LibLutRead (char *FileName)
 
If_LibLut_t * If_LibLutDup (If_LibLut_t *p)
 
void If_LibLutFree (If_LibLut_t *pLutLib)
 
void If_LibLutPrint (If_LibLut_t *pLutLib)
 
int If_LibLutDelaysAreDiscrete (If_LibLut_t *pLutLib)
 
int If_LibLutDelaysAreDifferent (If_LibLut_t *pLutLib)
 
If_LibLut_t * If_LibLutSetSimple (int nLutSize)
 
float If_LibLutFastestPinDelay (If_LibLut_t *p)
 
float If_LibLutSlowestPinDelay (If_LibLut_t *p)
 

Function Documentation

◆ Abc_FrameSetLutLibrary()

int Abc_FrameSetLutLibrary ( Abc_Frame_t * pAbc,
char * pLutLibString )

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

Synopsis [Sets the library associated with the string.]

Description []

SideEffects []

SeeAlso []

Definition at line 170 of file ifLibLut.c.

171{
172 If_LibLut_t * pLib = If_LibLutReadString( pLutLibString );
173 if ( pLib == NULL )
174 {
175 fprintf( stdout, "Reading LUT library from string has failed.\n" );
176 return 0;
177 }
178 // replace the current library
179 If_LibLutFree( (If_LibLut_t *)Abc_FrameReadLibLut() );
180 Abc_FrameSetLibLut( pLib );
181 return 1;
182}
Abc_FrameReadLibLut
ABC_DLL void * Abc_FrameReadLibLut()
Definition mainFrame.c:57
Abc_FrameSetLibLut
ABC_DLL void Abc_FrameSetLibLut(void *pLib)
Definition mainFrame.c:93
If_LibLutReadString
ABC_NAMESPACE_IMPL_START If_LibLut_t * If_LibLutReadString(char *pStr)
DECLARATIONS ///.
Definition ifLibLut.c:46
If_LibLutFree
void If_LibLutFree(If_LibLut_t *pLutLib)
Definition ifLibLut.c:332
If_LibLut_t
struct If_LibLut_t_ If_LibLut_t
Definition if.h:82
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Abc_FrameSetLutLibraryTest()

int Abc_FrameSetLutLibraryTest ( Abc_Frame_t * pAbc)

Definition at line 183 of file ifLibLut.c.

184{
185 char * pStr = "1 1.00 1000\n2 1.00 1000 1200\n3 1.00 1000 1200 1400\n4 1.00 1000 1200 1400 1600\n5 1.00 1000 1200 1400 1600 1800\n6 1.00 1000 1200 1400 1600 1800 2000\n\n\n";
186 Abc_FrameSetLutLibrary( pAbc, pStr );
187 return 1;
188}
Abc_FrameSetLutLibrary
int Abc_FrameSetLutLibrary(Abc_Frame_t *pAbc, char *pLutLibString)
Definition ifLibLut.c:170
Here is the call graph for this function:

◆ If_LibLutDelaysAreDifferent()

int If_LibLutDelaysAreDifferent ( If_LibLut_t * pLutLib)

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

Synopsis [Returns 1 if the delays are discrete.]

Description []

SideEffects []

SeeAlso []

Definition at line 407 of file ifLibLut.c.

408{
409 int i, k;
410 float Delay = pLutLib->pLutDelays[1][0];
411 if ( pLutLib->fVarPinDelays )
412 {
413 for ( i = 2; i <= pLutLib->LutMax; i++ )
414 for ( k = 0; k < i; k++ )
415 if ( pLutLib->pLutDelays[i][k] != Delay )
416 return 1;
417 }
418 else
419 {
420 for ( i = 2; i <= pLutLib->LutMax; i++ )
421 if ( pLutLib->pLutDelays[i][0] != Delay )
422 return 1;
423 }
424 return 0;
425}
If_LibLut_t_::fVarPinDelays
int fVarPinDelays
Definition if.h:191
If_LibLut_t_::LutMax
int LutMax
Definition if.h:190
If_LibLut_t_::pLutDelays
float pLutDelays[IF_MAX_LUTSIZE+1][IF_MAX_LUTSIZE+1]
Definition if.h:193

◆ If_LibLutDelaysAreDiscrete()

int If_LibLutDelaysAreDiscrete ( If_LibLut_t * pLutLib)

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

Synopsis [Returns 1 if the delays are discrete.]

Description []

SideEffects []

SeeAlso []

Definition at line 383 of file ifLibLut.c.

384{
385 float Delay;
386 int i;
387 for ( i = 1; i <= pLutLib->LutMax; i++ )
388 {
389 Delay = pLutLib->pLutDelays[i][0];
390 if ( ((float)((int)Delay)) != Delay )
391 return 0;
392 }
393 return 1;
394}

◆ If_LibLutDup()

If_LibLut_t * If_LibLutDup ( If_LibLut_t * p)

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

Synopsis [Duplicates the LUT library.]

Description []

SideEffects []

SeeAlso []

Definition at line 312 of file ifLibLut.c.

313{
314 If_LibLut_t * pNew;
315 pNew = ABC_ALLOC( If_LibLut_t, 1 );
316 *pNew = *p;
317 pNew->pName = Abc_UtilStrsav( pNew->pName );
318 return pNew;
319}
ABC_ALLOC
#define ABC_ALLOC(type, num)
Definition abc_global.h:264
p
Cube * p
Definition exorList.c:222
If_LibLut_t_::pName
char * pName
Definition if.h:189
Here is the caller graph for this function:

◆ If_LibLutFastestPinDelay()

float If_LibLutFastestPinDelay ( If_LibLut_t * p)

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

Synopsis [Gets the delay of the fastest pin.]

Description []

SideEffects []

SeeAlso []

Definition at line 478 of file ifLibLut.c.

479{
480 return !p? 1.0 : p->pLutDelays[p->LutMax][0];
481}

◆ If_LibLutFree()

void If_LibLutFree ( If_LibLut_t * pLutLib)

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

Synopsis [Frees the LUT library.]

Description []

SideEffects []

SeeAlso []

Definition at line 332 of file ifLibLut.c.

333{
334 if ( pLutLib == NULL )
335 return;
336 ABC_FREE( pLutLib->pName );
337 ABC_FREE( pLutLib );
338}
ABC_FREE
#define ABC_FREE(obj)
Definition abc_global.h:267
Here is the caller graph for this function:

◆ If_LibLutPrint()

void If_LibLutPrint ( If_LibLut_t * pLutLib)

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

Synopsis [Prints the LUT library.]

Description []

SideEffects []

SeeAlso []

Definition at line 352 of file ifLibLut.c.

353{
354 int i, k;
355 Abc_Print( 1, "# The area/delay of k-variable LUTs:\n" );
356 Abc_Print( 1, "# k area delay\n" );
357 if ( pLutLib->fVarPinDelays )
358 {
359 for ( i = 1; i <= pLutLib->LutMax; i++ )
360 {
361 Abc_Print( 1, "%d %7.2f ", i, pLutLib->pLutAreas[i] );
362 for ( k = 0; k < i; k++ )
363 Abc_Print( 1, " %7.2f", pLutLib->pLutDelays[i][k] );
364 Abc_Print( 1, "\n" );
365 }
366 }
367 else
368 for ( i = 1; i <= pLutLib->LutMax; i++ )
369 Abc_Print( 1, "%d %7.2f %7.2f\n", i, pLutLib->pLutAreas[i], pLutLib->pLutDelays[i][0] );
370}
If_LibLut_t_::pLutAreas
float pLutAreas[IF_MAX_LUTSIZE+1]
Definition if.h:192

◆ If_LibLutRead()

If_LibLut_t * If_LibLutRead ( char * FileName)

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

Synopsis [Reads the description of LUTs from the LUT library file.]

Description []

SideEffects []

SeeAlso []

Definition at line 202 of file ifLibLut.c.

203{
204 char pBuffer[1000], * pToken;
205 If_LibLut_t * p;
206 FILE * pFile;
207 int i, k;
208
209 pFile = fopen( FileName, "r" );
210 if ( pFile == NULL )
211 {
212 Abc_Print( -1, "Cannot open LUT library file \"%s\".\n", FileName );
213 return NULL;
214 }
215
216 p = ABC_ALLOC( If_LibLut_t, 1 );
217 memset( p, 0, sizeof(If_LibLut_t) );
218 p->pName = Abc_UtilStrsav( FileName );
219
220 i = 1;
221 while ( fgets( pBuffer, 1000, pFile ) != NULL )
222 {
223 pToken = strtok( pBuffer, " \t\n" );
224 if ( pToken == NULL )
225 continue;
226 if ( pToken[0] == '#' )
227 continue;
228 if ( i != atoi(pToken) )
229 {
230 Abc_Print( 1, "Error in the LUT library file \"%s\".\n", FileName );
231 ABC_FREE( p->pName );
232 ABC_FREE( p );
233 fclose( pFile );
234 return NULL;
235 }
236
237 // read area
238 pToken = strtok( NULL, " \t\n" );
239 p->pLutAreas[i] = (float)atof(pToken);
240
241 // read delays
242 k = 0;
243 while ( (pToken = strtok( NULL, " \t\n" )) )
244 p->pLutDelays[i][k++] = (float)atof(pToken);
245
246 // check for out-of-bound
247 if ( k > i )
248 {
249 ABC_FREE( p->pName );
250 ABC_FREE( p );
251 Abc_Print( 1, "LUT %d has too many pins (%d). Max allowed is %d.\n", i, k, i );
252 fclose( pFile );
253 return NULL;
254 }
255
256 // check if var delays are specified
257 if ( k > 1 )
258 p->fVarPinDelays = 1;
259
260 if ( i == IF_MAX_LUTSIZE )
261 {
262 ABC_FREE( p->pName );
263 ABC_FREE( p );
264 Abc_Print( 1, "Skipping LUTs of size more than %d.\n", i );
265 fclose( pFile );
266 return NULL;
267 }
268 i++;
269 }
270 p->LutMax = i-1;
271
272 // check the library
273 if ( p->fVarPinDelays )
274 {
275 for ( i = 1; i <= p->LutMax; i++ )
276 for ( k = 0; k < i; k++ )
277 {
278 if ( p->pLutDelays[i][k] <= 0.0 )
279 Abc_Print( 0, "Pin %d of LUT %d has delay %f. Pin delays should be non-negative numbers. Technology mapping may not work correctly.\n",
280 k, i, p->pLutDelays[i][k] );
281 if ( k && p->pLutDelays[i][k-1] > p->pLutDelays[i][k] )
282 Abc_Print( 0, "Pin %d of LUT %d has delay %f. Pin %d of LUT %d has delay %f. Pin delays should be in non-decreasing order. Technology mapping may not work correctly.\n",
283 k-1, i, p->pLutDelays[i][k-1],
284 k, i, p->pLutDelays[i][k] );
285 }
286 }
287 else
288 {
289 for ( i = 1; i <= p->LutMax; i++ )
290 {
291 if ( p->pLutDelays[i][0] <= 0.0 )
292 Abc_Print( 0, "LUT %d has delay %f. Pin delays should be non-negative numbers. Technology mapping may not work correctly.\n",
293 i, p->pLutDelays[i][0] );
294 }
295 }
296
297 fclose( pFile );
298 return p;
299}
IF_MAX_LUTSIZE
#define IF_MAX_LUTSIZE
INCLUDES ///.
Definition if.h:53
memset
char * memset()
strtok
char * strtok()
atof
double atof()
Here is the call graph for this function:

◆ If_LibLutReadString()

ABC_NAMESPACE_IMPL_START If_LibLut_t * If_LibLutReadString ( char * pStr)

DECLARATIONS ///.

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

FileName [ifLibLut.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [FPGA mapping based on priority cuts.]

Synopsis [LUT library.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - November 21, 2006.]

Revision [

Id
ifLibLut.c,v 1.00 2006/11/21 00:00:00 alanmi Exp

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

Synopsis [Reads the description of LUTs from the LUT library file.]

Description []

SideEffects []

SeeAlso []

Definition at line 46 of file ifLibLut.c.

47{
48 If_LibLut_t * p;
49 Vec_Ptr_t * vStrs;
50 char * pToken, * pBuffer, * pStrNew, * pStrMem;
51 int i, k, j;
52
53 if ( pStr == NULL || pStr[0] == 0 )
54 return NULL;
55
56 vStrs = Vec_PtrAlloc( 1000 );
57 pStrNew = pStrMem = Abc_UtilStrsav( pStr );
58 while ( *pStrNew )
59 {
60 Vec_PtrPush( vStrs, pStrNew );
61 while ( *pStrNew != '\n' )
62 pStrNew++;
63 while ( *pStrNew == '\n' )
64 *pStrNew++ = '\0';
65 }
66
67 p = ABC_ALLOC( If_LibLut_t, 1 );
68 memset( p, 0, sizeof(If_LibLut_t) );
69
70 i = 1;
71 //while ( fgets( pBuffer, 1000, pFile ) != NULL )
72 Vec_PtrForEachEntry( char *, vStrs, pBuffer, j )
73 {
74 if ( pBuffer[0] == 0 )
75 continue;
76 pToken = strtok( pBuffer, " \t\n" );
77 if ( pToken == NULL )
78 continue;
79 if ( pToken[0] == '#' )
80 continue;
81 if ( i != atoi(pToken) )
82 {
83 Abc_Print( 1, "Error in the LUT library string.\n" );
84 ABC_FREE( p->pName );
85 ABC_FREE( p );
86 ABC_FREE( pStrMem );
87 Vec_PtrFree( vStrs );
88 return NULL;
89 }
90
91 // read area
92 pToken = strtok( NULL, " \t\n" );
93 p->pLutAreas[i] = (float)atof(pToken);
94
95 // read delays
96 k = 0;
97 while ( (pToken = strtok( NULL, " \t\n" )) )
98 p->pLutDelays[i][k++] = (float)atof(pToken);
99
100 // check for out-of-bound
101 if ( k > i )
102 {
103 Abc_Print( 1, "LUT %d has too many pins (%d). Max allowed is %d.\n", i, k, i );
104 ABC_FREE( p->pName );
105 ABC_FREE( p );
106 ABC_FREE( pStrMem );
107 Vec_PtrFree( vStrs );
108 return NULL;
109 }
110
111 // check if var delays are specified
112 if ( k > 1 )
113 p->fVarPinDelays = 1;
114
115 if ( i == IF_MAX_LUTSIZE )
116 {
117 Abc_Print( 1, "Skipping LUTs of size more than %d.\n", i );
118 ABC_FREE( p->pName );
119 ABC_FREE( p );
120 ABC_FREE( pStrMem );
121 Vec_PtrFree( vStrs );
122 return NULL;
123 }
124 i++;
125 }
126 p->LutMax = i-1;
127
128 // check the library
129 if ( p->fVarPinDelays )
130 {
131 for ( i = 1; i <= p->LutMax; i++ )
132 for ( k = 0; k < i; k++ )
133 {
134 if ( p->pLutDelays[i][k] <= 0.0 )
135 Abc_Print( 0, "Pin %d of LUT %d has delay %f. Pin delays should be non-negative numbers. Technology mapping may not work correctly.\n",
136 k, i, p->pLutDelays[i][k] );
137 if ( k && p->pLutDelays[i][k-1] > p->pLutDelays[i][k] )
138 Abc_Print( 0, "Pin %d of LUT %d has delay %f. Pin %d of LUT %d has delay %f. Pin delays should be in non-decreasing order. Technology mapping may not work correctly.\n",
139 k-1, i, p->pLutDelays[i][k-1],
140 k, i, p->pLutDelays[i][k] );
141 }
142 }
143 else
144 {
145 for ( i = 1; i <= p->LutMax; i++ )
146 {
147 if ( p->pLutDelays[i][0] <= 0.0 )
148 Abc_Print( 0, "LUT %d has delay %f. Pin delays should be non-negative numbers. Technology mapping may not work correctly.\n",
149 i, p->pLutDelays[i][0] );
150 }
151 }
152
153 // cleanup
154 ABC_FREE( pStrMem );
155 Vec_PtrFree( vStrs );
156 return p;
157}
Vec_Ptr_t
typedefABC_NAMESPACE_HEADER_START struct Vec_Ptr_t_ Vec_Ptr_t
INCLUDES ///.
Definition vecPtr.h:42
Vec_PtrForEachEntry
#define Vec_PtrForEachEntry(Type, vVec, pEntry, i)
MACRO DEFINITIONS ///.
Definition vecPtr.h:55
Here is the call graph for this function:
Here is the caller graph for this function:

◆ If_LibLutSetSimple()

If_LibLut_t * If_LibLutSetSimple ( int nLutSize)

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

Synopsis [Sets simple LUT library.]

Description []

SideEffects []

SeeAlso []

Definition at line 438 of file ifLibLut.c.

439{
440 If_LibLut_t s_LutLib10= { "lutlib",10, 0, {0,1,1,1,1,1,1,1,1,1,1}, {{0},{1},{1},{1},{1},{1},{1},{1},{1},{1},{1}} };
441 If_LibLut_t s_LutLib9 = { "lutlib", 9, 0, {0,1,1,1,1,1,1,1,1,1}, {{0},{1},{1},{1},{1},{1},{1},{1},{1},{1}} };
442 If_LibLut_t s_LutLib8 = { "lutlib", 8, 0, {0,1,1,1,1,1,1,1,1}, {{0},{1},{1},{1},{1},{1},{1},{1},{1}} };
443 If_LibLut_t s_LutLib7 = { "lutlib", 7, 0, {0,1,1,1,1,1,1,1}, {{0},{1},{1},{1},{1},{1},{1},{1}} };
444 If_LibLut_t s_LutLib6 = { "lutlib", 6, 0, {0,1,1,1,1,1,1}, {{0},{1},{1},{1},{1},{1},{1}} };
445 If_LibLut_t s_LutLib5 = { "lutlib", 5, 0, {0,1,1,1,1,1}, {{0},{1},{1},{1},{1},{1}} };
446 If_LibLut_t s_LutLib4 = { "lutlib", 4, 0, {0,1,1,1,1}, {{0},{1},{1},{1},{1}} };
447 If_LibLut_t s_LutLib3 = { "lutlib", 3, 0, {0,1,1,1}, {{0},{1},{1},{1}} };
448 If_LibLut_t * pLutLib;
449 assert( nLutSize >= 3 && nLutSize <= 10 );
450 switch ( nLutSize )
451 {
452 case 3: pLutLib = &s_LutLib3; break;
453 case 4: pLutLib = &s_LutLib4; break;
454 case 5: pLutLib = &s_LutLib5; break;
455 case 6: pLutLib = &s_LutLib6; break;
456 case 7: pLutLib = &s_LutLib7; break;
457 case 8: pLutLib = &s_LutLib8; break;
458 case 9: pLutLib = &s_LutLib9; break;
459 case 10: pLutLib = &s_LutLib10; break;
460 default: pLutLib = NULL; break;
461 }
462 if ( pLutLib == NULL )
463 return NULL;
464 return If_LibLutDup(pLutLib);
465}
If_LibLutDup
If_LibLut_t * If_LibLutDup(If_LibLut_t *p)
Definition ifLibLut.c:312
assert
#define assert(ex)
Definition util_old.h:213
Here is the call graph for this function:

◆ If_LibLutSlowestPinDelay()

float If_LibLutSlowestPinDelay ( If_LibLut_t * p)

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

Synopsis [Gets the delay of the slowest pin.]

Description []

SideEffects []

SeeAlso []

Definition at line 494 of file ifLibLut.c.

495{
496 return !p? 1.0 : (p->fVarPinDelays? p->pLutDelays[p->LutMax][p->LutMax-1]: p->pLutDelays[p->LutMax][0]);
497}