luke
/
abc
mirror of https://github.com/YosysHQ/abc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
abc/src/misc/util/abc_global.h

562 lines
21 KiB
C
Raw Blame History

/**CFile****************************************************************
FileName [abc_global.h]
SystemName [ABC: Logic synthesis and verification system.]
PackageName [Global declarations.]
Synopsis [Global declarations.]
Author [Alan Mishchenko]
Affiliation [UC Berkeley]
Date [Ver. 1.0. Started - Jan 30, 2009.]
Revision [$Id: abc_global.h,v 1.00 2009/01/30 00:00:00 alanmi Exp $]
***********************************************************************/
#ifndef ABC__misc__util__abc_global_h
#define ABC__misc__util__abc_global_h
////////////////////////////////////////////////////////////////////////
/// INCLUDES ///
////////////////////////////////////////////////////////////////////////
#ifndef ABC_USE_BRIDGE
#define ABC_USE_BRIDGE
#endif
#ifdef _WIN32
#ifndef __MINGW32__
#define inline __inline // compatible with MS VS 6.0
#pragma warning(disable : 4152) // warning C4152: nonstandard extension, function/data pointer conversion in expression
#pragma warning(disable : 4200) // warning C4200: nonstandard extension used : zero-sized array in struct/union
#pragma warning(disable : 4244) // warning C4244: '+=' : conversion from 'int ' to 'unsigned short ', possible loss of data
#pragma warning(disable : 4514) // warning C4514: 'Vec_StrPop' : unreferenced inline function has been removed
#pragma warning(disable : 4710) // warning C4710: function 'Vec_PtrGrow' not inlined
//#pragma warning( disable : 4273 )
#endif
#endif
#ifdef WIN32
#ifdef WIN32_NO_DLL
#define ABC_DLLEXPORT
#define ABC_DLLIMPORT
#else
#define ABC_DLLEXPORT __declspec(dllexport)
#define ABC_DLLIMPORT __declspec(dllimport)
#endif
#else /* defined(WIN32) */
#define ABC_DLLIMPORT
#endif /* defined(WIN32) */
#ifndef ABC_DLL
#define ABC_DLL ABC_DLLIMPORT
#endif
#if !defined(___unused)
#if defined(__GNUC__)
#define ___unused __attribute__ ((__unused__))
#else
#define ___unused
#endif
#endif
/*
#ifdef __cplusplus
#error "C++ code"
#else
#error "C code"
#endif
*/
#include <time.h>
#include <stdarg.h>
#include <stdlib.h>
#include <assert.h>
#include <stdio.h>
#include <string.h>
// catch memory leaks in Visual Studio
#ifdef WIN32
#ifdef _DEBUG
#define _CRTDBG_MAP_ALLOC
#include <crtdbg.h>
#endif
#endif
#include "abc_namespaces.h"
////////////////////////////////////////////////////////////////////////
/// PARAMETERS ///
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
/// BASIC TYPES ///
////////////////////////////////////////////////////////////////////////
#ifdef ABC_USE_STDINT_H
// If there is stdint.h, assume this is a reasonably-modern platform that
// would also have stddef.h and limits.h
#include <limits.h>
#include <stddef.h>
#include <stdint.h>
#if UINTPTR_MAX == 0xFFFFFFFFFFFFFFFF
#define SIZEOF_VOID_P 8
#ifdef _WIN32
#define NT64
#else
#define LIN64
#endif
#elif UINTPTR_MAX == 0xFFFFFFFF
#define SIZEOF_VOID_P 4
#ifdef _WIN32
#define NT
#else
#define LIN
#endif
#else
#error unsupported platform
#endif
#if ULONG_MAX == 0xFFFFFFFFFFFFFFFF
#define SIZEOF_LONG 8
#elif ULONG_MAX == 0xFFFFFFFF
#define SIZEOF_LONG 4
#else
#error unsupported platform
#endif
#if UINT_MAX == 0xFFFFFFFFFFFFFFFF
#define SIZEOF_INT 8
#elif UINT_MAX == 0xFFFFFFFF
#define SIZEOF_INT 4
#else
#error unsupported platform
#endif
#endif
ABC_NAMESPACE_HEADER_START
/**
* Pointer difference type; replacement for ptrdiff_t.
* This is a signed integral type that is the same size as a pointer.
* NOTE: This type may be different sizes on different platforms.
*/
#if defined(__ccdoc__)
typedef platform_dependent_type ABC_PTRDIFF_T;
#elif defined(ABC_USE_STDINT_H)
typedef ptrdiff_t ABC_PTRDIFF_T;
#elif defined(LIN64)
typedef long ABC_PTRDIFF_T;
#elif defined(NT64)
typedef long long ABC_PTRDIFF_T;
#elif defined(NT) || defined(LIN) || defined(WIN32)
typedef int ABC_PTRDIFF_T;
#else
#error unknown platform
#endif /* defined(PLATFORM) */
/**
* Unsigned integral type that can contain a pointer.
* This is an unsigned integral type that is the same size as a pointer.
* NOTE: This type may be different sizes on different platforms.
*/
#if defined(__ccdoc__)
typedef platform_dependent_type ABC_PTRUINT_T;
#elif defined(ABC_USE_STDINT_H)
typedef uintptr_t ABC_PTRUINT_T;
#elif defined(LIN64)
typedef unsigned long ABC_PTRUINT_T;
#elif defined(NT64)
typedef unsigned long long ABC_PTRUINT_T;
#elif defined(NT) || defined(LIN) || defined(WIN32)
typedef unsigned int ABC_PTRUINT_T;
#else
#error unknown platform
#endif /* defined(PLATFORM) */
/**
* Signed integral type that can contain a pointer.
* This is a signed integral type that is the same size as a pointer.
* NOTE: This type may be different sizes on different platforms.
*/
#if defined(__ccdoc__)
typedef platform_dependent_type ABC_PTRINT_T;
#elif defined(ABC_USE_STDINT_H)
typedef intptr_t ABC_PTRINT_T;
#elif defined(LIN64)
typedef long ABC_PTRINT_T;
#elif defined(NT64)
typedef long long ABC_PTRINT_T;
#elif defined(NT) || defined(LIN) || defined(WIN32)
typedef int ABC_PTRINT_T;
#else
#error unknown platform
#endif /* defined(PLATFORM) */
/**
* 64-bit signed integral type.
*/
#if defined(__ccdoc__)
typedef platform_dependent_type ABC_INT64_T;
#elif defined(ABC_USE_STDINT_H)
typedef int64_t ABC_INT64_T;
#elif defined(LIN64)
typedef long ABC_INT64_T;
#elif defined(NT64) || defined(LIN)
typedef long long ABC_INT64_T;
#elif defined(WIN32) || defined(NT)
typedef signed __int64 ABC_INT64_T;
#else
#error unknown platform
#endif /* defined(PLATFORM) */
/**
* 64-bit unsigned integral type.
*/
#if defined(__ccdoc__)
typedef platform_dependent_type ABC_UINT64_T;
#elif defined(ABC_USE_STDINT_H)
typedef uint64_t ABC_UINT64_T;
#elif defined(LIN64)
typedef unsigned long ABC_UINT64_T;
#elif defined(NT64) || defined(LIN)
typedef unsigned long long ABC_UINT64_T;
#elif defined(WIN32) || defined(NT)
typedef unsigned __int64 ABC_UINT64_T;
#else
#error unknown platform
#endif /* defined(PLATFORM) */
#ifdef LIN
#define ABC_CONST(number) number ## ULL
#else // LIN64 and windows
#define ABC_CONST(number) number
#endif
typedef ABC_UINT64_T word;
typedef ABC_INT64_T iword;
////////////////////////////////////////////////////////////////////////
/// MACRO DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
#define ABC_INFINITY (1000000000)
#define ABC_SWAP(Type, a, b) { Type t = a; a = b; b = t; }
#define ABC_PRT(a,t) (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%9.2f sec\n", 1.0*((double)(t))/((double)CLOCKS_PER_SEC)))
#define ABC_PRTr(a,t) (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%9.2f sec\r", 1.0*((double)(t))/((double)CLOCKS_PER_SEC)))
#define ABC_PRTn(a,t) (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%9.2f sec ", 1.0*((double)(t))/((double)CLOCKS_PER_SEC)))
#define ABC_PRTP(a,t,T) (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%9.2f sec (%6.2f %%)\n", 1.0*((double)(t))/((double)CLOCKS_PER_SEC), ((double)(T))? 100.0*((double)(t))/((double)(T)) : 0.0))
#define ABC_PRM(a,f) (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%10.3f MB\n", 1.0*((double)(f))/(1<<20)))
#define ABC_PRMr(a,f) (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%10.3f MB\r", 1.0*((double)(f))/(1<<20)))
#define ABC_PRMn(a,f) (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%10.3f MB ", 1.0*((double)(f))/(1<<20)))
#define ABC_PRMP(a,f,F) (Abc_Print(1, "%s =", (a)), Abc_Print(1, "%10.3f MB (%6.2f %%)\n", (1.0*((double)(f))/(1<<20)), (((double)(F))? 100.0*((double)(f))/((double)(F)) : 0.0) ) )
#define ABC_ALLOC(type, num) ((type *) malloc(sizeof(type) * (size_t)(num)))
#define ABC_CALLOC(type, num) ((type *) calloc((size_t)(num), sizeof(type)))
#define ABC_FALLOC(type, num) ((type *) memset(malloc(sizeof(type) * (size_t)(num)), 0xff, sizeof(type) * (size_t)(num)))
#define ABC_FREE(obj) ((obj) ? (free((char *) (obj)), (obj) = 0) : 0)
#define ABC_REALLOC(type, obj, num) \
((obj) ? ((type *) realloc((char *)(obj), sizeof(type) * (size_t)(num))) : \
((type *) malloc(sizeof(type) * (size_t)(num))))
static inline int Abc_AbsInt( int a ) { return a < 0 ? -a : a; }
static inline int Abc_MaxInt( int a, int b ) { return a > b ? a : b; }
static inline int Abc_MinInt( int a, int b ) { return a < b ? a : b; }
static inline word Abc_MaxWord( word a, word b ) { return a > b ? a : b; }
static inline word Abc_MinWord( word a, word b ) { return a < b ? a : b; }
static inline float Abc_AbsFloat( float a ) { return a < 0 ? -a : a; }
static inline float Abc_MaxFloat( float a, float b ) { return a > b ? a : b; }
static inline float Abc_MinFloat( float a, float b ) { return a < b ? a : b; }
static inline double Abc_AbsDouble( double a ) { return a < 0 ? -a : a; }
static inline double Abc_MaxDouble( double a, double b ) { return a > b ? a : b; }
static inline double Abc_MinDouble( double a, double b ) { return a < b ? a : b; }
static inline int Abc_Float2Int( float Val ) { union { int x; float y; } v; v.y = Val; return v.x; }
static inline float Abc_Int2Float( int Num ) { union { int x; float y; } v; v.x = Num; return v.y; }
static inline word Abc_Dbl2Word( double Dbl ) { union { word x; double y; } v; v.y = Dbl; return v.x; }
static inline double Abc_Word2Dbl( word Num ) { union { word x; double y; } v; v.x = Num; return v.y; }
static inline int Abc_Base2Log( unsigned n ) { int r; if ( n < 2 ) return (int)n; for ( r = 0, n--; n; n >>= 1, r++ ) {}; return r; }
static inline int Abc_Base10Log( unsigned n ) { int r; if ( n < 2 ) return (int)n; for ( r = 0, n--; n; n /= 10, r++ ) {}; return r; }
static inline int Abc_Base16Log( unsigned n ) { int r; if ( n < 2 ) return (int)n; for ( r = 0, n--; n; n /= 16, r++ ) {}; return r; }
static inline char * Abc_UtilStrsav( char * s ) { return s ? strcpy(ABC_ALLOC(char, strlen(s)+1), s) : NULL; }
static inline char * Abc_UtilStrsavTwo( char * s, char * a ){ char * r; if (!a) return Abc_UtilStrsav(s); r = ABC_ALLOC(char, strlen(s)+strlen(a)+1); sprintf(r, "%s%s", s, a ); return r; }
static inline char * Abc_UtilStrsavNum( char * s, int n ) { char * r; if (!s) return NULL; r = ABC_ALLOC(char, strlen(s)+12+1); sprintf(r, "%s%d", s, n ); return r; }
static inline int Abc_BitByteNum( int nBits ) { return (nBits>>3) + ((nBits&7) > 0); }
static inline int Abc_BitWordNum( int nBits ) { return (nBits>>5) + ((nBits&31) > 0); }
static inline int Abc_Bit6WordNum( int nBits ) { return (nBits>>6) + ((nBits&63) > 0); }
static inline int Abc_TruthByteNum( int nVars ) { return nVars <= 3 ? 1 : (1 << (nVars - 3)); }
static inline int Abc_TruthWordNum( int nVars ) { return nVars <= 5 ? 1 : (1 << (nVars - 5)); }
static inline int Abc_Truth6WordNum( int nVars ) { return nVars <= 6 ? 1 : (1 << (nVars - 6)); }
static inline int Abc_InfoHasBit( unsigned * p, int i ) { return (p[(i)>>5] & (unsigned)(1<<((i) & 31))) > 0; }
static inline void Abc_InfoSetBit( unsigned * p, int i ) { p[(i)>>5] |= (unsigned)(1<<((i) & 31)); }
static inline void Abc_InfoXorBit( unsigned * p, int i ) { p[(i)>>5] ^= (unsigned)(1<<((i) & 31)); }
static inline unsigned Abc_InfoMask( int nVar ) { return (~(unsigned)0) >> (32-nVar); }
static inline int Abc_Var2Lit( int Var, int c ) { assert(Var >= 0 && !(c >> 1)); return Var + Var + c; }
static inline int Abc_Lit2Var( int Lit ) { assert(Lit >= 0); return Lit >> 1; }
static inline int Abc_LitIsCompl( int Lit ) { assert(Lit >= 0); return Lit & 1; }
static inline int Abc_LitNot( int Lit ) { assert(Lit >= 0); return Lit ^ 1; }
static inline int Abc_LitNotCond( int Lit, int c ) { assert(Lit >= 0); return Lit ^ (int)(c > 0); }
static inline int Abc_LitRegular( int Lit ) { assert(Lit >= 0); return Lit & ~01; }
static inline int Abc_Lit2LitV( int * pMap, int Lit ) { assert(Lit >= 0); return Abc_Var2Lit( pMap[Abc_Lit2Var(Lit)], Abc_LitIsCompl(Lit) ); }
static inline int Abc_Lit2LitL( int * pMap, int Lit ) { assert(Lit >= 0); return Abc_LitNotCond( pMap[Abc_Lit2Var(Lit)], Abc_LitIsCompl(Lit) ); }
static inline int Abc_Ptr2Int( void * p ) { return (int)(ABC_PTRINT_T)p; }
static inline void * Abc_Int2Ptr( int i ) { return (void *)(ABC_PTRINT_T)i; }
static inline word Abc_Ptr2Wrd( void * p ) { return (word)(ABC_PTRUINT_T)p; }
static inline void * Abc_Wrd2Ptr( word i ) { return (void *)(ABC_PTRUINT_T)i; }
static inline int Abc_Var2Lit2( int Var, int Att ) { assert(!(Att >> 2)); return (Var << 2) + Att; }
static inline int Abc_Lit2Var2( int Lit ) { assert(Lit >= 0); return Lit >> 2; }
static inline int Abc_Lit2Att2( int Lit ) { assert(Lit >= 0); return Lit & 3; }
static inline int Abc_Var2Lit3( int Var, int Att ) { assert(!(Att >> 3)); return (Var << 3) + Att; }
static inline int Abc_Lit2Var3( int Lit ) { assert(Lit >= 0); return Lit >> 3; }
static inline int Abc_Lit2Att3( int Lit ) { assert(Lit >= 0); return Lit & 7; }
static inline int Abc_Var2Lit4( int Var, int Att ) { assert(!(Att >> 4)); return (Var << 4) + Att; }
static inline int Abc_Lit2Var4( int Lit ) { assert(Lit >= 0); return Lit >> 4; }
static inline int Abc_Lit2Att4( int Lit ) { assert(Lit >= 0); return Lit & 15; }
typedef ABC_INT64_T abctime;
// counting wall time
static inline abctime Abc_Clock()
{
#if defined(__APPLE__) && defined(__MACH__)
#define APPLE_MACH (__APPLE__ & __MACH__)
#else
#define APPLE_MACH 0
#endif
#if (defined(LIN) || defined(LIN64)) && !APPLE_MACH && !defined(__MINGW32__) && !defined(__wasm)
struct timespec ts;
if ( clock_gettime(CLOCK_MONOTONIC, &ts) < 0 )
return (abctime)-1;
abctime res = ((abctime) ts.tv_sec) * CLOCKS_PER_SEC;
res += (((abctime) ts.tv_nsec) * CLOCKS_PER_SEC) / 1000000000;
return res;
#else
return (abctime) clock();
#endif
}
// counting thread time
static inline abctime Abc_ThreadClock()
{
#if defined(__APPLE__) && defined(__MACH__)
#define APPLE_MACH (__APPLE__ & __MACH__)
#else
#define APPLE_MACH 0
#endif
#if (defined(LIN) || defined(LIN64)) && !APPLE_MACH && !defined(__MINGW32__) && !defined(__wasm)
struct timespec ts;
if ( clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts) < 0 )
return (abctime)-1;
abctime res = ((abctime) ts.tv_sec) * CLOCKS_PER_SEC;
res += (((abctime) ts.tv_nsec) * CLOCKS_PER_SEC) / 1000000000;
return res;
#else
return (abctime) clock();
#endif
}
// misc printing procedures
enum Abc_VerbLevel
{
ABC_PROMPT = -2,
ABC_ERROR = -1,
ABC_WARNING = 0,
ABC_STANDARD = 1,
ABC_VERBOSE = 2
};
#ifdef ABC_USE_BRIDGE
// bridge communication
#define BRIDGE_NETLIST 106
#define BRIDGE_ABS_NETLIST 107
extern int Gia_ManToBridgeText( FILE * pFile, int Size, unsigned char * pBuffer );
extern int Gia_ManToBridgeAbsNetlist( FILE * pFile, void * p, int pkg_type );
// string printing
extern char * vnsprintf(const char* format, va_list args);
extern char * nsprintf(const char* format, ...);
static inline void Abc_Print( int level, const char * format, ... )
{
extern ABC_DLL int Abc_FrameIsBridgeMode();
va_list args;
extern unsigned enable_dbg_outs;
if ( !enable_dbg_outs )
return;
if ( ! Abc_FrameIsBridgeMode() ){
if ( level == ABC_ERROR )
printf( "Error: " );
else if ( level == ABC_WARNING )
printf( "Warning: " );
}else{
if ( level == ABC_ERROR )
Gia_ManToBridgeText( stdout, (int)strlen("Error: "), (unsigned char*)"Error: " );
else if ( level == ABC_WARNING )
Gia_ManToBridgeText( stdout, (int)strlen("Warning: "), (unsigned char*)"Warning: " );
}
va_start( args, format );
if ( Abc_FrameIsBridgeMode() )
{
char * tmp = vnsprintf( format, args );
Gia_ManToBridgeText( stdout, (int)strlen(tmp), (unsigned char*)tmp );
free( tmp );
}
else
vprintf( format, args );
va_end( args );
}
#else
static inline void Abc_Print( int level, const char * format, ... )
{
va_list args;
va_start( args, format );
if ( level == ABC_ERROR )
printf( "Error: " );
else if ( level == ABC_WARNING )
printf( "Warning: " );
vprintf( format, args );
va_end( args );
}
#endif
static inline void Abc_PrintInt( int i )
{
double v3 = (double)i/1000;
double v6 = (double)i/1000000;
Abc_Print( 1, " " );
if ( i > -1000 && i < 1000 )
Abc_Print( 1, " %4d", i );
else if ( v3 > -9.995 && v3 < 9.995 )
Abc_Print( 1, "%4.2fk", v3 );
else if ( v3 > -99.95 && v3 < 99.95 )
Abc_Print( 1, "%4.1fk", v3 );
else if ( v3 > -999.5 && v3 < 999.5 )
Abc_Print( 1, "%4.0fk", v3 );
else if ( v6 > -9.995 && v6 < 9.995 )
Abc_Print( 1, "%4.2fm", v6 );
else if ( v6 > -99.95 && v6 < 99.95 )
Abc_Print( 1, "%4.1fm", v6 );
else if ( v6 > -999.5 && v6 < 999.5 )
Abc_Print( 1, "%4.0fm", v6 );
}
static inline void Abc_PrintTime( int level, const char * pStr, abctime time )
{
ABC_PRT( pStr, time );
}
static inline void Abc_PrintTimeP( int level, const char * pStr, abctime time, abctime Time )
{
ABC_PRTP( pStr, time, Time );
}
static inline void Abc_PrintMemoryP( int level, const char * pStr, int mem, int Mem )
{
ABC_PRMP( pStr, mem, Mem );
}
// Returns the next prime >= p
static inline int Abc_PrimeCudd( unsigned int p )
{
int i,pn;
p--;
do {
p++;
if (p&1)
{
pn = 1;
i = 3;
while ((unsigned) (i * i) <= p)
{
if (p % (unsigned)i == 0) {
pn = 0;
break;
}
i += 2;
}
}
else
pn = 0;
} while (!pn);
return (int)(p);
} // end of Cudd_Prime
// the returned buffer has 32 unused bytes at the end, filled with zeros
static inline void * Abc_FileReadContents( char * pFileName, int * pnFileSize )
{
int RetValue, nFileSize;
char * pBuffer;
FILE * pFile = fopen( pFileName, "rb" );
if ( pFile == NULL )
return NULL;
// get the file size, in bytes
fseek( pFile, 0, SEEK_END );
nFileSize = ftell( pFile );
if ( pnFileSize )
*pnFileSize = nFileSize;
rewind( pFile );
// load the contents of the file into memory
pBuffer = ABC_ALLOC( char, nFileSize + 32 );
RetValue = fread( pBuffer, 1, nFileSize, pFile );
memset( pBuffer + nFileSize, 0, 32 );
assert( RetValue == nFileSize );
fclose( pFile );
return (void *)pBuffer;
}
static inline void Abc_ReverseOrder( int * pA, int nA )
{
int i;
for ( i = 0; i < nA/2; i++ )
ABC_SWAP( int, pA[i], pA[nA-1-i] );
}
// sorting
extern void Abc_MergeSort( int * pInput, int nSize );
extern int * Abc_MergeSortCost( int * pCosts, int nSize );
extern void Abc_MergeSortCost2( int * pInput, int nSize, int * pCost );
extern void Abc_MergeSortCost2Reverse( int * pInput, int nSize, int * pCost );
extern void Abc_QuickSort1( word * pData, int nSize, int fDecrease );
extern void Abc_QuickSort2( word * pData, int nSize, int fDecrease );
extern void Abc_QuickSort3( word * pData, int nSize, int fDecrease );
extern void Abc_QuickSortCostData( int * pCosts, int nSize, int fDecrease, word * pData, int * pResult );
extern int * Abc_QuickSortCost( int * pCosts, int nSize, int fDecrease );
extern unsigned Abc_Random( int fReset );
extern word Abc_RandomW( int fReset );
// pthreads
extern void Util_ProcessThreads( int (*pUserFunc)(void *), void * vData, int nProcs, int TimeOut, int fVerbose );
ABC_NAMESPACE_HEADER_END
#endif
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
////////////////////////////////////////////////////////////////////////
Reference in New Issue View Git Blame Copy Permalink