PyMetis-0.90/0000755000175000017500000000000010662401137012650 5ustar andreasandreasPyMetis-0.90/src/0000755000175000017500000000000010662401136013436 5ustar andreasandreasPyMetis-0.90/src/gklib/0000755000175000017500000000000010662401137014527 5ustar andreasandreasPyMetis-0.90/src/gklib/GKlib.h0000640000175000017500000000233310662171744015675 0ustar andreasandreas/* * GKlib.h * * George's library of most frequently used routines * * $Id: GKlib.h 1430 2007-04-07 17:53:07Z karypis $ * */ #ifndef _GKLIB_H_ #define _GKLIB_H_ 1 #define GKMSPACE #if defined(_MSC_VER) #define __MSC__ #endif #if defined(__ICC) #define __ICC__ #endif #include /*!< This should be here, prior to the includes */ /************************************************************************* * Header file inclusion section **************************************************************************/ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #if defined(__WITHPCRE__) #include #else #include #endif #if defined(__OPENMP__) #include #endif #include #include #include #include #include #include #include #include #include #include #include #endif /* GKlib.h */ PyMetis-0.90/src/gklib/b64.c0000640000175000017500000000570010662171744015274 0ustar andreasandreas/*! \file b64.c \brief This file contains some simple 8bit-to-6bit encoding/deconding routines Most of these routines are outdated and should be converted using glibc's equivalent routines. \date Started 2/22/05 \author George \version\verbatim $Id: b64.c 1421 2007-04-06 14:37:41Z karypis $ \endverbatim */ #include #define B64OFFSET 48 /* This is the '0' number */ /****************************************************************************** * Encode 3 '8-bit' binary bytes as 4 '6-bit' characters *******************************************************************************/ void encodeblock(unsigned char *in, unsigned char *out) { out[0] = (in[0] >> 2); out[1] = (((in[0] & 0x03) << 4) | (in[1] >> 4)); out[2] = (((in[1] & 0x0f) << 2) | (in[2] >> 6)); out[3] = (in[2] & 0x3f); out[0] += B64OFFSET; out[1] += B64OFFSET; out[2] += B64OFFSET; out[3] += B64OFFSET; // printf("%c %c %c %c %2x %2x %2x %2x %2x %2x %2x\n", out[0], out[1], out[2], out[3], out[0], out[1], out[2], out[3], in[0], in[1], in[2]); } /****************************************************************************** * Decode 4 '6-bit' characters into 3 '8-bit' binary bytes *******************************************************************************/ void decodeblock(unsigned char *in, unsigned char *out) { in[0] -= B64OFFSET; in[1] -= B64OFFSET; in[2] -= B64OFFSET; in[3] -= B64OFFSET; out[0] = (in[0] << 2 | in[1] >> 4); out[1] = (in[1] << 4 | in[2] >> 2); out[2] = (in[2] << 6 | in[3]); } /****************************************************************************** * This function encodes an input array of bytes into a base64 encoding. Memory * for the output array is assumed to have been allocated by the calling program * and be sufficiently large. The output string is NULL terminated. *******************************************************************************/ void GKEncodeBase64(int nbytes, unsigned char *inbuffer, unsigned char *outbuffer) { int i, j; if (nbytes%3 != 0) gk_errexit(SIGERR, "GKEncodeBase64: Input buffer size should be a multiple of 3! (%d)\n", nbytes); for (j=0, i=0; i /*************************************************************************/ /*! Set the elements of an array to a specified value */ /*************************************************************************/ GK_SET(gk_cset, char) GK_SET(gk_iset, int) GK_SET(gk_fset, float) GK_SET(gk_dset, double) GK_SET(gk_idxset, gk_idx_t) /*************************************************************************/ /*! Set the elements of an array in increasing order */ /*************************************************************************/ GK_INCSET(gk_cincset, char) GK_INCSET(gk_iincset, int) GK_INCSET(gk_fincset, float) GK_INCSET(gk_dincset, double) GK_INCSET(gk_idxincset, gk_idx_t) /*************************************************************************/ /*! Return the index of the maximum element in a vector */ /*************************************************************************/ GK_ARGMAX(gk_cargmax, char) GK_ARGMAX(gk_iargmax, int) GK_ARGMAX(gk_fargmax, float) GK_ARGMAX(gk_dargmax, double) GK_ARGMAX(gk_idxargmax, gk_idx_t) /*************************************************************************/ /*! Return the index of the minimum element in a vector */ /*************************************************************************/ GK_ARGMIN(gk_cargmin, char) GK_ARGMIN(gk_iargmin, int) GK_ARGMIN(gk_fargmin, float) GK_ARGMIN(gk_dargmin, double) GK_ARGMIN(gk_idxargmin, gk_idx_t) /*************************************************************************/ /*! Return the index of the Kth largest element in a vector */ /*************************************************************************/ GK_ARGMAX_N(gk_cargmax_n, char, gk_ckv_t, gk_ckvmalloc, gk_dckvsort) GK_ARGMAX_N(gk_iargmax_n, int, gk_ikv_t, gk_ikvmalloc, gk_dikvsort) GK_ARGMAX_N(gk_fargmax_n, float, gk_fkv_t, gk_fkvmalloc, gk_dfkvsort) GK_ARGMAX_N(gk_dargmax_n, double, gk_dkv_t, gk_dkvmalloc, gk_ddkvsort) GK_ARGMAX_N(gk_idxargmax_n, gk_idx_t, gk_idxkv_t, gk_idxkvmalloc, gk_didxkvsort) /*************************************************************************/ /*! Sums the entries of an array */ /*************************************************************************/ GK_SUM(gk_csum, char, intmax_t) GK_SUM(gk_isum, int, intmax_t) GK_SUM(gk_fsum, float, float) GK_SUM(gk_dsum, double, double) GK_SUM(gk_idxsum, gk_idx_t, intmax_t) /*************************************************************************/ /*! Scales the elements of a vector by a constant */ /*************************************************************************/ GK_SCALE(gk_cscale, char) GK_SCALE(gk_iscale, int) GK_SCALE(gk_fscale, float) GK_SCALE(gk_dscale, double) GK_SCALE(gk_idxscale, gk_idx_t) /*************************************************************************/ /*! Computes the 2-norm of a vector */ /*************************************************************************/ GK_NORM2(gk_cnorm2, char, intmax_t) GK_NORM2(gk_inorm2, int, intmax_t) GK_NORM2(gk_fnorm2, float, float) GK_NORM2(gk_dnorm2, double, double) GK_NORM2(gk_idxnorm2, gk_idx_t, intmax_t) /*************************************************************************/ /*! Computes the dot-product of two vectors */ /*************************************************************************/ GK_DOT(gk_cdot, char, intmax_t) GK_DOT(gk_idot, int, intmax_t) GK_DOT(gk_fdot, float, float) GK_DOT(gk_ddot, double, double) GK_DOT(gk_idxdot, gk_idx_t, intmax_t) /*************************************************************************/ /*! Computes y = ax+y */ /*************************************************************************/ GK_AXPY(gk_caxpy, char) GK_AXPY(gk_iaxpy, int) GK_AXPY(gk_faxpy, float) GK_AXPY(gk_daxpy, double) GK_AXPY(gk_idxaxpy, gk_idx_t) PyMetis-0.90/src/gklib/dfkvkselect.c0000640000175000017500000000402210662171744017202 0ustar andreasandreas/*! \file dfkvkselect.c \brief Sorts only the largest k values \date Started 7/14/00 \author George \version\verbatim $Id: dfkvkselect.c 1421 2007-04-06 14:37:41Z karypis $\endverbatim */ #include /* Byte-wise swap two items of size SIZE. */ #define QSSWAP(a, b, stmp) do { stmp = (a); (a) = (b); (b) = stmp; } while (0) /****************************************************************************** * This function puts the 'topk' largest values in the beginning of the array *******************************************************************************/ int gk_dfkvkselect(int n, int topk, gk_fkv_t *cand) { int i, j, lo, hi, mid; gk_fkv_t pivot, stmp; if (n <= topk) return n; /* return if the array has fewer elements than we want */ for (lo=0, hi=n-1; hi-lo > 2;) { mid = lo + ((hi-lo) >> 1); /* select the pivot */ if (cand[mid].key > cand[lo].key) QSSWAP(cand[mid], cand[lo], stmp); if (cand[hi].key > cand[mid].key) QSSWAP(cand[mid], cand[hi], stmp); else goto jump_over; if (cand[mid].key > cand[lo].key) QSSWAP(cand[mid], cand[lo], stmp); jump_over:; pivot = cand[mid]; /* Here's the famous ``collapse the walls'' section of quicksort. */ for (i=lo+1, j=hi-1; i<=j;) { for (; cand[i].key > pivot.key; i++); for (; pivot.key > cand[j].key; j--); if (i < j) { QSSWAP (cand[i], cand[j], stmp); i++; j--; } else if (i == j) { i++; j--; } } if (i > topk) hi = i; else if (i < topk) lo = i; else break; } if (hi-lo == 2) { if (cand[lo].key < cand[lo+1].key) QSSWAP(cand[lo], cand[lo+1], stmp); } /* if (cand[lo].key < cand[hi].key) printf("Hmm Error: %d %d %d %f %f\n", i, lo, hi, cand[lo].key, cand[hi].key); for (i=topk; i cand[j].key) printf("Hmm Error: %d %d %f %f %d %d\n", i, j, cand[i].key, cand[j].key, lo, hi); } */ return topk; } PyMetis-0.90/src/gklib/dlmalloc.c0000640000175000017500000043071610662171744016501 0ustar andreasandreas/*! \file dlmalloc.c \brief Doug Lea's malloc library This version of malloc.c was adapted for ptmalloc3 by Wolfram Gloger . Therefore, some of the comments below do not apply for this modified version. However, it is the intention to keep differences to Doug Lea's original version minimal, hence the comments were mostly left unchanged. ----------------------------------------------------------------------- This is a version (aka dlmalloc) of malloc/free/realloc written by Doug Lea and released to the public domain, as explained at http://creativecommons.org/licenses/publicdomain. Send questions, comments, complaints, performance data, etc to dl@cs.oswego.edu * Version pre-2.8.4 Wed Mar 29 19:46:29 2006 (dl at gee) Note: There may be an updated version of this malloc obtainable at ftp://gee.cs.oswego.edu/pub/misc/malloc.c Check before installing! \version\verbatim $Id: dlmalloc.c 1421 2007-04-06 14:37:41Z karypis $ \endverbatim */ #include "gk_dlmalloc.h" /*------------------------------ internal #includes ---------------------- */ #ifdef WIN32 #pragma warning( disable : 4146 ) /* no "unsigned" warnings */ #endif /* WIN32 */ #include /* for printing in malloc_stats */ #ifndef LACKS_ERRNO_H #include /* for MALLOC_FAILURE_ACTION */ #endif /* LACKS_ERRNO_H */ #if FOOTERS #include /* for magic initialization */ #endif /* FOOTERS */ #ifndef LACKS_STDLIB_H #include /* for abort() */ #endif /* LACKS_STDLIB_H */ #ifdef DEBUG #if ABORT_ON_ASSERT_FAILURE #define assert(x) if(!(x)) ABORT #else /* ABORT_ON_ASSERT_FAILURE */ #include #endif /* ABORT_ON_ASSERT_FAILURE */ #else /* DEBUG */ #define assert(x) #endif /* DEBUG */ #ifndef LACKS_STRING_H #include /* for memset etc */ #endif /* LACKS_STRING_H */ #if USE_BUILTIN_FFS #ifndef LACKS_STRINGS_H #include /* for ffs */ #endif /* LACKS_STRINGS_H */ #endif /* USE_BUILTIN_FFS */ #if HAVE_MMAP #ifndef LACKS_SYS_MMAN_H #include /* for mmap */ #endif /* LACKS_SYS_MMAN_H */ #ifndef LACKS_FCNTL_H #include #endif /* LACKS_FCNTL_H */ #endif /* HAVE_MMAP */ #if HAVE_MORECORE #ifndef LACKS_UNISTD_H #include /* for sbrk */ #else /* LACKS_UNISTD_H */ #if !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__NetBSD__) extern void* sbrk(ptrdiff_t); #endif /* FreeBSD etc */ #endif /* LACKS_UNISTD_H */ #endif /* HAVE_MMAP */ /* START of GK additions */ #include extern void *sbrk(ptrdiff_t increment); /* END of GK additions */ /* Declarations for locking */ #if USE_LOCKS #ifndef WIN32 #include #if defined (__SVR4) && defined (__sun) /* solaris */ #include #endif /* solaris */ #else #ifndef _M_AMD64 /* These are already defined on AMD64 builds */ #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ LONG __cdecl _InterlockedCompareExchange(LPLONG volatile Dest, LONG Exchange, LONG Comp); LONG __cdecl _InterlockedExchange(LPLONG volatile Target, LONG Value); #ifdef __cplusplus } #endif /* __cplusplus */ #endif /* _M_AMD64 */ #pragma intrinsic (_InterlockedCompareExchange) #pragma intrinsic (_InterlockedExchange) #define interlockedcompareexchange _InterlockedCompareExchange #define interlockedexchange _InterlockedExchange #endif /* Win32 */ #endif /* USE_LOCKS */ /* Declarations for bit scanning on win32 */ #if defined(_MSC_VER) && _MSC_VER>=1300 #ifndef BitScanForward /* Try to avoid pulling in WinNT.h */ #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ unsigned char _BitScanForward(unsigned long *index, unsigned long mask); unsigned char _BitScanReverse(unsigned long *index, unsigned long mask); #ifdef __cplusplus } #endif /* __cplusplus */ #define BitScanForward _BitScanForward #define BitScanReverse _BitScanReverse #pragma intrinsic(_BitScanForward) #pragma intrinsic(_BitScanReverse) #endif /* BitScanForward */ #endif /* defined(_MSC_VER) && _MSC_VER>=1300 */ #ifndef WIN32 #ifndef malloc_getpagesize # ifdef _SC_PAGESIZE /* some SVR4 systems omit an underscore */ # ifndef _SC_PAGE_SIZE # define _SC_PAGE_SIZE _SC_PAGESIZE # endif # endif # ifdef _SC_PAGE_SIZE # define malloc_getpagesize sysconf(_SC_PAGE_SIZE) # else # if defined(BSD) || defined(DGUX) || defined(HAVE_GETPAGESIZE) extern size_t getpagesize(); # define malloc_getpagesize getpagesize() # else # ifdef WIN32 /* use supplied emulation of getpagesize */ # define malloc_getpagesize getpagesize() # else # ifndef LACKS_SYS_PARAM_H # include # endif # ifdef EXEC_PAGESIZE # define malloc_getpagesize EXEC_PAGESIZE # else # ifdef NBPG # ifndef CLSIZE # define malloc_getpagesize NBPG # else # define malloc_getpagesize (NBPG * CLSIZE) # endif # else # ifdef NBPC # define malloc_getpagesize NBPC # else # ifdef PAGESIZE # define malloc_getpagesize PAGESIZE # else /* just guess */ # define malloc_getpagesize ((size_t)4096U) # endif # endif # endif # endif # endif # endif # endif #endif #endif /* ------------------- size_t and alignment properties -------------------- */ /* The byte and bit size of a size_t */ #define SIZE_T_SIZE (sizeof(size_t)) #define SIZE_T_BITSIZE (sizeof(size_t) << 3) /* Some constants coerced to size_t */ /* Annoying but necessary to avoid errors on some platforms */ #define SIZE_T_ZERO ((size_t)0) #define SIZE_T_ONE ((size_t)1) #define SIZE_T_TWO ((size_t)2) #define SIZE_T_FOUR ((size_t)4) #define TWO_SIZE_T_SIZES (SIZE_T_SIZE<<1) #define FOUR_SIZE_T_SIZES (SIZE_T_SIZE<<2) #define SIX_SIZE_T_SIZES (FOUR_SIZE_T_SIZES+TWO_SIZE_T_SIZES) #define HALF_MAX_SIZE_T (MAX_SIZE_T / 2U) /* The bit mask value corresponding to MALLOC_ALIGNMENT */ #define CHUNK_ALIGN_MASK (MALLOC_ALIGNMENT - SIZE_T_ONE) /* True if address a has acceptable alignment */ #define is_aligned(A) (((size_t)((A)) & (CHUNK_ALIGN_MASK)) == 0) /* the number of bytes to offset an address to align it */ #define align_offset(A)\ ((((size_t)(A) & CHUNK_ALIGN_MASK) == 0)? 0 :\ ((MALLOC_ALIGNMENT - ((size_t)(A) & CHUNK_ALIGN_MASK)) & CHUNK_ALIGN_MASK)) /* -------------------------- MMAP preliminaries ------------------------- */ /* If HAVE_MORECORE or HAVE_MMAP are false, we just define calls and checks to fail so compiler optimizer can delete code rather than using so many "#if"s. */ /* MORECORE and MMAP must return MFAIL on failure */ #define MFAIL ((void*)(MAX_SIZE_T)) #define CMFAIL ((char*)(MFAIL)) /* defined for convenience */ #if !HAVE_MMAP #define IS_MMAPPED_BIT (SIZE_T_ZERO) #define USE_MMAP_BIT (SIZE_T_ZERO) #define CALL_MMAP(s) MFAIL #define CALL_MUNMAP(a, s) (-1) #define DIRECT_MMAP(s) MFAIL #else /* HAVE_MMAP */ #define IS_MMAPPED_BIT (SIZE_T_ONE) #define USE_MMAP_BIT (SIZE_T_ONE) #ifndef WIN32 #define CALL_MUNMAP(a, s) munmap((a), (s)) #define MMAP_PROT (PROT_READ|PROT_WRITE) #if !defined(MAP_ANONYMOUS) && defined(MAP_ANON) #define MAP_ANONYMOUS MAP_ANON #endif /* MAP_ANON */ #ifdef MAP_ANONYMOUS #define MMAP_FLAGS (MAP_PRIVATE|MAP_ANONYMOUS) #define CALL_MMAP(s) mmap(0, (s), MMAP_PROT, MMAP_FLAGS, -1, 0) #else /* MAP_ANONYMOUS */ /* Nearly all versions of mmap support MAP_ANONYMOUS, so the following is unlikely to be needed, but is supplied just in case. */ #define MMAP_FLAGS (MAP_PRIVATE) static int dev_zero_fd = -1; /* Cached file descriptor for /dev/zero. */ #define CALL_MMAP(s) ((dev_zero_fd < 0) ? \ (dev_zero_fd = open("/dev/zero", O_RDWR), \ mmap(0, (s), MMAP_PROT, MMAP_FLAGS, dev_zero_fd, 0)) : \ mmap(0, (s), MMAP_PROT, MMAP_FLAGS, dev_zero_fd, 0)) #endif /* MAP_ANONYMOUS */ #define DIRECT_MMAP(s) CALL_MMAP(s) #else /* WIN32 */ /* Win32 MMAP via VirtualAlloc */ static FORCEINLINE void* win32mmap(size_t size) { void* ptr = VirtualAlloc(0, size, MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE); return (ptr != 0)? ptr: MFAIL; } /* For direct MMAP, use MEM_TOP_DOWN to minimize interference */ static FORCEINLINE void* win32direct_mmap(size_t size) { void* ptr = VirtualAlloc(0, size, MEM_RESERVE|MEM_COMMIT|MEM_TOP_DOWN, PAGE_READWRITE); return (ptr != 0)? ptr: MFAIL; } /* This function supports releasing coalesed segments */ static FORCEINLINE int win32munmap(void* ptr, size_t size) { MEMORY_BASIC_INFORMATION minfo; char* cptr = (char*)ptr; while (size) { if (VirtualQuery(cptr, &minfo, sizeof(minfo)) == 0) return -1; if (minfo.BaseAddress != cptr || minfo.AllocationBase != cptr || minfo.State != MEM_COMMIT || minfo.RegionSize > size) return -1; if (VirtualFree(cptr, 0, MEM_RELEASE) == 0) return -1; cptr += minfo.RegionSize; size -= minfo.RegionSize; } return 0; } #define CALL_MMAP(s) win32mmap(s) #define CALL_MUNMAP(a, s) win32munmap((a), (s)) #define DIRECT_MMAP(s) win32direct_mmap(s) #endif /* WIN32 */ #endif /* HAVE_MMAP */ #if HAVE_MMAP && HAVE_MREMAP #define CALL_MREMAP(addr, osz, nsz, mv) mremap((addr), (osz), (nsz), (mv)) #else /* HAVE_MMAP && HAVE_MREMAP */ #define CALL_MREMAP(addr, osz, nsz, mv) ((void)(addr),(void)(osz), \ (void)(nsz), (void)(mv),MFAIL) #endif /* HAVE_MMAP && HAVE_MREMAP */ #if HAVE_MORECORE #define CALL_MORECORE(S) MORECORE(S) #else /* HAVE_MORECORE */ #define CALL_MORECORE(S) MFAIL #endif /* HAVE_MORECORE */ /* mstate bit set if continguous morecore disabled or failed */ #define USE_NONCONTIGUOUS_BIT (4U) /* segment bit set in create_mspace_with_base */ #define EXTERN_BIT (8U) /* --------------------------- Lock preliminaries ------------------------ */ /* When locks are defined, there are up to two global locks: * If HAVE_MORECORE, morecore_mutex protects sequences of calls to MORECORE. In many cases sys_alloc requires two calls, that should not be interleaved with calls by other threads. This does not protect against direct calls to MORECORE by other threads not using this lock, so there is still code to cope the best we can on interference. * magic_init_mutex ensures that mparams.magic and other unique mparams values are initialized only once. To enable use in layered extensions, locks are reentrant. Because lock-protected regions generally have bounded times, we use the supplied simple spinlocks in the custom versions for x86. If USE_LOCKS is > 1, the definitions of lock routines here are bypassed, in which case you will need to define at least INITIAL_LOCK, ACQUIRE_LOCK, RELEASE_LOCK, and NULL_LOCK_INITIALIZER, and possibly TRY_LOCK and IS_LOCKED (The latter two are not used in this malloc, but are commonly needed in extensions.) */ #if USE_LOCKS == 1 #if USE_SPIN_LOCKS #ifndef WIN32 /* Custom pthread-style spin locks on x86 and x64 for gcc */ struct pthread_mlock_t { volatile pthread_t threadid; volatile unsigned int c; volatile unsigned int l; }; #define MLOCK_T struct pthread_mlock_t #define CURRENT_THREAD pthread_self() #define SPINS_PER_YIELD 63 static FORCEINLINE int pthread_acquire_lock (MLOCK_T *sl) { if(CURRENT_THREAD==sl->threadid) ++sl->c; else { int spins = 0; for (;;) { int ret; __asm__ __volatile__ ("lock cmpxchgl %2,(%1)" : "=a" (ret) : "r" (&sl->l), "r" (1), "a" (0)); if(!ret) { assert(!sl->threadid); sl->threadid=CURRENT_THREAD; sl->c=1; break; } if ((++spins & SPINS_PER_YIELD) == 0) { #if defined (__SVR4) && defined (__sun) /* solaris */ thr_yield(); #else #ifdef linux sched_yield(); #else /* no-op yield on unknown systems */ ; #endif /* linux */ #endif /* solaris */ } } } return 0; } static FORCEINLINE void pthread_release_lock (MLOCK_T *sl) { int ret; assert(CURRENT_THREAD==sl->threadid); if (!--sl->c) { sl->threadid=0; __asm__ __volatile__ ("xchgl %2,(%1)" : "=r" (ret) : "r" (&sl->l), "0" (0)); } } static FORCEINLINE int pthread_try_lock (MLOCK_T *sl) { int ret; __asm__ __volatile__ ("lock cmpxchgl %2,(%1)" : "=a" (ret) : "r" (&sl->l), "r" (1), "a" (0)); if(!ret){ assert(!sl->threadid); sl->threadid=CURRENT_THREAD; sl->c=1; return 1; } return 0; } #define INITIAL_LOCK(sl) (memset((sl), 0, sizeof(MLOCK_T)), 0) #define ACQUIRE_LOCK(sl) pthread_acquire_lock(sl) #define RELEASE_LOCK(sl) pthread_release_lock(sl) #define TRY_LOCK(sl) pthread_try_lock(sl) #define IS_LOCKED(sl) ((sl)->l) static MLOCK_T magic_init_mutex = {0, 0, 0 }; #if HAVE_MORECORE static MLOCK_T morecore_mutex = {0, 0, 0 }; #endif /* HAVE_MORECORE */ #else /* WIN32 */ /* Custom win32-style spin locks on x86 and x64 for MSC */ struct win32_mlock_t { volatile long threadid; volatile unsigned int c; long l; }; #define MLOCK_T struct win32_mlock_t #define CURRENT_THREAD GetCurrentThreadId() #define SPINS_PER_YIELD 63 static FORCEINLINE int win32_acquire_lock (MLOCK_T *sl) { long mythreadid=CURRENT_THREAD; if(mythreadid==sl->threadid) ++sl->c; else { int spins = 0; for (;;) { if (!interlockedexchange(&sl->l, 1)) { assert(!sl->threadid); sl->threadid=mythreadid; sl->c=1; break; } if ((++spins & SPINS_PER_YIELD) == 0) SleepEx(0, FALSE); } } return 0; } static FORCEINLINE void win32_release_lock (MLOCK_T *sl) { assert(CURRENT_THREAD==sl->threadid); if (!--sl->c) { sl->threadid=0; interlockedexchange (&sl->l, 0); } } static FORCEINLINE int win32_try_lock (MLOCK_T *sl) { if (!interlockedexchange(&sl->l, 1)){ assert(!sl->threadid); sl->threadid=CURRENT_THREAD; sl->c=1; return 1; } return 0; } #define INITIAL_LOCK(sl) (memset(sl, 0, sizeof(MLOCK_T)), 0) #define ACQUIRE_LOCK(sl) win32_acquire_lock(sl) #define RELEASE_LOCK(sl) win32_release_lock(sl) #define TRY_LOCK(sl) win32_try_lock(sl) #define IS_LOCKED(sl) ((sl)->l) static MLOCK_T magic_init_mutex = {0, 0 }; #if HAVE_MORECORE static MLOCK_T morecore_mutex = {0, 0 }; #endif /* HAVE_MORECORE */ #endif /* WIN32 */ #else /* USE_SPIN_LOCKS */ #ifndef WIN32 /* pthreads-based locks */ struct pthread_mlock_t { volatile unsigned int c; pthread_mutex_t l; }; #define MLOCK_T struct pthread_mlock_t #define CURRENT_THREAD pthread_self() static FORCEINLINE int pthread_acquire_lock (MLOCK_T *sl) { if(!pthread_mutex_lock(&(sl)->l)){ sl->c++; return 0; } return 1; } static FORCEINLINE void pthread_release_lock (MLOCK_T *sl) { --sl->c; pthread_mutex_unlock(&(sl)->l); } static FORCEINLINE int pthread_try_lock (MLOCK_T *sl) { if(!pthread_mutex_trylock(&(sl)->l)){ sl->c++; return 1; } return 0; } static FORCEINLINE int pthread_init_lock (MLOCK_T *sl) { pthread_mutexattr_t attr; sl->c=0; if(pthread_mutexattr_init(&attr)) return 1; if(pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE)) return 1; if(pthread_mutex_init(&sl->l, &attr)) return 1; pthread_mutexattr_destroy(&attr); return 0; } static FORCEINLINE int pthread_islocked (MLOCK_T *sl) { if(!pthread_try_lock(sl)){ int ret = (sl->c != 0); pthread_mutex_unlock(sl); return ret; } return 0; } #define INITIAL_LOCK(sl) pthread_init_lock(sl) #define ACQUIRE_LOCK(sl) pthread_acquire_lock(sl) #define RELEASE_LOCK(sl) pthread_release_lock(sl) #define TRY_LOCK(sl) pthread_try_lock(sl) #define IS_LOCKED(sl) pthread_islocked(sl) static MLOCK_T magic_init_mutex = {0, PTHREAD_MUTEX_INITIALIZER }; #if HAVE_MORECORE static MLOCK_T morecore_mutex = {0, PTHREAD_MUTEX_INITIALIZER }; #endif /* HAVE_MORECORE */ #else /* WIN32 */ /* Win32 critical sections */ #define MLOCK_T CRITICAL_SECTION #define CURRENT_THREAD GetCurrentThreadId() #define INITIAL_LOCK(s) (!InitializeCriticalSectionAndSpinCount((s), 4000) #define ACQUIRE_LOCK(s) ( (!((s))->DebugInfo ? INITIAL_LOCK((s)) : 0), !EnterCriticalSection((s)), 0) #define RELEASE_LOCK(s) ( LeaveCriticalSection((s)), 0 ) #define TRY_LOCK(s) ( TryEnterCriticalSection((s)) ) #define IS_LOCKED(s) ( (s)->LockCount >= 0 ) #define NULL_LOCK_INITIALIZER static MLOCK_T magic_init_mutex; #if HAVE_MORECORE static MLOCK_T morecore_mutex; #endif /* HAVE_MORECORE */ #endif /* WIN32 */ #endif /* USE_SPIN_LOCKS */ #endif /* USE_LOCKS == 1 */ /* ----------------------- User-defined locks ------------------------ */ #if USE_LOCKS > 1 /* Define your own lock implementation here */ /* #define INITIAL_LOCK(sl) ... */ /* #define ACQUIRE_LOCK(sl) ... */ /* #define RELEASE_LOCK(sl) ... */ /* #define TRY_LOCK(sl) ... */ /* #define IS_LOCKED(sl) ... */ /* #define NULL_LOCK_INITIALIZER ... */ static MLOCK_T magic_init_mutex = NULL_LOCK_INITIALIZER; #if HAVE_MORECORE static MLOCK_T morecore_mutex = NULL_LOCK_INITIALIZER; #endif /* HAVE_MORECORE */ #endif /* USE_LOCKS > 1 */ /* ----------------------- Lock-based state ------------------------ */ #if USE_LOCKS #define USE_LOCK_BIT (2U) #else /* USE_LOCKS */ #define USE_LOCK_BIT (0U) #define INITIAL_LOCK(l) #endif /* USE_LOCKS */ #if USE_LOCKS && HAVE_MORECORE #define ACQUIRE_MORECORE_LOCK() ACQUIRE_LOCK(&morecore_mutex); #define RELEASE_MORECORE_LOCK() RELEASE_LOCK(&morecore_mutex); #else /* USE_LOCKS && HAVE_MORECORE */ #define ACQUIRE_MORECORE_LOCK() #define RELEASE_MORECORE_LOCK() #endif /* USE_LOCKS && HAVE_MORECORE */ #if USE_LOCKS #define ACQUIRE_MAGIC_INIT_LOCK() ACQUIRE_LOCK(&magic_init_mutex); #define RELEASE_MAGIC_INIT_LOCK() RELEASE_LOCK(&magic_init_mutex); #else /* USE_LOCKS */ #define ACQUIRE_MAGIC_INIT_LOCK() #define RELEASE_MAGIC_INIT_LOCK() #endif /* USE_LOCKS */ /* ----------------------- Chunk representations ------------------------ */ /* (The following includes lightly edited explanations by Colin Plumb.) The malloc_chunk declaration below is misleading (but accurate and necessary). It declares a "view" into memory allowing access to necessary fields at known offsets from a given base. Chunks of memory are maintained using a `boundary tag' method as originally described by Knuth. (See the paper by Paul Wilson ftp://ftp.cs.utexas.edu/pub/garbage/allocsrv.ps for a survey of such techniques.) Sizes of free chunks are stored both in the front of each chunk and at the end. This makes consolidating fragmented chunks into bigger chunks fast. The head fields also hold bits representing whether chunks are free or in use. Here are some pictures to make it clearer. They are "exploded" to show that the state of a chunk can be thought of as extending from the high 31 bits of the head field of its header through the prev_foot and PINUSE_BIT bit of the following chunk header. A chunk that's in use looks like: chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Size of previous chunk (if P = 1) | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |P| | Size of this chunk 1| +-+ mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | | +- -+ | | +- -+ | : +- size - sizeof(size_t) available payload bytes -+ : | chunk-> +- -+ | | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |1| | Size of next chunk (may or may not be in use) | +-+ mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ And if it's free, it looks like this: chunk-> +- -+ | User payload (must be in use, or we would have merged!) | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |P| | Size of this chunk 0| +-+ mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Next pointer | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Prev pointer | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | : +- size - sizeof(struct chunk) unused bytes -+ : | chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Size of this chunk | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |0| | Size of next chunk (must be in use, or we would have merged)| +-+ mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | : +- User payload -+ : | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |0| +-+ Note that since we always merge adjacent free chunks, the chunks adjacent to a free chunk must be in use. Given a pointer to a chunk (which can be derived trivially from the payload pointer) we can, in O(1) time, find out whether the adjacent chunks are free, and if so, unlink them from the lists that they are on and merge them with the current chunk. Chunks always begin on even word boundaries, so the mem portion (which is returned to the user) is also on an even word boundary, and thus at least double-word aligned. The P (PINUSE_BIT) bit, stored in the unused low-order bit of the chunk size (which is always a multiple of two words), is an in-use bit for the *previous* chunk. If that bit is *clear*, then the word before the current chunk size contains the previous chunk size, and can be used to find the front of the previous chunk. The very first chunk allocated always has this bit set, preventing access to non-existent (or non-owned) memory. If pinuse is set for any given chunk, then you CANNOT determine the size of the previous chunk, and might even get a memory addressing fault when trying to do so. The C (CINUSE_BIT) bit, stored in the unused second-lowest bit of the chunk size redundantly records whether the current chunk is inuse. This redundancy enables usage checks within free and realloc, and reduces indirection when freeing and consolidating chunks. Each freshly allocated chunk must have both cinuse and pinuse set. That is, each allocated chunk borders either a previously allocated and still in-use chunk, or the base of its memory arena. This is ensured by making all allocations from the the `lowest' part of any found chunk. Further, no free chunk physically borders another one, so each free chunk is known to be preceded and followed by either inuse chunks or the ends of memory. Note that the `foot' of the current chunk is actually represented as the prev_foot of the NEXT chunk. This makes it easier to deal with alignments etc but can be very confusing when trying to extend or adapt this code. The exceptions to all this are 1. The special chunk `top' is the top-most available chunk (i.e., the one bordering the end of available memory). It is treated specially. Top is never included in any bin, is used only if no other chunk is available, and is released back to the system if it is very large (see M_TRIM_THRESHOLD). In effect, the top chunk is treated as larger (and thus less well fitting) than any other available chunk. The top chunk doesn't update its trailing size field since there is no next contiguous chunk that would have to index off it. However, space is still allocated for it (TOP_FOOT_SIZE) to enable separation or merging when space is extended. 3. Chunks allocated via mmap, which have the lowest-order bit (IS_MMAPPED_BIT) set in their prev_foot fields, and do not set PINUSE_BIT in their head fields. Because they are allocated one-by-one, each must carry its own prev_foot field, which is also used to hold the offset this chunk has within its mmapped region, which is needed to preserve alignment. Each mmapped chunk is trailed by the first two fields of a fake next-chunk for sake of usage checks. */ struct malloc_chunk { size_t prev_foot; /* Size of previous chunk (if free). */ size_t head; /* Size and inuse bits. */ struct malloc_chunk* fd; /* double links -- used only if free. */ struct malloc_chunk* bk; }; typedef struct malloc_chunk mchunk; typedef struct malloc_chunk* mchunkptr; typedef struct malloc_chunk* sbinptr; /* The type of bins of chunks */ typedef unsigned int bindex_t; /* Described below */ typedef unsigned int binmap_t; /* Described below */ typedef unsigned int flag_t; /* The type of various bit flag sets */ /* ------------------- Chunks sizes and alignments ----------------------- */ #define MCHUNK_SIZE (sizeof(mchunk)) #if FOOTERS #define CHUNK_OVERHEAD (TWO_SIZE_T_SIZES) #else /* FOOTERS */ #define CHUNK_OVERHEAD (SIZE_T_SIZE) #endif /* FOOTERS */ /* MMapped chunks need a second word of overhead ... */ #define MMAP_CHUNK_OVERHEAD (TWO_SIZE_T_SIZES) /* ... and additional padding for fake next-chunk at foot */ #define MMAP_FOOT_PAD (FOUR_SIZE_T_SIZES) /* The smallest size we can malloc is an aligned minimal chunk */ #define MIN_CHUNK_SIZE\ ((MCHUNK_SIZE + CHUNK_ALIGN_MASK) & ~CHUNK_ALIGN_MASK) /* conversion from malloc headers to user pointers, and back */ #define chunk2mem(p) ((void*)((char*)(p) + TWO_SIZE_T_SIZES)) #define mem2chunk(mem) ((mchunkptr)((char*)(mem) - TWO_SIZE_T_SIZES)) /* chunk associated with aligned address A */ #define align_as_chunk(A) (mchunkptr)((A) + align_offset(chunk2mem(A))) /* Bounds on request (not chunk) sizes. */ #define MAX_REQUEST ((-MIN_CHUNK_SIZE) << 2) #define MIN_REQUEST (MIN_CHUNK_SIZE - CHUNK_OVERHEAD - SIZE_T_ONE) /* pad request bytes into a usable size */ #define pad_request(req) \ (((req) + CHUNK_OVERHEAD + CHUNK_ALIGN_MASK) & ~CHUNK_ALIGN_MASK) /* pad request, checking for minimum (but not maximum) */ #define request2size(req) \ (((req) < MIN_REQUEST)? MIN_CHUNK_SIZE : pad_request(req)) /* ------------------ Operations on head and foot fields ----------------- */ /* The head field of a chunk is or'ed with PINUSE_BIT when previous adjacent chunk in use, and or'ed with CINUSE_BIT if this chunk is in use. If the chunk was obtained with mmap, the prev_foot field has IS_MMAPPED_BIT set, otherwise holding the offset of the base of the mmapped region to the base of the chunk. FLAG4_BIT is not used by this malloc, but might be useful in extensions. */ #define PINUSE_BIT (SIZE_T_ONE) #define CINUSE_BIT (SIZE_T_TWO) #define FLAG4_BIT (SIZE_T_FOUR) #define INUSE_BITS (PINUSE_BIT|CINUSE_BIT) #define FLAG_BITS (PINUSE_BIT|CINUSE_BIT|FLAG4_BIT) /* Head value for fenceposts */ #define FENCEPOST_HEAD (INUSE_BITS|SIZE_T_SIZE) /* extraction of fields from head words */ #define cinuse(p) ((p)->head & CINUSE_BIT) #define pinuse(p) ((p)->head & PINUSE_BIT) #define chunksize(p) ((p)->head & ~(FLAG_BITS)) #define clear_pinuse(p) ((p)->head &= ~PINUSE_BIT) #define clear_cinuse(p) ((p)->head &= ~CINUSE_BIT) /* Treat space at ptr +/- offset as a chunk */ #define chunk_plus_offset(p, s) ((mchunkptr)(((char*)(p)) + (s))) #define chunk_minus_offset(p, s) ((mchunkptr)(((char*)(p)) - (s))) /* Ptr to next or previous physical malloc_chunk. */ #define next_chunk(p) ((mchunkptr)( ((char*)(p)) + ((p)->head & ~FLAG_BITS))) #define prev_chunk(p) ((mchunkptr)( ((char*)(p)) - ((p)->prev_foot) )) /* extract next chunk's pinuse bit */ #define next_pinuse(p) ((next_chunk(p)->head) & PINUSE_BIT) /* Get/set size at footer */ #define get_foot(p, s) (((mchunkptr)((char*)(p) + (s)))->prev_foot) #define set_foot(p, s) (((mchunkptr)((char*)(p) + (s)))->prev_foot = (s)) /* Set size, pinuse bit, and foot */ #define set_size_and_pinuse_of_free_chunk(p, s)\ ((p)->head = (s|PINUSE_BIT), set_foot(p, s)) /* Set size, pinuse bit, foot, and clear next pinuse */ #define set_free_with_pinuse(p, s, n)\ (clear_pinuse(n), set_size_and_pinuse_of_free_chunk(p, s)) #define is_mmapped(p)\ (!((p)->head & PINUSE_BIT) && ((p)->prev_foot & IS_MMAPPED_BIT)) /* Get the internal overhead associated with chunk p */ #define overhead_for(p)\ (is_mmapped(p)? MMAP_CHUNK_OVERHEAD : CHUNK_OVERHEAD) /* Return true if malloced space is not necessarily cleared */ #if MMAP_CLEARS #define calloc_must_clear(p) (!is_mmapped(p)) #else /* MMAP_CLEARS */ #define calloc_must_clear(p) (1) #endif /* MMAP_CLEARS */ /* ---------------------- Overlaid data structures ----------------------- */ /* When chunks are not in use, they are treated as nodes of either lists or trees. "Small" chunks are stored in circular doubly-linked lists, and look like this: chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Size of previous chunk | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ `head:' | Size of chunk, in bytes |P| mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Forward pointer to next chunk in list | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Back pointer to previous chunk in list | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Unused space (may be 0 bytes long) . . . . | nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ `foot:' | Size of chunk, in bytes | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Larger chunks are kept in a form of bitwise digital trees (aka tries) keyed on chunksizes. Because malloc_tree_chunks are only for free chunks greater than 256 bytes, their size doesn't impose any constraints on user chunk sizes. Each node looks like: chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Size of previous chunk | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ `head:' | Size of chunk, in bytes |P| mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Forward pointer to next chunk of same size | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Back pointer to previous chunk of same size | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Pointer to left child (child[0]) | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Pointer to right child (child[1]) | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Pointer to parent | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | bin index of this chunk | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Unused space . . | nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ `foot:' | Size of chunk, in bytes | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Each tree holding treenodes is a tree of unique chunk sizes. Chunks of the same size are arranged in a circularly-linked list, with only the oldest chunk (the next to be used, in our FIFO ordering) actually in the tree. (Tree members are distinguished by a non-null parent pointer.) If a chunk with the same size an an existing node is inserted, it is linked off the existing node using pointers that work in the same way as fd/bk pointers of small chunks. Each tree contains a power of 2 sized range of chunk sizes (the smallest is 0x100 <= x < 0x180), which is is divided in half at each tree level, with the chunks in the smaller half of the range (0x100 <= x < 0x140 for the top nose) in the left subtree and the larger half (0x140 <= x < 0x180) in the right subtree. This is, of course, done by inspecting individual bits. Using these rules, each node's left subtree contains all smaller sizes than its right subtree. However, the node at the root of each subtree has no particular ordering relationship to either. (The dividing line between the subtree sizes is based on trie relation.) If we remove the last chunk of a given size from the interior of the tree, we need to replace it with a leaf node. The tree ordering rules permit a node to be replaced by any leaf below it. The smallest chunk in a tree (a common operation in a best-fit allocator) can be found by walking a path to the leftmost leaf in the tree. Unlike a usual binary tree, where we follow left child pointers until we reach a null, here we follow the right child pointer any time the left one is null, until we reach a leaf with both child pointers null. The smallest chunk in the tree will be somewhere along that path. The worst case number of steps to add, find, or remove a node is bounded by the number of bits differentiating chunks within bins. Under current bin calculations, this ranges from 6 up to 21 (for 32 bit sizes) or up to 53 (for 64 bit sizes). The typical case is of course much better. */ struct malloc_tree_chunk { /* The first four fields must be compatible with malloc_chunk */ size_t prev_foot; size_t head; struct malloc_tree_chunk* fd; struct malloc_tree_chunk* bk; struct malloc_tree_chunk* child[2]; struct malloc_tree_chunk* parent; bindex_t index; }; typedef struct malloc_tree_chunk tchunk; typedef struct malloc_tree_chunk* tchunkptr; typedef struct malloc_tree_chunk* tbinptr; /* The type of bins of trees */ /* A little helper macro for trees */ #define leftmost_child(t) ((t)->child[0] != 0? (t)->child[0] : (t)->child[1]) /* ----------------------------- Segments -------------------------------- */ /* Each malloc space may include non-contiguous segments, held in a list headed by an embedded malloc_segment record representing the top-most space. Segments also include flags holding properties of the space. Large chunks that are directly allocated by mmap are not included in this list. They are instead independently created and destroyed without otherwise keeping track of them. Segment management mainly comes into play for spaces allocated by MMAP. Any call to MMAP might or might not return memory that is adjacent to an existing segment. MORECORE normally contiguously extends the current space, so this space is almost always adjacent, which is simpler and faster to deal with. (This is why MORECORE is used preferentially to MMAP when both are available -- see sys_alloc.) When allocating using MMAP, we don't use any of the hinting mechanisms (inconsistently) supported in various implementations of unix mmap, or distinguish reserving from committing memory. Instead, we just ask for space, and exploit contiguity when we get it. It is probably possible to do better than this on some systems, but no general scheme seems to be significantly better. Management entails a simpler variant of the consolidation scheme used for chunks to reduce fragmentation -- new adjacent memory is normally prepended or appended to an existing segment. However, there are limitations compared to chunk consolidation that mostly reflect the fact that segment processing is relatively infrequent (occurring only when getting memory from system) and that we don't expect to have huge numbers of segments: * Segments are not indexed, so traversal requires linear scans. (It would be possible to index these, but is not worth the extra overhead and complexity for most programs on most platforms.) * New segments are only appended to old ones when holding top-most memory; if they cannot be prepended to others, they are held in different segments. Except for the top-most segment of an mstate, each segment record is kept at the tail of its segment. Segments are added by pushing segment records onto the list headed by &mstate.seg for the containing mstate. Segment flags control allocation/merge/deallocation policies: * If EXTERN_BIT set, then we did not allocate this segment, and so should not try to deallocate or merge with others. (This currently holds only for the initial segment passed into create_mspace_with_base.) * If IS_MMAPPED_BIT set, the segment may be merged with other surrounding mmapped segments and trimmed/de-allocated using munmap. * If neither bit is set, then the segment was obtained using MORECORE so can be merged with surrounding MORECORE'd segments and deallocated/trimmed using MORECORE with negative arguments. */ struct malloc_segment { char* base; /* base address */ size_t size; /* allocated size */ struct malloc_segment* next; /* ptr to next segment */ flag_t sflags; /* mmap and extern flag */ }; #define is_mmapped_segment(S) ((S)->sflags & IS_MMAPPED_BIT) #define is_extern_segment(S) ((S)->sflags & EXTERN_BIT) typedef struct malloc_segment msegment; typedef struct malloc_segment* msegmentptr; /* ---------------------------- malloc_state ----------------------------- */ /* A malloc_state holds all of the bookkeeping for a space. The main fields are: Top The topmost chunk of the currently active segment. Its size is cached in topsize. The actual size of topmost space is topsize+TOP_FOOT_SIZE, which includes space reserved for adding fenceposts and segment records if necessary when getting more space from the system. The size at which to autotrim top is cached from mparams in trim_check, except that it is disabled if an autotrim fails. Designated victim (dv) This is the preferred chunk for servicing small requests that don't have exact fits. It is normally the chunk split off most recently to service another small request. Its size is cached in dvsize. The link fields of this chunk are not maintained since it is not kept in a bin. SmallBins An array of bin headers for free chunks. These bins hold chunks with sizes less than MIN_LARGE_SIZE bytes. Each bin contains chunks of all the same size, spaced 8 bytes apart. To simplify use in double-linked lists, each bin header acts as a malloc_chunk pointing to the real first node, if it exists (else pointing to itself). This avoids special-casing for headers. But to avoid waste, we allocate only the fd/bk pointers of bins, and then use repositioning tricks to treat these as the fields of a chunk. TreeBins Treebins are pointers to the roots of trees holding a range of sizes. There are 2 equally spaced treebins for each power of two from TREE_SHIFT to TREE_SHIFT+16. The last bin holds anything larger. Bin maps There is one bit map for small bins ("smallmap") and one for treebins ("treemap). Each bin sets its bit when non-empty, and clears the bit when empty. Bit operations are then used to avoid bin-by-bin searching -- nearly all "search" is done without ever looking at bins that won't be selected. The bit maps conservatively use 32 bits per map word, even if on 64bit system. For a good description of some of the bit-based techniques used here, see Henry S. Warren Jr's book "Hacker's Delight" (and supplement at http://hackersdelight.org/). Many of these are intended to reduce the branchiness of paths through malloc etc, as well as to reduce the number of memory locations read or written. Segments A list of segments headed by an embedded malloc_segment record representing the initial space. Address check support The least_addr field is the least address ever obtained from MORECORE or MMAP. Attempted frees and reallocs of any address less than this are trapped (unless INSECURE is defined). Magic tag A cross-check field that should always hold same value as mparams.magic. Flags Bits recording whether to use MMAP, locks, or contiguous MORECORE Statistics Each space keeps track of current and maximum system memory obtained via MORECORE or MMAP. Trim support Fields holding the amount of unused topmost memory that should trigger timming, and a counter to force periodic scanning to release unused non-topmost segments. Locking If USE_LOCKS is defined, the "mutex" lock is acquired and released around every public call using this mspace. Extension support A void* pointer and a size_t field that can be used to help implement extensions to this malloc. */ /* Bin types, widths and sizes */ #define NSMALLBINS (32U) #define NTREEBINS (32U) #define SMALLBIN_SHIFT (3U) #define SMALLBIN_WIDTH (SIZE_T_ONE << SMALLBIN_SHIFT) #define TREEBIN_SHIFT (8U) #define MIN_LARGE_SIZE (SIZE_T_ONE << TREEBIN_SHIFT) #define MAX_SMALL_SIZE (MIN_LARGE_SIZE - SIZE_T_ONE) #define MAX_SMALL_REQUEST (MAX_SMALL_SIZE - CHUNK_ALIGN_MASK - CHUNK_OVERHEAD) struct malloc_state { binmap_t smallmap; binmap_t treemap; size_t dvsize; size_t topsize; char* least_addr; mchunkptr dv; mchunkptr top; size_t trim_check; size_t release_checks; size_t magic; mchunkptr smallbins[(NSMALLBINS+1)*2]; tbinptr treebins[NTREEBINS]; size_t footprint; size_t max_footprint; flag_t mflags; #if USE_LOCKS MLOCK_T mutex; /* locate lock among fields that rarely change */ #endif /* USE_LOCKS */ msegment seg; void* extp; /* Unused but available for extensions */ size_t exts; }; typedef struct malloc_state* mstate; /* ------------- Global malloc_state and malloc_params ------------------- */ /* malloc_params holds global properties, including those that can be dynamically set using mallopt. There is a single instance, mparams, initialized in init_mparams. */ struct malloc_params { size_t magic; size_t page_size; size_t granularity; size_t mmap_threshold; size_t trim_threshold; flag_t default_mflags; }; static struct malloc_params mparams; #if !ONLY_MSPACES /* The global malloc_state used for all non-"mspace" calls */ static struct malloc_state _gm_; #define gm (&_gm_) #define is_global(M) ((M) == &_gm_) #endif /* !ONLY_MSPACES */ #define is_initialized(M) ((M)->top != 0) /* -------------------------- system alloc setup ------------------------- */ /* Operations on mflags */ #define use_lock(M) ((M)->mflags & USE_LOCK_BIT) #define enable_lock(M) ((M)->mflags |= USE_LOCK_BIT) #define disable_lock(M) ((M)->mflags &= ~USE_LOCK_BIT) #define use_mmap(M) ((M)->mflags & USE_MMAP_BIT) #define enable_mmap(M) ((M)->mflags |= USE_MMAP_BIT) #define disable_mmap(M) ((M)->mflags &= ~USE_MMAP_BIT) #define use_noncontiguous(M) ((M)->mflags & USE_NONCONTIGUOUS_BIT) #define disable_contiguous(M) ((M)->mflags |= USE_NONCONTIGUOUS_BIT) #define set_lock(M,L)\ ((M)->mflags = (L)?\ ((M)->mflags | USE_LOCK_BIT) :\ ((M)->mflags & ~USE_LOCK_BIT)) /* page-align a size */ #define page_align(S)\ (((S) + (mparams.page_size - SIZE_T_ONE)) & ~(mparams.page_size - SIZE_T_ONE)) /* granularity-align a size */ #define granularity_align(S)\ (((S) + (mparams.granularity - SIZE_T_ONE))\ & ~(mparams.granularity - SIZE_T_ONE)) /* For mmap, use granularity alignment on windows, else page-align */ #ifdef WIN32 #define mmap_align(S) granularity_align(S) #else #define mmap_align(S) page_align(S) #endif #define is_page_aligned(S)\ (((size_t)(S) & (mparams.page_size - SIZE_T_ONE)) == 0) #define is_granularity_aligned(S)\ (((size_t)(S) & (mparams.granularity - SIZE_T_ONE)) == 0) /* True if segment S holds address A */ #define segment_holds(S, A)\ ((char*)(A) >= S->base && (char*)(A) < S->base + S->size) /* Return segment holding given address */ static msegmentptr segment_holding(mstate m, char* addr) { msegmentptr sp = &m->seg; for (;;) { if (addr >= sp->base && addr < sp->base + sp->size) return sp; if ((sp = sp->next) == 0) return 0; } } /* Return true if segment contains a segment link */ static int has_segment_link(mstate m, msegmentptr ss) { msegmentptr sp = &m->seg; for (;;) { if ((char*)sp >= ss->base && (char*)sp < ss->base + ss->size) return 1; if ((sp = sp->next) == 0) return 0; } } #ifndef MORECORE_CANNOT_TRIM #define should_trim(M,s) ((s) > (M)->trim_check) #else /* MORECORE_CANNOT_TRIM */ #define should_trim(M,s) (0) #endif /* MORECORE_CANNOT_TRIM */ /* TOP_FOOT_SIZE is padding at the end of a segment, including space that may be needed to place segment records and fenceposts when new noncontiguous segments are added. */ #define TOP_FOOT_SIZE\ (align_offset(chunk2mem(0))+pad_request(sizeof(struct malloc_segment))+MIN_CHUNK_SIZE) /* ------------------------------- Hooks -------------------------------- */ /* PREACTION should be defined to return 0 on success, and nonzero on failure. If you are not using locking, you can redefine these to do anything you like. */ #if USE_LOCKS /* Ensure locks are initialized */ #define GLOBALLY_INITIALIZE() (mparams.page_size == 0 && init_mparams()) #define PREACTION(M) ((GLOBALLY_INITIALIZE() || use_lock(M))? ACQUIRE_LOCK(&(M)->mutex) : 0) #define POSTACTION(M) { if (use_lock(M)) RELEASE_LOCK(&(M)->mutex); } #else /* USE_LOCKS */ #ifndef PREACTION #define PREACTION(M) (0) #endif /* PREACTION */ #ifndef POSTACTION #define POSTACTION(M) #endif /* POSTACTION */ #endif /* USE_LOCKS */ /* CORRUPTION_ERROR_ACTION is triggered upon detected bad addresses. USAGE_ERROR_ACTION is triggered on detected bad frees and reallocs. The argument p is an address that might have triggered the fault. It is ignored by the two predefined actions, but might be useful in custom actions that try to help diagnose errors. */ #if PROCEED_ON_ERROR /* A count of the number of corruption errors causing resets */ int malloc_corruption_error_count; /* default corruption action */ static void reset_on_error(mstate m); #define CORRUPTION_ERROR_ACTION(m) reset_on_error(m) #define USAGE_ERROR_ACTION(m, p) #else /* PROCEED_ON_ERROR */ #ifndef CORRUPTION_ERROR_ACTION #define CORRUPTION_ERROR_ACTION(m) ABORT #endif /* CORRUPTION_ERROR_ACTION */ #ifndef USAGE_ERROR_ACTION #define USAGE_ERROR_ACTION(m,p) ABORT #endif /* USAGE_ERROR_ACTION */ #endif /* PROCEED_ON_ERROR */ /* -------------------------- Debugging setup ---------------------------- */ #if ! DEBUG #define check_free_chunk(M,P) #define check_inuse_chunk(M,P) #define check_malloced_chunk(M,P,N) #define check_mmapped_chunk(M,P) #define check_malloc_state(M) #define check_top_chunk(M,P) #else /* DEBUG */ #define check_free_chunk(M,P) do_check_free_chunk(M,P) #define check_inuse_chunk(M,P) do_check_inuse_chunk(M,P) #define check_top_chunk(M,P) do_check_top_chunk(M,P) #define check_malloced_chunk(M,P,N) do_check_malloced_chunk(M,P,N) #define check_mmapped_chunk(M,P) do_check_mmapped_chunk(M,P) #define check_malloc_state(M) do_check_malloc_state(M) static void do_check_any_chunk(mstate m, mchunkptr p); static void do_check_top_chunk(mstate m, mchunkptr p); static void do_check_mmapped_chunk(mstate m, mchunkptr p); static void do_check_inuse_chunk(mstate m, mchunkptr p); static void do_check_free_chunk(mstate m, mchunkptr p); static void do_check_malloced_chunk(mstate m, void* mem, size_t s); static void do_check_tree(mstate m, tchunkptr t); static void do_check_treebin(mstate m, bindex_t i); static void do_check_smallbin(mstate m, bindex_t i); static void do_check_malloc_state(mstate m); static int bin_find(mstate m, mchunkptr x); static size_t traverse_and_check(mstate m); #endif /* DEBUG */ /* ---------------------------- Indexing Bins ---------------------------- */ #define is_small(s) (((s) >> SMALLBIN_SHIFT) < NSMALLBINS) #define small_index(s) ((s) >> SMALLBIN_SHIFT) #define small_index2size(i) ((i) << SMALLBIN_SHIFT) #define MIN_SMALL_INDEX (small_index(MIN_CHUNK_SIZE)) /* addressing by index. See above about smallbin repositioning */ #define smallbin_at(M, i) ((sbinptr)((char*)&((M)->smallbins[(i)<<1]))) #define treebin_at(M,i) (&((M)->treebins[i])) /* assign tree index for size S to variable I */ #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) #define compute_tree_index(S, I)\ {\ unsigned int X = S >> TREEBIN_SHIFT;\ if (X == 0)\ I = 0;\ else if (X > 0xFFFF)\ I = NTREEBINS-1;\ else {\ unsigned int K;\ __asm__("bsrl\t%1, %0\n\t" : "=r" (K) : "g" (X));\ I = (bindex_t)((K << 1) + ((S >> (K + (TREEBIN_SHIFT-1)) & 1)));\ }\ } #elif defined(_MSC_VER) && _MSC_VER>=1300 #define compute_tree_index(S, I)\ {\ size_t X = S >> TREEBIN_SHIFT;\ if (X == 0)\ I = 0;\ else if (X > 0xFFFF)\ I = NTREEBINS-1;\ else {\ unsigned int K;\ _BitScanReverse((DWORD *) &K, X);\ I = (bindex_t)((K << 1) + ((S >> (K + (TREEBIN_SHIFT-1)) & 1)));\ }\ } #else /* GNUC */ #define compute_tree_index(S, I)\ {\ size_t X = S >> TREEBIN_SHIFT;\ if (X == 0)\ I = 0;\ else if (X > 0xFFFF)\ I = NTREEBINS-1;\ else {\ unsigned int Y = (unsigned int)X;\ unsigned int N = ((Y - 0x100) >> 16) & 8;\ unsigned int K = (((Y <<= N) - 0x1000) >> 16) & 4;\ N += K;\ N += K = (((Y <<= K) - 0x4000) >> 16) & 2;\ K = 14 - N + ((Y <<= K) >> 15);\ I = (K << 1) + ((S >> (K + (TREEBIN_SHIFT-1)) & 1));\ }\ } #endif /* GNUC */ /* Bit representing maximum resolved size in a treebin at i */ #define bit_for_tree_index(i) \ (i == NTREEBINS-1)? (SIZE_T_BITSIZE-1) : (((i) >> 1) + TREEBIN_SHIFT - 2) /* Shift placing maximum resolved bit in a treebin at i as sign bit */ #define leftshift_for_tree_index(i) \ ((i == NTREEBINS-1)? 0 : \ ((SIZE_T_BITSIZE-SIZE_T_ONE) - (((i) >> 1) + TREEBIN_SHIFT - 2))) /* The size of the smallest chunk held in bin with index i */ #define minsize_for_tree_index(i) \ ((SIZE_T_ONE << (((i) >> 1) + TREEBIN_SHIFT)) | \ (((size_t)((i) & SIZE_T_ONE)) << (((i) >> 1) + TREEBIN_SHIFT - 1))) /* ------------------------ Operations on bin maps ----------------------- */ /* bit corresponding to given index */ #define idx2bit(i) ((binmap_t)(1) << (i)) /* Mark/Clear bits with given index */ #define mark_smallmap(M,i) ((M)->smallmap |= idx2bit(i)) #define clear_smallmap(M,i) ((M)->smallmap &= ~idx2bit(i)) #define smallmap_is_marked(M,i) ((M)->smallmap & idx2bit(i)) #define mark_treemap(M,i) ((M)->treemap |= idx2bit(i)) #define clear_treemap(M,i) ((M)->treemap &= ~idx2bit(i)) #define treemap_is_marked(M,i) ((M)->treemap & idx2bit(i)) /* index corresponding to given bit */ #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) #define compute_bit2idx(X, I)\ {\ unsigned int J;\ __asm__("bsfl\t%1, %0\n\t" : "=r" (J) : "g" (X));\ I = (bindex_t)J;\ } #elif defined(_MSC_VER) && _MSC_VER>=1300 #define compute_bit2idx(X, I)\ {\ unsigned int J;\ _BitScanForward((DWORD *) &J, X);\ I = (bindex_t)J;\ } #else /* GNUC */ #if USE_BUILTIN_FFS #define compute_bit2idx(X, I) I = ffs(X)-1 #else /* USE_BUILTIN_FFS */ #define compute_bit2idx(X, I)\ {\ unsigned int Y = X - 1;\ unsigned int K = Y >> (16-4) & 16;\ unsigned int N = K; Y >>= K;\ N += K = Y >> (8-3) & 8; Y >>= K;\ N += K = Y >> (4-2) & 4; Y >>= K;\ N += K = Y >> (2-1) & 2; Y >>= K;\ N += K = Y >> (1-0) & 1; Y >>= K;\ I = (bindex_t)(N + Y);\ } #endif /* USE_BUILTIN_FFS */ #endif /* GNUC */ /* isolate the least set bit of a bitmap */ #define least_bit(x) ((x) & -(x)) /* mask with all bits to left of least bit of x on */ #define left_bits(x) ((x<<1) | -(x<<1)) /* mask with all bits to left of or equal to least bit of x on */ #define same_or_left_bits(x) ((x) | -(x)) /* ----------------------- Runtime Check Support ------------------------- */ /* For security, the main invariant is that malloc/free/etc never writes to a static address other than malloc_state, unless static malloc_state itself has been corrupted, which cannot occur via malloc (because of these checks). In essence this means that we believe all pointers, sizes, maps etc held in malloc_state, but check all of those linked or offsetted from other embedded data structures. These checks are interspersed with main code in a way that tends to minimize their run-time cost. When FOOTERS is defined, in addition to range checking, we also verify footer fields of inuse chunks, which can be used guarantee that the mstate controlling malloc/free is intact. This is a streamlined version of the approach described by William Robertson et al in "Run-time Detection of Heap-based Overflows" LISA'03 http://www.usenix.org/events/lisa03/tech/robertson.html The footer of an inuse chunk holds the xor of its mstate and a random seed, that is checked upon calls to free() and realloc(). This is (probablistically) unguessable from outside the program, but can be computed by any code successfully malloc'ing any chunk, so does not itself provide protection against code that has already broken security through some other means. Unlike Robertson et al, we always dynamically check addresses of all offset chunks (previous, next, etc). This turns out to be cheaper than relying on hashes. */ #if !INSECURE /* Check if address a is at least as high as any from MORECORE or MMAP */ #define ok_address(M, a) ((char*)(a) >= (M)->least_addr) /* Check if address of next chunk n is higher than base chunk p */ #define ok_next(p, n) ((char*)(p) < (char*)(n)) /* Check if p has its cinuse bit on */ #define ok_cinuse(p) cinuse(p) /* Check if p has its pinuse bit on */ #define ok_pinuse(p) pinuse(p) #else /* !INSECURE */ #define ok_address(M, a) (1) #define ok_next(b, n) (1) #define ok_cinuse(p) (1) #define ok_pinuse(p) (1) #endif /* !INSECURE */ #if (FOOTERS && !INSECURE) /* Check if (alleged) mstate m has expected magic field */ #define ok_magic(M) ((M)->magic == mparams.magic) #else /* (FOOTERS && !INSECURE) */ #define ok_magic(M) (1) #endif /* (FOOTERS && !INSECURE) */ /* In gcc, use __builtin_expect to minimize impact of checks */ #if !INSECURE #if defined(__GNUC__) && __GNUC__ >= 3 #define RTCHECK(e) __builtin_expect(e, 1) #else /* GNUC */ #define RTCHECK(e) (e) #endif /* GNUC */ #else /* !INSECURE */ #define RTCHECK(e) (1) #endif /* !INSECURE */ /* macros to set up inuse chunks with or without footers */ #if !FOOTERS #define mark_inuse_foot(M,p,s) /* Set cinuse bit and pinuse bit of next chunk */ #define set_inuse(M,p,s)\ ((p)->head = (((p)->head & PINUSE_BIT)|s|CINUSE_BIT),\ ((mchunkptr)(((char*)(p)) + (s)))->head |= PINUSE_BIT) /* Set cinuse and pinuse of this chunk and pinuse of next chunk */ #define set_inuse_and_pinuse(M,p,s)\ ((p)->head = (s|PINUSE_BIT|CINUSE_BIT),\ ((mchunkptr)(((char*)(p)) + (s)))->head |= PINUSE_BIT) /* Set size, cinuse and pinuse bit of this chunk */ #define set_size_and_pinuse_of_inuse_chunk(M, p, s)\ ((p)->head = (s|PINUSE_BIT|CINUSE_BIT)) #else /* FOOTERS */ /* Set foot of inuse chunk to be xor of mstate and seed */ #define mark_inuse_foot(M,p,s)\ (((mchunkptr)((char*)(p) + (s)))->prev_foot = ((size_t)(M) ^ mparams.magic)) #define get_mstate_for(p)\ ((mstate)(((mchunkptr)((char*)(p) +\ (chunksize(p))))->prev_foot ^ mparams.magic)) #define set_inuse(M,p,s)\ ((p)->head = (((p)->head & PINUSE_BIT)|s|CINUSE_BIT),\ (((mchunkptr)(((char*)(p)) + (s)))->head |= PINUSE_BIT), \ mark_inuse_foot(M,p,s)) #define set_inuse_and_pinuse(M,p,s)\ ((p)->head = (s|PINUSE_BIT|CINUSE_BIT),\ (((mchunkptr)(((char*)(p)) + (s)))->head |= PINUSE_BIT),\ mark_inuse_foot(M,p,s)) #define set_size_and_pinuse_of_inuse_chunk(M, p, s)\ ((p)->head = (s|PINUSE_BIT|CINUSE_BIT),\ mark_inuse_foot(M, p, s)) #endif /* !FOOTERS */ /* ---------------------------- setting mparams -------------------------- */ /* Initialize mparams */ static int init_mparams(void) { if (mparams.page_size == 0) { size_t s; mparams.mmap_threshold = DEFAULT_MMAP_THRESHOLD; mparams.trim_threshold = DEFAULT_TRIM_THRESHOLD; #if MORECORE_CONTIGUOUS mparams.default_mflags = USE_LOCK_BIT|USE_MMAP_BIT; #else /* MORECORE_CONTIGUOUS */ mparams.default_mflags = USE_LOCK_BIT|USE_MMAP_BIT|USE_NONCONTIGUOUS_BIT; #endif /* MORECORE_CONTIGUOUS */ #if (FOOTERS && !INSECURE) { #if USE_DEV_RANDOM int fd; unsigned char buf[sizeof(size_t)]; /* Try to use /dev/urandom, else fall back on using time */ if ((fd = open("/dev/urandom", O_RDONLY)) >= 0 && read(fd, buf, sizeof(buf)) == sizeof(buf)) { s = *((size_t *) buf); close(fd); } else #endif /* USE_DEV_RANDOM */ s = (size_t)(time(0) ^ (size_t)0x55555555U); s |= (size_t)8U; /* ensure nonzero */ s &= ~(size_t)7U; /* improve chances of fault for bad values */ } #else /* (FOOTERS && !INSECURE) */ s = (size_t)0x58585858U; #endif /* (FOOTERS && !INSECURE) */ ACQUIRE_MAGIC_INIT_LOCK(); if (mparams.magic == 0) { mparams.magic = s; #if !ONLY_MSPACES /* Set up lock for main malloc area */ INITIAL_LOCK(&gm->mutex); gm->mflags = mparams.default_mflags; #endif } RELEASE_MAGIC_INIT_LOCK(); #ifndef WIN32 mparams.page_size = malloc_getpagesize; mparams.granularity = ((DEFAULT_GRANULARITY != 0)? DEFAULT_GRANULARITY : mparams.page_size); #else /* WIN32 */ { SYSTEM_INFO system_info; GetSystemInfo(&system_info); mparams.page_size = system_info.dwPageSize; mparams.granularity = system_info.dwAllocationGranularity; } #endif /* WIN32 */ /* Sanity-check configuration: size_t must be unsigned and as wide as pointer type. ints must be at least 4 bytes. alignment must be at least 8. Alignment, min chunk size, and page size must all be powers of 2. */ if ((sizeof(size_t) != sizeof(char*)) || (MAX_SIZE_T < MIN_CHUNK_SIZE) || (sizeof(int) < 4) || (MALLOC_ALIGNMENT < (size_t)8U) || ((MALLOC_ALIGNMENT & (MALLOC_ALIGNMENT-SIZE_T_ONE)) != 0) || ((MCHUNK_SIZE & (MCHUNK_SIZE-SIZE_T_ONE)) != 0) || ((mparams.granularity & (mparams.granularity-SIZE_T_ONE)) != 0) || ((mparams.page_size & (mparams.page_size-SIZE_T_ONE)) != 0)) ABORT; } return 0; } /* support for mallopt */ static int change_mparam(int param_number, int value) { size_t val = (size_t)value; init_mparams(); switch(param_number) { case M_TRIM_THRESHOLD: mparams.trim_threshold = val; return 1; case M_GRANULARITY: if (val >= mparams.page_size && ((val & (val-1)) == 0)) { mparams.granularity = val; return 1; } else return 0; case M_MMAP_THRESHOLD: mparams.mmap_threshold = val; return 1; default: return 0; } } #if DEBUG /* ------------------------- Debugging Support --------------------------- */ /* Check properties of any chunk, whether free, inuse, mmapped etc */ static void do_check_any_chunk(mstate m, mchunkptr p) { assert((is_aligned(chunk2mem(p))) || (p->head == FENCEPOST_HEAD)); assert(ok_address(m, p)); } /* Check properties of top chunk */ static void do_check_top_chunk(mstate m, mchunkptr p) { msegmentptr sp = segment_holding(m, (char*)p); size_t sz = p->head & ~INUSE_BITS; /* third-lowest bit can be set! */ assert(sp != 0); assert((is_aligned(chunk2mem(p))) || (p->head == FENCEPOST_HEAD)); assert(ok_address(m, p)); assert(sz == m->topsize); assert(sz > 0); assert(sz == ((sp->base + sp->size) - (char*)p) - TOP_FOOT_SIZE); assert(pinuse(p)); assert(!pinuse(chunk_plus_offset(p, sz))); } /* Check properties of (inuse) mmapped chunks */ static void do_check_mmapped_chunk(mstate m, mchunkptr p) { size_t sz = chunksize(p); size_t len = (sz + (p->prev_foot & ~IS_MMAPPED_BIT) + MMAP_FOOT_PAD); assert(is_mmapped(p)); assert(use_mmap(m)); assert((is_aligned(chunk2mem(p))) || (p->head == FENCEPOST_HEAD)); assert(ok_address(m, p)); assert(!is_small(sz)); assert((len & (mparams.page_size-SIZE_T_ONE)) == 0); assert(chunk_plus_offset(p, sz)->head == FENCEPOST_HEAD); assert(chunk_plus_offset(p, sz+SIZE_T_SIZE)->head == 0); } /* Check properties of inuse chunks */ static void do_check_inuse_chunk(mstate m, mchunkptr p) { do_check_any_chunk(m, p); assert(cinuse(p)); assert(next_pinuse(p)); /* If not pinuse and not mmapped, previous chunk has OK offset */ assert(is_mmapped(p) || pinuse(p) || next_chunk(prev_chunk(p)) == p); if (is_mmapped(p)) do_check_mmapped_chunk(m, p); } /* Check properties of free chunks */ static void do_check_free_chunk(mstate m, mchunkptr p) { size_t sz = chunksize(p); mchunkptr next = chunk_plus_offset(p, sz); do_check_any_chunk(m, p); assert(!cinuse(p)); assert(!next_pinuse(p)); assert (!is_mmapped(p)); if (p != m->dv && p != m->top) { if (sz >= MIN_CHUNK_SIZE) { assert((sz & CHUNK_ALIGN_MASK) == 0); assert(is_aligned(chunk2mem(p))); assert(next->prev_foot == sz); assert(pinuse(p)); assert (next == m->top || cinuse(next)); assert(p->fd->bk == p); assert(p->bk->fd == p); } else /* markers are always of size SIZE_T_SIZE */ assert(sz == SIZE_T_SIZE); } } /* Check properties of malloced chunks at the point they are malloced */ static void do_check_malloced_chunk(mstate m, void* mem, size_t s) { if (mem != 0) { mchunkptr p = mem2chunk(mem); size_t sz = p->head & ~(PINUSE_BIT|CINUSE_BIT); do_check_inuse_chunk(m, p); assert((sz & CHUNK_ALIGN_MASK) == 0); assert(sz >= MIN_CHUNK_SIZE); assert(sz >= s); /* unless mmapped, size is less than MIN_CHUNK_SIZE more than request */ assert(is_mmapped(p) || sz < (s + MIN_CHUNK_SIZE)); } } /* Check a tree and its subtrees. */ static void do_check_tree(mstate m, tchunkptr t) { tchunkptr head = 0; tchunkptr u = t; bindex_t tindex = t->index; size_t tsize = chunksize(t); bindex_t idx; compute_tree_index(tsize, idx); assert(tindex == idx); assert(tsize >= MIN_LARGE_SIZE); assert(tsize >= minsize_for_tree_index(idx)); assert((idx == NTREEBINS-1) || (tsize < minsize_for_tree_index((idx+1)))); do { /* traverse through chain of same-sized nodes */ do_check_any_chunk(m, ((mchunkptr)u)); assert(u->index == tindex); assert(chunksize(u) == tsize); assert(!cinuse(u)); assert(!next_pinuse(u)); assert(u->fd->bk == u); assert(u->bk->fd == u); if (u->parent == 0) { assert(u->child[0] == 0); assert(u->child[1] == 0); } else { assert(head == 0); /* only one node on chain has parent */ head = u; assert(u->parent != u); assert (u->parent->child[0] == u || u->parent->child[1] == u || *((tbinptr*)(u->parent)) == u); if (u->child[0] != 0) { assert(u->child[0]->parent == u); assert(u->child[0] != u); do_check_tree(m, u->child[0]); } if (u->child[1] != 0) { assert(u->child[1]->parent == u); assert(u->child[1] != u); do_check_tree(m, u->child[1]); } if (u->child[0] != 0 && u->child[1] != 0) { assert(chunksize(u->child[0]) < chunksize(u->child[1])); } } u = u->fd; } while (u != t); assert(head != 0); } /* Check all the chunks in a treebin. */ static void do_check_treebin(mstate m, bindex_t i) { tbinptr* tb = treebin_at(m, i); tchunkptr t = *tb; int empty = (m->treemap & (1U << i)) == 0; if (t == 0) assert(empty); if (!empty) do_check_tree(m, t); } /* Check all the chunks in a smallbin. */ static void do_check_smallbin(mstate m, bindex_t i) { sbinptr b = smallbin_at(m, i); mchunkptr p = b->bk; unsigned int empty = (m->smallmap & (1U << i)) == 0; if (p == b) assert(empty); if (!empty) { for (; p != b; p = p->bk) { size_t size = chunksize(p); mchunkptr q; /* each chunk claims to be free */ do_check_free_chunk(m, p); /* chunk belongs in bin */ assert(small_index(size) == i); assert(p->bk == b || chunksize(p->bk) == chunksize(p)); /* chunk is followed by an inuse chunk */ q = next_chunk(p); if (q->head != FENCEPOST_HEAD) do_check_inuse_chunk(m, q); } } } /* Find x in a bin. Used in other check functions. */ static int bin_find(mstate m, mchunkptr x) { size_t size = chunksize(x); if (is_small(size)) { bindex_t sidx = small_index(size); sbinptr b = smallbin_at(m, sidx); if (smallmap_is_marked(m, sidx)) { mchunkptr p = b; do { if (p == x) return 1; } while ((p = p->fd) != b); } } else { bindex_t tidx; compute_tree_index(size, tidx); if (treemap_is_marked(m, tidx)) { tchunkptr t = *treebin_at(m, tidx); size_t sizebits = size << leftshift_for_tree_index(tidx); while (t != 0 && chunksize(t) != size) { t = t->child[(sizebits >> (SIZE_T_BITSIZE-SIZE_T_ONE)) & 1]; sizebits <<= 1; } if (t != 0) { tchunkptr u = t; do { if (u == (tchunkptr)x) return 1; } while ((u = u->fd) != t); } } } return 0; } /* Traverse each chunk and check it; return total */ static size_t traverse_and_check(mstate m) { size_t sum = 0; if (is_initialized(m)) { msegmentptr s = &m->seg; sum += m->topsize + TOP_FOOT_SIZE; while (s != 0) { mchunkptr q = align_as_chunk(s->base); mchunkptr lastq = 0; assert(pinuse(q)); while (segment_holds(s, q) && q != m->top && q->head != FENCEPOST_HEAD) { sum += chunksize(q); if (cinuse(q)) { assert(!bin_find(m, q)); do_check_inuse_chunk(m, q); } else { assert(q == m->dv || bin_find(m, q)); assert(lastq == 0 || cinuse(lastq)); /* Not 2 consecutive free */ do_check_free_chunk(m, q); } lastq = q; q = next_chunk(q); } s = s->next; } } return sum; } /* Check all properties of malloc_state. */ static void do_check_malloc_state(mstate m) { bindex_t i; size_t total; /* check bins */ for (i = 0; i < NSMALLBINS; ++i) do_check_smallbin(m, i); for (i = 0; i < NTREEBINS; ++i) do_check_treebin(m, i); if (m->dvsize != 0) { /* check dv chunk */ do_check_any_chunk(m, m->dv); assert(m->dvsize == chunksize(m->dv)); assert(m->dvsize >= MIN_CHUNK_SIZE); assert(bin_find(m, m->dv) == 0); } if (m->top != 0) { /* check top chunk */ do_check_top_chunk(m, m->top); /*assert(m->topsize == chunksize(m->top)); redundant */ assert(m->topsize > 0); assert(bin_find(m, m->top) == 0); } total = traverse_and_check(m); assert(total <= m->footprint); assert(m->footprint <= m->max_footprint); } #endif /* DEBUG */ /* ----------------------------- statistics ------------------------------ */ #if !NO_MALLINFO static struct mallinfo internal_mallinfo(mstate m) { struct mallinfo nm = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; if (!PREACTION(m)) { check_malloc_state(m); if (is_initialized(m)) { size_t nfree = SIZE_T_ONE; /* top always free */ size_t mfree = m->topsize + TOP_FOOT_SIZE; size_t sum = mfree; msegmentptr s = &m->seg; while (s != 0) { mchunkptr q = align_as_chunk(s->base); while (segment_holds(s, q) && q != m->top && q->head != FENCEPOST_HEAD) { size_t sz = chunksize(q); sum += sz; if (!cinuse(q)) { mfree += sz; ++nfree; } q = next_chunk(q); } s = s->next; } nm.arena = sum; nm.ordblks = nfree; nm.hblkhd = m->footprint - sum; nm.usmblks = m->max_footprint; nm.uordblks = m->footprint - mfree; nm.fordblks = mfree; nm.keepcost = m->topsize; } POSTACTION(m); } return nm; } #endif /* !NO_MALLINFO */ static void internal_malloc_stats(mstate m) { if (!PREACTION(m)) { size_t maxfp = 0; size_t fp = 0; size_t used = 0; check_malloc_state(m); if (is_initialized(m)) { msegmentptr s = &m->seg; maxfp = m->max_footprint; fp = m->footprint; used = fp - (m->topsize + TOP_FOOT_SIZE); while (s != 0) { mchunkptr q = align_as_chunk(s->base); while (segment_holds(s, q) && q != m->top && q->head != FENCEPOST_HEAD) { if (!cinuse(q)) used -= chunksize(q); q = next_chunk(q); } s = s->next; } } fprintf(stderr, "max system bytes = %10lu\n", (unsigned long)(maxfp)); fprintf(stderr, "system bytes = %10lu\n", (unsigned long)(fp)); fprintf(stderr, "in use bytes = %10lu\n", (unsigned long)(used)); POSTACTION(m); } } /* ----------------------- Operations on smallbins ----------------------- */ /* Various forms of linking and unlinking are defined as macros. Even the ones for trees, which are very long but have very short typical paths. This is ugly but reduces reliance on inlining support of compilers. */ /* Link a free chunk into a smallbin */ #define insert_small_chunk(M, P, S) {\ bindex_t I = small_index(S);\ mchunkptr B = smallbin_at(M, I);\ mchunkptr F = B;\ assert(S >= MIN_CHUNK_SIZE);\ if (!smallmap_is_marked(M, I))\ mark_smallmap(M, I);\ else if (RTCHECK(ok_address(M, B->fd)))\ F = B->fd;\ else {\ CORRUPTION_ERROR_ACTION(M);\ }\ B->fd = P;\ F->bk = P;\ P->fd = F;\ P->bk = B;\ } /* Unlink a chunk from a smallbin */ #define unlink_small_chunk(M, P, S) {\ mchunkptr F = P->fd;\ mchunkptr B = P->bk;\ bindex_t I = small_index(S);\ assert(P != B);\ assert(P != F);\ assert(chunksize(P) == small_index2size(I));\ if (F == B)\ clear_smallmap(M, I);\ else if (RTCHECK((F == smallbin_at(M,I) || ok_address(M, F)) &&\ (B == smallbin_at(M,I) || ok_address(M, B)))) {\ F->bk = B;\ B->fd = F;\ }\ else {\ CORRUPTION_ERROR_ACTION(M);\ }\ } /* Unlink the first chunk from a smallbin */ #define unlink_first_small_chunk(M, B, P, I) {\ mchunkptr F = P->fd;\ assert(P != B);\ assert(P != F);\ assert(chunksize(P) == small_index2size(I));\ if (B == F)\ clear_smallmap(M, I);\ else if (RTCHECK(ok_address(M, F))) {\ B->fd = F;\ F->bk = B;\ }\ else {\ CORRUPTION_ERROR_ACTION(M);\ }\ } /* Replace dv node, binning the old one */ /* Used only when dvsize known to be small */ #define replace_dv(M, P, S) {\ size_t DVS = M->dvsize;\ if (DVS != 0) {\ mchunkptr DV = M->dv;\ assert(is_small(DVS));\ insert_small_chunk(M, DV, DVS);\ }\ M->dvsize = S;\ M->dv = P;\ } /* ------------------------- Operations on trees ------------------------- */ /* Insert chunk into tree */ #define insert_large_chunk(M, X, S) {\ tbinptr* H;\ bindex_t I;\ compute_tree_index(S, I);\ H = treebin_at(M, I);\ X->index = I;\ X->child[0] = X->child[1] = 0;\ if (!treemap_is_marked(M, I)) {\ mark_treemap(M, I);\ *H = X;\ X->parent = (tchunkptr)H;\ X->fd = X->bk = X;\ }\ else {\ tchunkptr T = *H;\ size_t K = S << leftshift_for_tree_index(I);\ for (;;) {\ if (chunksize(T) != S) {\ tchunkptr* C = &(T->child[(K >> (SIZE_T_BITSIZE-SIZE_T_ONE)) & 1]);\ K <<= 1;\ if (*C != 0)\ T = *C;\ else if (RTCHECK(ok_address(M, C))) {\ *C = X;\ X->parent = T;\ X->fd = X->bk = X;\ break;\ }\ else {\ CORRUPTION_ERROR_ACTION(M);\ break;\ }\ }\ else {\ tchunkptr F = T->fd;\ if (RTCHECK(ok_address(M, T) && ok_address(M, F))) {\ T->fd = F->bk = X;\ X->fd = F;\ X->bk = T;\ X->parent = 0;\ break;\ }\ else {\ CORRUPTION_ERROR_ACTION(M);\ break;\ }\ }\ }\ }\ } /* Unlink steps: 1. If x is a chained node, unlink it from its same-sized fd/bk links and choose its bk node as its replacement. 2. If x was the last node of its size, but not a leaf node, it must be replaced with a leaf node (not merely one with an open left or right), to make sure that lefts and rights of descendents correspond properly to bit masks. We use the rightmost descendent of x. We could use any other leaf, but this is easy to locate and tends to counteract removal of leftmosts elsewhere, and so keeps paths shorter than minimally guaranteed. This doesn't loop much because on average a node in a tree is near the bottom. 3. If x is the base of a chain (i.e., has parent links) relink x's parent and children to x's replacement (or null if none). */ #define unlink_large_chunk(M, X) {\ tchunkptr XP = X->parent;\ tchunkptr R;\ if (X->bk != X) {\ tchunkptr F = X->fd;\ R = X->bk;\ if (RTCHECK(ok_address(M, F))) {\ F->bk = R;\ R->fd = F;\ }\ else {\ CORRUPTION_ERROR_ACTION(M);\ }\ }\ else {\ tchunkptr* RP;\ if (((R = *(RP = &(X->child[1]))) != 0) ||\ ((R = *(RP = &(X->child[0]))) != 0)) {\ tchunkptr* CP;\ while ((*(CP = &(R->child[1])) != 0) ||\ (*(CP = &(R->child[0])) != 0)) {\ R = *(RP = CP);\ }\ if (RTCHECK(ok_address(M, RP)))\ *RP = 0;\ else {\ CORRUPTION_ERROR_ACTION(M);\ }\ }\ }\ if (XP != 0) {\ tbinptr* H = treebin_at(M, X->index);\ if (X == *H) {\ if ((*H = R) == 0) \ clear_treemap(M, X->index);\ }\ else if (RTCHECK(ok_address(M, XP))) {\ if (XP->child[0] == X) \ XP->child[0] = R;\ else \ XP->child[1] = R;\ }\ else\ CORRUPTION_ERROR_ACTION(M);\ if (R != 0) {\ if (RTCHECK(ok_address(M, R))) {\ tchunkptr C0, C1;\ R->parent = XP;\ if ((C0 = X->child[0]) != 0) {\ if (RTCHECK(ok_address(M, C0))) {\ R->child[0] = C0;\ C0->parent = R;\ }\ else\ CORRUPTION_ERROR_ACTION(M);\ }\ if ((C1 = X->child[1]) != 0) {\ if (RTCHECK(ok_address(M, C1))) {\ R->child[1] = C1;\ C1->parent = R;\ }\ else\ CORRUPTION_ERROR_ACTION(M);\ }\ }\ else\ CORRUPTION_ERROR_ACTION(M);\ }\ }\ } /* Relays to large vs small bin operations */ #define insert_chunk(M, P, S)\ if (is_small(S)) insert_small_chunk(M, P, S)\ else { tchunkptr TP = (tchunkptr)(P); insert_large_chunk(M, TP, S); } #define unlink_chunk(M, P, S)\ if (is_small(S)) unlink_small_chunk(M, P, S)\ else { tchunkptr TP = (tchunkptr)(P); unlink_large_chunk(M, TP); } /* Relays to internal calls to malloc/free from realloc, memalign etc */ #if ONLY_MSPACES #define internal_malloc(m, b) mspace_malloc(m, b) #define internal_free(m, mem) mspace_free(m,mem); #else /* ONLY_MSPACES */ #if MSPACES #define internal_malloc(m, b)\ ((m == gm) ? dlmalloc(b) : mspace_malloc((mspace)m, b)) /* GKMOD here */ #define internal_free(m, mem)\ ((m == gm) ? dlfree(mem) : mspace_free((mspace)m, mem)); /* GKMOD here */ #else /* MSPACES */ #define internal_malloc(m, b) dlmalloc(b) #define internal_free(m, mem) dlfree(mem) #endif /* MSPACES */ #endif /* ONLY_MSPACES */ /* ----------------------- Direct-mmapping chunks ----------------------- */ /* Directly mmapped chunks are set up with an offset to the start of the mmapped region stored in the prev_foot field of the chunk. This allows reconstruction of the required argument to MUNMAP when freed, and also allows adjustment of the returned chunk to meet alignment requirements (especially in memalign). There is also enough space allocated to hold a fake next chunk of size SIZE_T_SIZE to maintain the PINUSE bit so frees can be checked. */ /* Malloc using mmap */ static void* mmap_alloc(mstate m, size_t nb) { size_t mmsize = mmap_align(nb + SIX_SIZE_T_SIZES + CHUNK_ALIGN_MASK); if (mmsize > nb) { /* Check for wrap around 0 */ char* mm = (char*)(DIRECT_MMAP(mmsize)); if (mm != CMFAIL) { size_t offset = align_offset(chunk2mem(mm)); size_t psize = mmsize - offset - MMAP_FOOT_PAD; mchunkptr p = (mchunkptr)(mm + offset); p->prev_foot = offset | IS_MMAPPED_BIT; (p)->head = (psize|CINUSE_BIT); mark_inuse_foot(m, p, psize); chunk_plus_offset(p, psize)->head = FENCEPOST_HEAD; chunk_plus_offset(p, psize+SIZE_T_SIZE)->head = 0; if (mm < m->least_addr) m->least_addr = mm; if ((m->footprint += mmsize) > m->max_footprint) m->max_footprint = m->footprint; assert(is_aligned(chunk2mem(p))); check_mmapped_chunk(m, p); return chunk2mem(p); } } return 0; } /* Realloc using mmap */ static mchunkptr mmap_resize(mstate m, mchunkptr oldp, size_t nb) { size_t oldsize = chunksize(oldp); if (is_small(nb)) /* Can't shrink mmap regions below small size */ return 0; /* Keep old chunk if big enough but not too big */ if (oldsize >= nb + SIZE_T_SIZE && (oldsize - nb) <= (mparams.granularity << 1)) return oldp; else { size_t offset = oldp->prev_foot & ~IS_MMAPPED_BIT; size_t oldmmsize = oldsize + offset + MMAP_FOOT_PAD; size_t newmmsize = mmap_align(nb + SIX_SIZE_T_SIZES + CHUNK_ALIGN_MASK); char* cp = (char*)CALL_MREMAP((char*)oldp - offset, oldmmsize, newmmsize, 1); if (cp != CMFAIL) { mchunkptr newp = (mchunkptr)(cp + offset); size_t psize = newmmsize - offset - MMAP_FOOT_PAD; newp->head = (psize|CINUSE_BIT); mark_inuse_foot(m, newp, psize); chunk_plus_offset(newp, psize)->head = FENCEPOST_HEAD; chunk_plus_offset(newp, psize+SIZE_T_SIZE)->head = 0; if (cp < m->least_addr) m->least_addr = cp; if ((m->footprint += newmmsize - oldmmsize) > m->max_footprint) m->max_footprint = m->footprint; check_mmapped_chunk(m, newp); return newp; } } return 0; } /* -------------------------- mspace management -------------------------- */ /* Initialize top chunk and its size */ static void init_top(mstate m, mchunkptr p, size_t psize) { /* Ensure alignment */ size_t offset = align_offset(chunk2mem(p)); p = (mchunkptr)((char*)p + offset); psize -= offset; m->top = p; m->topsize = psize; p->head = psize | PINUSE_BIT; /* set size of fake trailing chunk holding overhead space only once */ chunk_plus_offset(p, psize)->head = TOP_FOOT_SIZE; m->trim_check = mparams.trim_threshold; /* reset on each update */ } /* Initialize bins for a new mstate that is otherwise zeroed out */ static void init_bins(mstate m) { /* Establish circular links for smallbins */ bindex_t i; for (i = 0; i < NSMALLBINS; ++i) { sbinptr bin = smallbin_at(m,i); bin->fd = bin->bk = bin; } } #if PROCEED_ON_ERROR /* default corruption action */ static void reset_on_error(mstate m) { int i; ++malloc_corruption_error_count; /* Reinitialize fields to forget about all memory */ m->smallbins = m->treebins = 0; m->dvsize = m->topsize = 0; m->seg.base = 0; m->seg.size = 0; m->seg.next = 0; m->top = m->dv = 0; for (i = 0; i < NTREEBINS; ++i) *treebin_at(m, i) = 0; init_bins(m); } #endif /* PROCEED_ON_ERROR */ /* Allocate chunk and prepend remainder with chunk in successor base. */ static void* prepend_alloc(mstate m, char* newbase, char* oldbase, size_t nb) { mchunkptr p = align_as_chunk(newbase); mchunkptr oldfirst = align_as_chunk(oldbase); size_t psize = (char*)oldfirst - (char*)p; mchunkptr q = chunk_plus_offset(p, nb); size_t qsize = psize - nb; set_size_and_pinuse_of_inuse_chunk(m, p, nb); assert((char*)oldfirst > (char*)q); assert(pinuse(oldfirst)); assert(qsize >= MIN_CHUNK_SIZE); /* consolidate remainder with first chunk of old base */ if (oldfirst == m->top) { size_t tsize = m->topsize += qsize; m->top = q; q->head = tsize | PINUSE_BIT; check_top_chunk(m, q); } else if (oldfirst == m->dv) { size_t dsize = m->dvsize += qsize; m->dv = q; set_size_and_pinuse_of_free_chunk(q, dsize); } else { if (!cinuse(oldfirst)) { size_t nsize = chunksize(oldfirst); unlink_chunk(m, oldfirst, nsize); oldfirst = chunk_plus_offset(oldfirst, nsize); qsize += nsize; } set_free_with_pinuse(q, qsize, oldfirst); insert_chunk(m, q, qsize); check_free_chunk(m, q); } check_malloced_chunk(m, chunk2mem(p), nb); return chunk2mem(p); } /* Add a segment to hold a new noncontiguous region */ static void add_segment(mstate m, char* tbase, size_t tsize, flag_t mmapped) { /* Determine locations and sizes of segment, fenceposts, old top */ char* old_top = (char*)m->top; msegmentptr oldsp = segment_holding(m, old_top); char* old_end = oldsp->base + oldsp->size; size_t ssize = pad_request(sizeof(struct malloc_segment)); char* rawsp = old_end - (ssize + FOUR_SIZE_T_SIZES + CHUNK_ALIGN_MASK); size_t offset = align_offset(chunk2mem(rawsp)); char* asp = rawsp + offset; char* csp = (asp < (old_top + MIN_CHUNK_SIZE))? old_top : asp; mchunkptr sp = (mchunkptr)csp; msegmentptr ss = (msegmentptr)(chunk2mem(sp)); mchunkptr tnext = chunk_plus_offset(sp, ssize); mchunkptr p = tnext; int nfences = 0; /* reset top to new space */ init_top(m, (mchunkptr)tbase, tsize - TOP_FOOT_SIZE); /* Set up segment record */ assert(is_aligned(ss)); set_size_and_pinuse_of_inuse_chunk(m, sp, ssize); *ss = m->seg; /* Push current record */ m->seg.base = tbase; m->seg.size = tsize; m->seg.sflags = mmapped; m->seg.next = ss; /* Insert trailing fenceposts */ for (;;) { mchunkptr nextp = chunk_plus_offset(p, SIZE_T_SIZE); p->head = FENCEPOST_HEAD; ++nfences; if ((char*)(&(nextp->head)) < old_end) p = nextp; else break; } assert(nfences >= 2); /* Insert the rest of old top into a bin as an ordinary free chunk */ if (csp != old_top) { mchunkptr q = (mchunkptr)old_top; size_t psize = csp - old_top; mchunkptr tn = chunk_plus_offset(q, psize); set_free_with_pinuse(q, psize, tn); insert_chunk(m, q, psize); } check_top_chunk(m, m->top); } /* -------------------------- System allocation -------------------------- */ /* Get memory from system using MORECORE or MMAP */ static void* sys_alloc(mstate m, size_t nb) { char* tbase = CMFAIL; size_t tsize = 0; flag_t mmap_flag = 0; init_mparams(); /* Directly map large chunks */ if (use_mmap(m) && nb >= mparams.mmap_threshold) { void* mem = mmap_alloc(m, nb); if (mem != 0) return mem; } /* Try getting memory in any of three ways (in most-preferred to least-preferred order): 1. A call to MORECORE that can normally contiguously extend memory. (disabled if not MORECORE_CONTIGUOUS or not HAVE_MORECORE or or main space is mmapped or a previous contiguous call failed) 2. A call to MMAP new space (disabled if not HAVE_MMAP). Note that under the default settings, if MORECORE is unable to fulfill a request, and HAVE_MMAP is true, then mmap is used as a noncontiguous system allocator. This is a useful backup strategy for systems with holes in address spaces -- in this case sbrk cannot contiguously expand the heap, but mmap may be able to find space. 3. A call to MORECORE that cannot usually contiguously extend memory. (disabled if not HAVE_MORECORE) */ if (MORECORE_CONTIGUOUS && !use_noncontiguous(m)) { char* br = CMFAIL; msegmentptr ss = (m->top == 0)? 0 : segment_holding(m, (char*)m->top); size_t asize = 0; ACQUIRE_MORECORE_LOCK(); if (ss == 0) { /* First time through or recovery */ char* base = (char*)CALL_MORECORE(0); if (base != CMFAIL) { asize = granularity_align(nb + TOP_FOOT_SIZE + SIZE_T_ONE); /* Adjust to end on a page boundary */ if (!is_page_aligned(base)) asize += (page_align((size_t)base) - (size_t)base); /* Can't call MORECORE if size is negative when treated as signed */ if (asize < HALF_MAX_SIZE_T && (br = (char*)(CALL_MORECORE(asize))) == base) { tbase = base; tsize = asize; } } } else { /* Subtract out existing available top space from MORECORE request. */ asize = granularity_align(nb - m->topsize + TOP_FOOT_SIZE + SIZE_T_ONE); /* Use mem here only if it did continuously extend old space */ if (asize < HALF_MAX_SIZE_T && (br = (char*)(CALL_MORECORE(asize))) == ss->base+ss->size) { tbase = br; tsize = asize; } } if (tbase == CMFAIL) { /* Cope with partial failure */ if (br != CMFAIL) { /* Try to use/extend the space we did get */ if (asize < HALF_MAX_SIZE_T && asize < nb + TOP_FOOT_SIZE + SIZE_T_ONE) { size_t esize = granularity_align(nb + TOP_FOOT_SIZE + SIZE_T_ONE - asize); if (esize < HALF_MAX_SIZE_T) { char* end = (char*)CALL_MORECORE(esize); if (end != CMFAIL) asize += esize; else { /* Can't use; try to release */ (void) CALL_MORECORE(-asize); br = CMFAIL; } } } } if (br != CMFAIL) { /* Use the space we did get */ tbase = br; tsize = asize; } else disable_contiguous(m); /* Don't try contiguous path in the future */ } RELEASE_MORECORE_LOCK(); } if (HAVE_MMAP && tbase == CMFAIL) { /* Try MMAP */ size_t req = nb + TOP_FOOT_SIZE + SIZE_T_ONE; size_t rsize = granularity_align(req); if (rsize > nb) { /* Fail if wraps around zero */ char* mp = (char*)(CALL_MMAP(rsize)); if (mp != CMFAIL) { tbase = mp; tsize = rsize; mmap_flag = IS_MMAPPED_BIT; } } } if (HAVE_MORECORE && tbase == CMFAIL) { /* Try noncontiguous MORECORE */ size_t asize = granularity_align(nb + TOP_FOOT_SIZE + SIZE_T_ONE); if (asize < HALF_MAX_SIZE_T) { char* br = CMFAIL; char* end = CMFAIL; ACQUIRE_MORECORE_LOCK(); br = (char*)(CALL_MORECORE(asize)); end = (char*)(CALL_MORECORE(0)); RELEASE_MORECORE_LOCK(); if (br != CMFAIL && end != CMFAIL && br < end) { size_t ssize = end - br; if (ssize > nb + TOP_FOOT_SIZE) { tbase = br; tsize = ssize; } } } } if (tbase != CMFAIL) { if ((m->footprint += tsize) > m->max_footprint) m->max_footprint = m->footprint; if (!is_initialized(m)) { /* first-time initialization */ m->seg.base = m->least_addr = tbase; m->seg.size = tsize; m->seg.sflags = mmap_flag; m->magic = mparams.magic; m->release_checks = MAX_RELEASE_CHECK_RATE; init_bins(m); #if !ONLY_MSPACES if (is_global(m)) init_top(m, (mchunkptr)tbase, tsize - TOP_FOOT_SIZE); else #endif { /* Offset top by embedded malloc_state */ mchunkptr mn = next_chunk(mem2chunk(m)); init_top(m, mn, (size_t)((tbase + tsize) - (char*)mn) -TOP_FOOT_SIZE); } } else { /* Try to merge with an existing segment */ msegmentptr sp = &m->seg; /* Only consider most recent segment if traversal suppressed */ while (sp != 0 && tbase != sp->base + sp->size) sp = (NO_SEGMENT_TRAVERSAL) ? 0 : sp->next; if (sp != 0 && !is_extern_segment(sp) && (sp->sflags & IS_MMAPPED_BIT) == mmap_flag && segment_holds(sp, m->top)) { /* append */ sp->size += tsize; init_top(m, m->top, m->topsize + tsize); } else { if (tbase < m->least_addr) m->least_addr = tbase; sp = &m->seg; while (sp != 0 && sp->base != tbase + tsize) sp = (NO_SEGMENT_TRAVERSAL) ? 0 : sp->next; if (sp != 0 && !is_extern_segment(sp) && (sp->sflags & IS_MMAPPED_BIT) == mmap_flag) { char* oldbase = sp->base; sp->base = tbase; sp->size += tsize; return prepend_alloc(m, tbase, oldbase, nb); } else add_segment(m, tbase, tsize, mmap_flag); } } if (nb < m->topsize) { /* Allocate from new or extended top space */ size_t rsize = m->topsize -= nb; mchunkptr p = m->top; mchunkptr r = m->top = chunk_plus_offset(p, nb); r->head = rsize | PINUSE_BIT; set_size_and_pinuse_of_inuse_chunk(m, p, nb); check_top_chunk(m, m->top); check_malloced_chunk(m, chunk2mem(p), nb); return chunk2mem(p); } } MALLOC_FAILURE_ACTION; return 0; } /* ----------------------- system deallocation -------------------------- */ /* Unmap and unlink any mmapped segments that don't contain used chunks */ static size_t release_unused_segments(mstate m) { size_t released = 0; int nsegs = 0; msegmentptr pred = &m->seg; msegmentptr sp = pred->next; while (sp != 0) { char* base = sp->base; size_t size = sp->size; msegmentptr next = sp->next; ++nsegs; if (is_mmapped_segment(sp) && !is_extern_segment(sp)) { mchunkptr p = align_as_chunk(base); size_t psize = chunksize(p); /* Can unmap if first chunk holds entire segment and not pinned */ if (!cinuse(p) && (char*)p + psize >= base + size - TOP_FOOT_SIZE) { tchunkptr tp = (tchunkptr)p; assert(segment_holds(sp, (char*)sp)); if (p == m->dv) { m->dv = 0; m->dvsize = 0; } else { unlink_large_chunk(m, tp); } if (CALL_MUNMAP(base, size) == 0) { released += size; m->footprint -= size; /* unlink obsoleted record */ sp = pred; sp->next = next; } else { /* back out if cannot unmap */ insert_large_chunk(m, tp, psize); } } } if (NO_SEGMENT_TRAVERSAL) /* scan only first segment */ break; pred = sp; sp = next; } /* Reset check counter */ m->release_checks = ((nsegs > MAX_RELEASE_CHECK_RATE)? nsegs : MAX_RELEASE_CHECK_RATE); return released; } static int sys_trim(mstate m, size_t pad) { size_t released = 0; if (pad < MAX_REQUEST && is_initialized(m)) { pad += TOP_FOOT_SIZE; /* ensure enough room for segment overhead */ if (m->topsize > pad) { /* Shrink top space in granularity-size units, keeping at least one */ size_t unit = mparams.granularity; size_t extra = ((m->topsize - pad + (unit - SIZE_T_ONE)) / unit - SIZE_T_ONE) * unit; msegmentptr sp = segment_holding(m, (char*)m->top); if (!is_extern_segment(sp)) { if (is_mmapped_segment(sp)) { if (HAVE_MMAP && sp->size >= extra && !has_segment_link(m, sp)) { /* can't shrink if pinned */ size_t newsize = sp->size - extra; /* Prefer mremap, fall back to munmap */ if ((CALL_MREMAP(sp->base, sp->size, newsize, 0) != MFAIL) || (CALL_MUNMAP(sp->base + newsize, extra) == 0)) { released = extra; } } } else if (HAVE_MORECORE) { if (extra >= HALF_MAX_SIZE_T) /* Avoid wrapping negative */ extra = (HALF_MAX_SIZE_T) + SIZE_T_ONE - unit; ACQUIRE_MORECORE_LOCK(); { /* Make sure end of memory is where we last set it. */ char* old_br = (char*)(CALL_MORECORE(0)); if (old_br == sp->base + sp->size) { char* rel_br = (char*)(CALL_MORECORE(-extra)); char* new_br = (char*)(CALL_MORECORE(0)); if (rel_br != CMFAIL && new_br < old_br) released = old_br - new_br; } } RELEASE_MORECORE_LOCK(); } } if (released != 0) { sp->size -= released; m->footprint -= released; init_top(m, m->top, m->topsize - released); check_top_chunk(m, m->top); } } /* Unmap any unused mmapped segments */ if (HAVE_MMAP) released += release_unused_segments(m); /* On failure, disable autotrim to avoid repeated failed future calls */ if (released == 0 && m->topsize > m->trim_check) m->trim_check = MAX_SIZE_T; } return (released != 0)? 1 : 0; } /* ---------------------------- malloc support --------------------------- */ /* allocate a large request from the best fitting chunk in a treebin */ static void* tmalloc_large(mstate m, size_t nb) { tchunkptr v = 0; size_t rsize = -nb; /* Unsigned negation */ tchunkptr t; bindex_t idx; compute_tree_index(nb, idx); if ((t = *treebin_at(m, idx)) != 0) { /* Traverse tree for this bin looking for node with size == nb */ size_t sizebits = nb << leftshift_for_tree_index(idx); tchunkptr rst = 0; /* The deepest untaken right subtree */ for (;;) { tchunkptr rt; size_t trem = chunksize(t) - nb; if (trem < rsize) { v = t; if ((rsize = trem) == 0) break; } rt = t->child[1]; t = t->child[(sizebits >> (SIZE_T_BITSIZE-SIZE_T_ONE)) & 1]; if (rt != 0 && rt != t) rst = rt; if (t == 0) { t = rst; /* set t to least subtree holding sizes > nb */ break; } sizebits <<= 1; } } if (t == 0 && v == 0) { /* set t to root of next non-empty treebin */ binmap_t leftbits = left_bits(idx2bit(idx)) & m->treemap; if (leftbits != 0) { bindex_t i; binmap_t leastbit = least_bit(leftbits); compute_bit2idx(leastbit, i); t = *treebin_at(m, i); } } while (t != 0) { /* find smallest of tree or subtree */ size_t trem = chunksize(t) - nb; if (trem < rsize) { rsize = trem; v = t; } t = leftmost_child(t); } /* If dv is a better fit, return 0 so malloc will use it */ if (v != 0 && rsize < (size_t)(m->dvsize - nb)) { if (RTCHECK(ok_address(m, v))) { /* split */ mchunkptr r = chunk_plus_offset(v, nb); assert(chunksize(v) == rsize + nb); if (RTCHECK(ok_next(v, r))) { unlink_large_chunk(m, v); if (rsize < MIN_CHUNK_SIZE) set_inuse_and_pinuse(m, v, (rsize + nb)); else { set_size_and_pinuse_of_inuse_chunk(m, v, nb); set_size_and_pinuse_of_free_chunk(r, rsize); insert_chunk(m, r, rsize); } return chunk2mem(v); } } CORRUPTION_ERROR_ACTION(m); } return 0; } /* allocate a small request from the best fitting chunk in a treebin */ static void* tmalloc_small(mstate m, size_t nb) { tchunkptr t, v; size_t rsize; bindex_t i; binmap_t leastbit = least_bit(m->treemap); compute_bit2idx(leastbit, i); v = t = *treebin_at(m, i); rsize = chunksize(t) - nb; while ((t = leftmost_child(t)) != 0) { size_t trem = chunksize(t) - nb; if (trem < rsize) { rsize = trem; v = t; } } if (RTCHECK(ok_address(m, v))) { mchunkptr r = chunk_plus_offset(v, nb); assert(chunksize(v) == rsize + nb); if (RTCHECK(ok_next(v, r))) { unlink_large_chunk(m, v); if (rsize < MIN_CHUNK_SIZE) set_inuse_and_pinuse(m, v, (rsize + nb)); else { set_size_and_pinuse_of_inuse_chunk(m, v, nb); set_size_and_pinuse_of_free_chunk(r, rsize); replace_dv(m, r, rsize); } return chunk2mem(v); } } CORRUPTION_ERROR_ACTION(m); return 0; } /* --------------------------- realloc support --------------------------- */ static void* internal_realloc(mstate m, void* oldmem, size_t bytes) { if (bytes >= MAX_REQUEST) { MALLOC_FAILURE_ACTION; return 0; } if (!PREACTION(m)) { mchunkptr oldp = mem2chunk(oldmem); size_t oldsize = chunksize(oldp); mchunkptr next = chunk_plus_offset(oldp, oldsize); mchunkptr newp = 0; void* extra = 0; /* Try to either shrink or extend into top. Else malloc-copy-free */ if (RTCHECK(ok_address(m, oldp) && ok_cinuse(oldp) && ok_next(oldp, next) && ok_pinuse(next))) { size_t nb = request2size(bytes); if (is_mmapped(oldp)) newp = mmap_resize(m, oldp, nb); else if (oldsize >= nb) { /* already big enough */ size_t rsize = oldsize - nb; newp = oldp; if (rsize >= MIN_CHUNK_SIZE) { mchunkptr remainder = chunk_plus_offset(newp, nb); set_inuse(m, newp, nb); set_inuse(m, remainder, rsize); extra = chunk2mem(remainder); } } else if (next == m->top && oldsize + m->topsize > nb) { /* Expand into top */ size_t newsize = oldsize + m->topsize; size_t newtopsize = newsize - nb; mchunkptr newtop = chunk_plus_offset(oldp, nb); set_inuse(m, oldp, nb); newtop->head = newtopsize |PINUSE_BIT; m->top = newtop; m->topsize = newtopsize; newp = oldp; } } else { USAGE_ERROR_ACTION(m, oldmem); POSTACTION(m); return 0; } POSTACTION(m); if (newp != 0) { if (extra != 0) { internal_free(m, extra); } check_inuse_chunk(m, newp); return chunk2mem(newp); } else { void* newmem = internal_malloc(m, bytes); if (newmem != 0) { size_t oc = oldsize - overhead_for(oldp); memcpy(newmem, oldmem, (oc < bytes)? oc : bytes); internal_free(m, oldmem); } return newmem; } } return 0; } /* --------------------------- memalign support -------------------------- */ static void* internal_memalign(mstate m, size_t alignment, size_t bytes) { if (alignment <= MALLOC_ALIGNMENT) /* Can just use malloc */ return internal_malloc(m, bytes); if (alignment < MIN_CHUNK_SIZE) /* must be at least a minimum chunk size */ alignment = MIN_CHUNK_SIZE; if ((alignment & (alignment-SIZE_T_ONE)) != 0) {/* Ensure a power of 2 */ size_t a = MALLOC_ALIGNMENT << 1; while (a < alignment) a <<= 1; alignment = a; } if (bytes >= MAX_REQUEST - alignment) { if (m != 0) { /* Test isn't needed but avoids compiler warning */ MALLOC_FAILURE_ACTION; } } else { size_t nb = request2size(bytes); size_t req = nb + alignment + MIN_CHUNK_SIZE - CHUNK_OVERHEAD; char* mem = (char*)internal_malloc(m, req); if (mem != 0) { void* leader = 0; void* trailer = 0; mchunkptr p = mem2chunk(mem); if (PREACTION(m)) return 0; if ((((size_t)(mem)) % alignment) != 0) { /* misaligned */ /* Find an aligned spot inside chunk. Since we need to give back leading space in a chunk of at least MIN_CHUNK_SIZE, if the first calculation places us at a spot with less than MIN_CHUNK_SIZE leader, we can move to the next aligned spot. We've allocated enough total room so that this is always possible. */ char* br = (char*)mem2chunk((size_t)(((size_t)(mem + alignment - SIZE_T_ONE)) & -alignment)); char* pos = ((size_t)(br - (char*)(p)) >= MIN_CHUNK_SIZE)? br : br+alignment; mchunkptr newp = (mchunkptr)pos; size_t leadsize = pos - (char*)(p); size_t newsize = chunksize(p) - leadsize; if (is_mmapped(p)) { /* For mmapped chunks, just adjust offset */ newp->prev_foot = p->prev_foot + leadsize; newp->head = (newsize|CINUSE_BIT); } else { /* Otherwise, give back leader, use the rest */ set_inuse(m, newp, newsize); set_inuse(m, p, leadsize); leader = chunk2mem(p); } p = newp; } /* Give back spare room at the end */ if (!is_mmapped(p)) { size_t size = chunksize(p); if (size > nb + MIN_CHUNK_SIZE) { size_t remainder_size = size - nb; mchunkptr remainder = chunk_plus_offset(p, nb); set_inuse(m, p, nb); set_inuse(m, remainder, remainder_size); trailer = chunk2mem(remainder); } } assert (chunksize(p) >= nb); assert((((size_t)(chunk2mem(p))) % alignment) == 0); check_inuse_chunk(m, p); POSTACTION(m); if (leader != 0) { internal_free(m, leader); } if (trailer != 0) { internal_free(m, trailer); } return chunk2mem(p); } } return 0; } /* ------------------------ comalloc/coalloc support --------------------- */ static void** ialloc(mstate m, size_t n_elements, size_t* sizes, int opts, void* chunks[]) { /* This provides common support for independent_X routines, handling all of the combinations that can result. The opts arg has: bit 0 set if all elements are same size (using sizes[0]) bit 1 set if elements should be zeroed */ size_t element_size; /* chunksize of each element, if all same */ size_t contents_size; /* total size of elements */ size_t array_size; /* request size of pointer array */ void* mem; /* malloced aggregate space */ mchunkptr p; /* corresponding chunk */ size_t remainder_size; /* remaining bytes while splitting */ void** marray; /* either "chunks" or malloced ptr array */ mchunkptr array_chunk; /* chunk for malloced ptr array */ flag_t was_enabled; /* to disable mmap */ size_t size; size_t i; /* compute array length, if needed */ if (chunks != 0) { if (n_elements == 0) return chunks; /* nothing to do */ marray = chunks; array_size = 0; } else { /* if empty req, must still return chunk representing empty array */ if (n_elements == 0) return (void**)internal_malloc(m, 0); marray = 0; array_size = request2size(n_elements * (sizeof(void*))); } /* compute total element size */ if (opts & 0x1) { /* all-same-size */ element_size = request2size(*sizes); contents_size = n_elements * element_size; } else { /* add up all the sizes */ element_size = 0; contents_size = 0; for (i = 0; i != n_elements; ++i) contents_size += request2size(sizes[i]); } size = contents_size + array_size; /* Allocate the aggregate chunk. First disable direct-mmapping so malloc won't use it, since we would not be able to later free/realloc space internal to a segregated mmap region. */ was_enabled = use_mmap(m); disable_mmap(m); mem = internal_malloc(m, size - CHUNK_OVERHEAD); if (was_enabled) enable_mmap(m); if (mem == 0) return 0; if (PREACTION(m)) return 0; p = mem2chunk(mem); remainder_size = chunksize(p); assert(!is_mmapped(p)); if (opts & 0x2) { /* optionally clear the elements */ memset((size_t*)mem, 0, remainder_size - SIZE_T_SIZE - array_size); } /* If not provided, allocate the pointer array as final part of chunk */ if (marray == 0) { size_t array_chunk_size; array_chunk = chunk_plus_offset(p, contents_size); array_chunk_size = remainder_size - contents_size; marray = (void**) (chunk2mem(array_chunk)); set_size_and_pinuse_of_inuse_chunk(m, array_chunk, array_chunk_size); remainder_size = contents_size; } /* split out elements */ for (i = 0; ; ++i) { marray[i] = chunk2mem(p); if (i != n_elements-1) { if (element_size != 0) size = element_size; else size = request2size(sizes[i]); remainder_size -= size; set_size_and_pinuse_of_inuse_chunk(m, p, size); p = chunk_plus_offset(p, size); } else { /* the final element absorbs any overallocation slop */ set_size_and_pinuse_of_inuse_chunk(m, p, remainder_size); break; } } #if DEBUG if (marray != chunks) { /* final element must have exactly exhausted chunk */ if (element_size != 0) { assert(remainder_size == element_size); } else { assert(remainder_size == request2size(sizes[i])); } check_inuse_chunk(m, mem2chunk(marray)); } for (i = 0; i != n_elements; ++i) check_inuse_chunk(m, mem2chunk(marray[i])); #endif /* DEBUG */ POSTACTION(m); return marray; } /* -------------------------- public routines ---------------------------- */ #if !ONLY_MSPACES void* dlmalloc(size_t bytes) { /* Basic algorithm: If a small request (< 256 bytes minus per-chunk overhead): 1. If one exists, use a remainderless chunk in associated smallbin. (Remainderless means that there are too few excess bytes to represent as a chunk.) 2. If it is big enough, use the dv chunk, which is normally the chunk adjacent to the one used for the most recent small request. 3. If one exists, split the smallest available chunk in a bin, saving remainder in dv. 4. If it is big enough, use the top chunk. 5. If available, get memory from system and use it Otherwise, for a large request: 1. Find the smallest available binned chunk that fits, and use it if it is better fitting than dv chunk, splitting if necessary. 2. If better fitting than any binned chunk, use the dv chunk. 3. If it is big enough, use the top chunk. 4. If request size >= mmap threshold, try to directly mmap this chunk. 5. If available, get memory from system and use it The ugly goto's here ensure that postaction occurs along all paths. */ if (!PREACTION(gm)) { void* mem; size_t nb; if (bytes <= MAX_SMALL_REQUEST) { bindex_t idx; binmap_t smallbits; nb = (bytes < MIN_REQUEST)? MIN_CHUNK_SIZE : pad_request(bytes); idx = small_index(nb); smallbits = gm->smallmap >> idx; if ((smallbits & 0x3U) != 0) { /* Remainderless fit to a smallbin. */ mchunkptr b, p; idx += ~smallbits & 1; /* Uses next bin if idx empty */ b = smallbin_at(gm, idx); p = b->fd; assert(chunksize(p) == small_index2size(idx)); unlink_first_small_chunk(gm, b, p, idx); set_inuse_and_pinuse(gm, p, small_index2size(idx)); mem = chunk2mem(p); check_malloced_chunk(gm, mem, nb); goto postaction; } else if (nb > gm->dvsize) { if (smallbits != 0) { /* Use chunk in next nonempty smallbin */ mchunkptr b, p, r; size_t rsize; bindex_t i; binmap_t leftbits = (smallbits << idx) & left_bits(idx2bit(idx)); binmap_t leastbit = least_bit(leftbits); compute_bit2idx(leastbit, i); b = smallbin_at(gm, i); p = b->fd; assert(chunksize(p) == small_index2size(i)); unlink_first_small_chunk(gm, b, p, i); rsize = small_index2size(i) - nb; /* Fit here cannot be remainderless if 4byte sizes */ if (SIZE_T_SIZE != 4 && rsize < MIN_CHUNK_SIZE) set_inuse_and_pinuse(gm, p, small_index2size(i)); else { set_size_and_pinuse_of_inuse_chunk(gm, p, nb); r = chunk_plus_offset(p, nb); set_size_and_pinuse_of_free_chunk(r, rsize); replace_dv(gm, r, rsize); } mem = chunk2mem(p); check_malloced_chunk(gm, mem, nb); goto postaction; } else if (gm->treemap != 0 && (mem = tmalloc_small(gm, nb)) != 0) { check_malloced_chunk(gm, mem, nb); goto postaction; } } } else if (bytes >= MAX_REQUEST) nb = MAX_SIZE_T; /* Too big to allocate. Force failure (in sys alloc) */ else { nb = pad_request(bytes); if (gm->treemap != 0 && (mem = tmalloc_large(gm, nb)) != 0) { check_malloced_chunk(gm, mem, nb); goto postaction; } } if (nb <= gm->dvsize) { size_t rsize = gm->dvsize - nb; mchunkptr p = gm->dv; if (rsize >= MIN_CHUNK_SIZE) { /* split dv */ mchunkptr r = gm->dv = chunk_plus_offset(p, nb); gm->dvsize = rsize; set_size_and_pinuse_of_free_chunk(r, rsize); set_size_and_pinuse_of_inuse_chunk(gm, p, nb); } else { /* exhaust dv */ size_t dvs = gm->dvsize; gm->dvsize = 0; gm->dv = 0; set_inuse_and_pinuse(gm, p, dvs); } mem = chunk2mem(p); check_malloced_chunk(gm, mem, nb); goto postaction; } else if (nb < gm->topsize) { /* Split top */ size_t rsize = gm->topsize -= nb; mchunkptr p = gm->top; mchunkptr r = gm->top = chunk_plus_offset(p, nb); r->head = rsize | PINUSE_BIT; set_size_and_pinuse_of_inuse_chunk(gm, p, nb); mem = chunk2mem(p); check_top_chunk(gm, gm->top); check_malloced_chunk(gm, mem, nb); goto postaction; } mem = sys_alloc(gm, nb); postaction: POSTACTION(gm); return mem; } return 0; } void dlfree(void* mem) { /* Consolidate freed chunks with preceeding or succeeding bordering free chunks, if they exist, and then place in a bin. Intermixed with special cases for top, dv, mmapped chunks, and usage errors. */ if (mem != 0) { mchunkptr p = mem2chunk(mem); #if FOOTERS mstate fm = get_mstate_for(p); if (!ok_magic(fm)) { USAGE_ERROR_ACTION(fm, p); return; } #else /* FOOTERS */ #define fm gm #endif /* FOOTERS */ if (!PREACTION(fm)) { check_inuse_chunk(fm, p); if (RTCHECK(ok_address(fm, p) && ok_cinuse(p))) { size_t psize = chunksize(p); mchunkptr next = chunk_plus_offset(p, psize); if (!pinuse(p)) { size_t prevsize = p->prev_foot; if ((prevsize & IS_MMAPPED_BIT) != 0) { prevsize &= ~IS_MMAPPED_BIT; psize += prevsize + MMAP_FOOT_PAD; if (CALL_MUNMAP((char*)p - prevsize, psize) == 0) fm->footprint -= psize; goto postaction; } else { mchunkptr prev = chunk_minus_offset(p, prevsize); psize += prevsize; p = prev; if (RTCHECK(ok_address(fm, prev))) { /* consolidate backward */ if (p != fm->dv) { unlink_chunk(fm, p, prevsize); } else if ((next->head & INUSE_BITS) == INUSE_BITS) { fm->dvsize = psize; set_free_with_pinuse(p, psize, next); goto postaction; } } else goto erroraction; } } if (RTCHECK(ok_next(p, next) && ok_pinuse(next))) { if (!cinuse(next)) { /* consolidate forward */ if (next == fm->top) { size_t tsize = fm->topsize += psize; fm->top = p; p->head = tsize | PINUSE_BIT; if (p == fm->dv) { fm->dv = 0; fm->dvsize = 0; } if (should_trim(fm, tsize)) sys_trim(fm, 0); goto postaction; } else if (next == fm->dv) { size_t dsize = fm->dvsize += psize; fm->dv = p; set_size_and_pinuse_of_free_chunk(p, dsize); goto postaction; } else { size_t nsize = chunksize(next); psize += nsize; unlink_chunk(fm, next, nsize); set_size_and_pinuse_of_free_chunk(p, psize); if (p == fm->dv) { fm->dvsize = psize; goto postaction; } } } else set_free_with_pinuse(p, psize, next); if (is_small(psize)) { insert_small_chunk(fm, p, psize); check_free_chunk(fm, p); } else { tchunkptr tp = (tchunkptr)p; insert_large_chunk(fm, tp, psize); check_free_chunk(fm, p); if (--fm->release_checks == 0) release_unused_segments(fm); } goto postaction; } } erroraction: USAGE_ERROR_ACTION(fm, p); postaction: POSTACTION(fm); } } #if !FOOTERS #undef fm #endif /* FOOTERS */ } void* dlcalloc(size_t n_elements, size_t elem_size) { void* mem; size_t req = 0; if (n_elements != 0) { req = n_elements * elem_size; if (((n_elements | elem_size) & ~(size_t)0xffff) && (req / n_elements != elem_size)) req = MAX_SIZE_T; /* force downstream failure on overflow */ } mem = dlmalloc(req); if (mem != 0 && calloc_must_clear(mem2chunk(mem))) memset(mem, 0, req); return mem; } void* dlrealloc(void* oldmem, size_t bytes) { if (oldmem == 0) return dlmalloc(bytes); #ifdef REALLOC_ZERO_BYTES_FREES if (bytes == 0) { dlfree(oldmem); return 0; } #endif /* REALLOC_ZERO_BYTES_FREES */ else { #if ! FOOTERS mstate m = gm; #else /* FOOTERS */ mstate m = get_mstate_for(mem2chunk(oldmem)); if (!ok_magic(m)) { USAGE_ERROR_ACTION(m, oldmem); return 0; } #endif /* FOOTERS */ return internal_realloc(m, oldmem, bytes); } } void* dlmemalign(size_t alignment, size_t bytes) { return internal_memalign(gm, alignment, bytes); } void** dlindependent_calloc(size_t n_elements, size_t elem_size, void* chunks[]) { size_t sz = elem_size; /* serves as 1-element array */ return ialloc(gm, n_elements, &sz, 3, chunks); } void** dlindependent_comalloc(size_t n_elements, size_t sizes[], void* chunks[]) { return ialloc(gm, n_elements, sizes, 0, chunks); } void* dlvalloc(size_t bytes) { size_t pagesz; init_mparams(); pagesz = mparams.page_size; return dlmemalign(pagesz, bytes); } void* dlpvalloc(size_t bytes) { size_t pagesz; init_mparams(); pagesz = mparams.page_size; return dlmemalign(pagesz, (bytes + pagesz - SIZE_T_ONE) & ~(pagesz - SIZE_T_ONE)); } int dlmalloc_trim(size_t pad) { int result = 0; if (!PREACTION(gm)) { result = sys_trim(gm, pad); POSTACTION(gm); } return result; } size_t dlmalloc_footprint(void) { return gm->footprint; } size_t dlmalloc_max_footprint(void) { return gm->max_footprint; } #if !NO_MALLINFO struct mallinfo dlmallinfo(void) { return internal_mallinfo(gm); } #endif /* NO_MALLINFO */ void dlmalloc_stats() { internal_malloc_stats(gm); } size_t dlmalloc_usable_size(void* mem) { if (mem != 0) { mchunkptr p = mem2chunk(mem); if (cinuse(p)) return chunksize(p) - overhead_for(p); } return 0; } int dlmallopt(int param_number, int value) { return change_mparam(param_number, value); } #endif /* !ONLY_MSPACES */ /* ----------------------------- user mspaces ---------------------------- */ #if MSPACES static mstate init_user_mstate(char* tbase, size_t tsize) { size_t msize = pad_request(sizeof(struct malloc_state)); mchunkptr mn; mchunkptr msp = align_as_chunk(tbase); mstate m = (mstate)(chunk2mem(msp)); memset(m, 0, msize); INITIAL_LOCK(&m->mutex); msp->head = (msize|PINUSE_BIT|CINUSE_BIT); m->seg.base = m->least_addr = tbase; m->seg.size = m->footprint = m->max_footprint = tsize; m->magic = mparams.magic; m->release_checks = MAX_RELEASE_CHECK_RATE; m->mflags = mparams.default_mflags; m->extp = 0; m->exts = 0; disable_contiguous(m); init_bins(m); mn = next_chunk(mem2chunk(m)); init_top(m, mn, (size_t)((tbase + tsize) - (char*)mn) - TOP_FOOT_SIZE); check_top_chunk(m, m->top); return m; } mspace create_mspace(size_t capacity, int locked) { mstate m = 0; size_t msize = pad_request(sizeof(struct malloc_state)); init_mparams(); /* Ensure pagesize etc initialized */ if (capacity < (size_t) -(msize + TOP_FOOT_SIZE + mparams.page_size)) { size_t rs = ((capacity == 0)? mparams.granularity : (capacity + TOP_FOOT_SIZE + msize)); size_t tsize = granularity_align(rs); char* tbase = (char*)(CALL_MMAP(tsize)); if (tbase != CMFAIL) { m = init_user_mstate(tbase, tsize); m->seg.sflags = IS_MMAPPED_BIT; set_lock(m, locked); } } return (mspace)m; } mspace create_mspace_with_base(void* base, size_t capacity, int locked) { mstate m = 0; size_t msize = pad_request(sizeof(struct malloc_state)); init_mparams(); /* Ensure pagesize etc initialized */ if (capacity > msize + TOP_FOOT_SIZE && capacity < (size_t) -(msize + TOP_FOOT_SIZE + mparams.page_size)) { m = init_user_mstate((char*)base, capacity); m->seg.sflags = EXTERN_BIT; set_lock(m, locked); } return (mspace)m; } size_t destroy_mspace(mspace msp) { size_t freed = 0; mstate ms = (mstate)msp; if (ok_magic(ms)) { msegmentptr sp = &ms->seg; while (sp != 0) { char* base = sp->base; size_t size = sp->size; flag_t flag = sp->sflags; sp = sp->next; if ((flag & IS_MMAPPED_BIT) && !(flag & EXTERN_BIT) && CALL_MUNMAP(base, size) == 0) freed += size; } } else { USAGE_ERROR_ACTION(ms,ms); } return freed; } /* mspace versions of routines are near-clones of the global versions. This is not so nice but better than the alternatives. */ void* mspace_malloc(mspace msp, size_t bytes) { mstate ms = (mstate)msp; if (!ok_magic(ms)) { USAGE_ERROR_ACTION(ms,ms); return 0; } if (!PREACTION(ms)) { void* mem; size_t nb; if (bytes <= MAX_SMALL_REQUEST) { bindex_t idx; binmap_t smallbits; nb = (bytes < MIN_REQUEST)? MIN_CHUNK_SIZE : pad_request(bytes); idx = small_index(nb); smallbits = ms->smallmap >> idx; if ((smallbits & 0x3U) != 0) { /* Remainderless fit to a smallbin. */ mchunkptr b, p; idx += ~smallbits & 1; /* Uses next bin if idx empty */ b = smallbin_at(ms, idx); p = b->fd; assert(chunksize(p) == small_index2size(idx)); unlink_first_small_chunk(ms, b, p, idx); set_inuse_and_pinuse(ms, p, small_index2size(idx)); mem = chunk2mem(p); check_malloced_chunk(ms, mem, nb); goto postaction; } else if (nb > ms->dvsize) { if (smallbits != 0) { /* Use chunk in next nonempty smallbin */ mchunkptr b, p, r; size_t rsize; bindex_t i; binmap_t leftbits = (smallbits << idx) & left_bits(idx2bit(idx)); binmap_t leastbit = least_bit(leftbits); compute_bit2idx(leastbit, i); b = smallbin_at(ms, i); p = b->fd; assert(chunksize(p) == small_index2size(i)); unlink_first_small_chunk(ms, b, p, i); rsize = small_index2size(i) - nb; /* Fit here cannot be remainderless if 4byte sizes */ if (SIZE_T_SIZE != 4 && rsize < MIN_CHUNK_SIZE) set_inuse_and_pinuse(ms, p, small_index2size(i)); else { set_size_and_pinuse_of_inuse_chunk(ms, p, nb); r = chunk_plus_offset(p, nb); set_size_and_pinuse_of_free_chunk(r, rsize); replace_dv(ms, r, rsize); } mem = chunk2mem(p); check_malloced_chunk(ms, mem, nb); goto postaction; } else if (ms->treemap != 0 && (mem = tmalloc_small(ms, nb)) != 0) { check_malloced_chunk(ms, mem, nb); goto postaction; } } } else if (bytes >= MAX_REQUEST) nb = MAX_SIZE_T; /* Too big to allocate. Force failure (in sys alloc) */ else { nb = pad_request(bytes); if (ms->treemap != 0 && (mem = tmalloc_large(ms, nb)) != 0) { check_malloced_chunk(ms, mem, nb); goto postaction; } } if (nb <= ms->dvsize) { size_t rsize = ms->dvsize - nb; mchunkptr p = ms->dv; if (rsize >= MIN_CHUNK_SIZE) { /* split dv */ mchunkptr r = ms->dv = chunk_plus_offset(p, nb); ms->dvsize = rsize; set_size_and_pinuse_of_free_chunk(r, rsize); set_size_and_pinuse_of_inuse_chunk(ms, p, nb); } else { /* exhaust dv */ size_t dvs = ms->dvsize; ms->dvsize = 0; ms->dv = 0; set_inuse_and_pinuse(ms, p, dvs); } mem = chunk2mem(p); check_malloced_chunk(ms, mem, nb); goto postaction; } else if (nb < ms->topsize) { /* Split top */ size_t rsize = ms->topsize -= nb; mchunkptr p = ms->top; mchunkptr r = ms->top = chunk_plus_offset(p, nb); r->head = rsize | PINUSE_BIT; set_size_and_pinuse_of_inuse_chunk(ms, p, nb); mem = chunk2mem(p); check_top_chunk(ms, ms->top); check_malloced_chunk(ms, mem, nb); goto postaction; } mem = sys_alloc(ms, nb); postaction: POSTACTION(ms); return mem; } return 0; } void mspace_free(mspace msp, void* mem) { if (mem != 0) { mchunkptr p = mem2chunk(mem); #if FOOTERS mstate fm = get_mstate_for(p); #else /* FOOTERS */ mstate fm = (mstate)msp; #endif /* FOOTERS */ if (!ok_magic(fm)) { USAGE_ERROR_ACTION(fm, p); return; } if (!PREACTION(fm)) { check_inuse_chunk(fm, p); if (RTCHECK(ok_address(fm, p) && ok_cinuse(p))) { size_t psize = chunksize(p); mchunkptr next = chunk_plus_offset(p, psize); if (!pinuse(p)) { size_t prevsize = p->prev_foot; if ((prevsize & IS_MMAPPED_BIT) != 0) { prevsize &= ~IS_MMAPPED_BIT; psize += prevsize + MMAP_FOOT_PAD; if (CALL_MUNMAP((char*)p - prevsize, psize) == 0) fm->footprint -= psize; goto postaction; } else { mchunkptr prev = chunk_minus_offset(p, prevsize); psize += prevsize; p = prev; if (RTCHECK(ok_address(fm, prev))) { /* consolidate backward */ if (p != fm->dv) { unlink_chunk(fm, p, prevsize); } else if ((next->head & INUSE_BITS) == INUSE_BITS) { fm->dvsize = psize; set_free_with_pinuse(p, psize, next); goto postaction; } } else goto erroraction; } } if (RTCHECK(ok_next(p, next) && ok_pinuse(next))) { if (!cinuse(next)) { /* consolidate forward */ if (next == fm->top) { size_t tsize = fm->topsize += psize; fm->top = p; p->head = tsize | PINUSE_BIT; if (p == fm->dv) { fm->dv = 0; fm->dvsize = 0; } if (should_trim(fm, tsize)) sys_trim(fm, 0); goto postaction; } else if (next == fm->dv) { size_t dsize = fm->dvsize += psize; fm->dv = p; set_size_and_pinuse_of_free_chunk(p, dsize); goto postaction; } else { size_t nsize = chunksize(next); psize += nsize; unlink_chunk(fm, next, nsize); set_size_and_pinuse_of_free_chunk(p, psize); if (p == fm->dv) { fm->dvsize = psize; goto postaction; } } } else set_free_with_pinuse(p, psize, next); if (is_small(psize)) { insert_small_chunk(fm, p, psize); check_free_chunk(fm, p); } else { tchunkptr tp = (tchunkptr)p; insert_large_chunk(fm, tp, psize); check_free_chunk(fm, p); if (--fm->release_checks == 0) release_unused_segments(fm); } goto postaction; } } erroraction: USAGE_ERROR_ACTION(fm, p); postaction: POSTACTION(fm); } } } void* mspace_calloc(mspace msp, size_t n_elements, size_t elem_size) { void* mem; size_t req = 0; mstate ms = (mstate)msp; if (!ok_magic(ms)) { USAGE_ERROR_ACTION(ms,ms); return 0; } if (n_elements != 0) { req = n_elements * elem_size; if (((n_elements | elem_size) & ~(size_t)0xffff) && (req / n_elements != elem_size)) req = MAX_SIZE_T; /* force downstream failure on overflow */ } mem = internal_malloc(ms, req); if (mem != 0 && calloc_must_clear(mem2chunk(mem))) memset(mem, 0, req); return mem; } void* mspace_realloc(mspace msp, void* oldmem, size_t bytes) { if (oldmem == 0) return mspace_malloc(msp, bytes); #ifdef REALLOC_ZERO_BYTES_FREES if (bytes == 0) { mspace_free(msp, oldmem); return 0; } #endif /* REALLOC_ZERO_BYTES_FREES */ else { #if FOOTERS mchunkptr p = mem2chunk(oldmem); mstate ms = get_mstate_for(p); #else /* FOOTERS */ mstate ms = (mstate)msp; #endif /* FOOTERS */ if (!ok_magic(ms)) { USAGE_ERROR_ACTION(ms,ms); return 0; } return internal_realloc(ms, oldmem, bytes); } } void* mspace_memalign(mspace msp, size_t alignment, size_t bytes) { mstate ms = (mstate)msp; if (!ok_magic(ms)) { USAGE_ERROR_ACTION(ms,ms); return 0; } return internal_memalign(ms, alignment, bytes); } void** mspace_independent_calloc(mspace msp, size_t n_elements, size_t elem_size, void* chunks[]) { size_t sz = elem_size; /* serves as 1-element array */ mstate ms = (mstate)msp; if (!ok_magic(ms)) { USAGE_ERROR_ACTION(ms,ms); return 0; } return ialloc(ms, n_elements, &sz, 3, chunks); } void** mspace_independent_comalloc(mspace msp, size_t n_elements, size_t sizes[], void* chunks[]) { mstate ms = (mstate)msp; if (!ok_magic(ms)) { USAGE_ERROR_ACTION(ms,ms); return 0; } return ialloc(ms, n_elements, sizes, 0, chunks); } int mspace_trim(mspace msp, size_t pad) { int result = 0; mstate ms = (mstate)msp; if (ok_magic(ms)) { if (!PREACTION(ms)) { result = sys_trim(ms, pad); POSTACTION(ms); } } else { USAGE_ERROR_ACTION(ms,ms); } return result; } void mspace_malloc_stats(mspace msp) { mstate ms = (mstate)msp; if (ok_magic(ms)) { internal_malloc_stats(ms); } else { USAGE_ERROR_ACTION(ms,ms); } } size_t mspace_footprint(mspace msp) { size_t result = 0; mstate ms = (mstate)msp; if (ok_magic(ms)) { result = ms->footprint; } else { USAGE_ERROR_ACTION(ms,ms); } return result; } size_t mspace_max_footprint(mspace msp) { size_t result = 0; mstate ms = (mstate)msp; if (ok_magic(ms)) { result = ms->max_footprint; } else { USAGE_ERROR_ACTION(ms,ms); } return result; } #if !NO_MALLINFO struct mallinfo mspace_mallinfo(mspace msp) { mstate ms = (mstate)msp; if (!ok_magic(ms)) { USAGE_ERROR_ACTION(ms,ms); } return internal_mallinfo(ms); } #endif /* NO_MALLINFO */ size_t mspace_usable_size(void* mem) { if (mem != 0) { mchunkptr p = mem2chunk(mem); if (cinuse(p)) return chunksize(p) - overhead_for(p); } return 0; } int mspace_mallopt(int param_number, int value) { return change_mparam(param_number, value); } #endif /* MSPACES */ /* -------------------- Alternative MORECORE functions ------------------- */ /* Guidelines for creating a custom version of MORECORE: * For best performance, MORECORE should allocate in multiples of pagesize. * MORECORE may allocate more memory than requested. (Or even less, but this will usually result in a malloc failure.) * MORECORE must not allocate memory when given argument zero, but instead return one past the end address of memory from previous nonzero call. * For best performance, consecutive calls to MORECORE with positive arguments should return increasing addresses, indicating that space has been contiguously extended. * Even though consecutive calls to MORECORE need not return contiguous addresses, it must be OK for malloc'ed chunks to span multiple regions in those cases where they do happen to be contiguous. * MORECORE need not handle negative arguments -- it may instead just return MFAIL when given negative arguments. Negative arguments are always multiples of pagesize. MORECORE must not misinterpret negative args as large positive unsigned args. You can suppress all such calls from even occurring by defining MORECORE_CANNOT_TRIM, As an example alternative MORECORE, here is a custom allocator kindly contributed for pre-OSX macOS. It uses virtually but not necessarily physically contiguous non-paged memory (locked in, present and won't get swapped out). You can use it by uncommenting this section, adding some #includes, and setting up the appropriate defines above: #define MORECORE osMoreCore There is also a shutdown routine that should somehow be called for cleanup upon program exit. #define MAX_POOL_ENTRIES 100 #define MINIMUM_MORECORE_SIZE (64 * 1024U) static int next_os_pool; void *our_os_pools[MAX_POOL_ENTRIES]; void *osMoreCore(int size) { void *ptr = 0; static void *sbrk_top = 0; if (size > 0) { if (size < MINIMUM_MORECORE_SIZE) size = MINIMUM_MORECORE_SIZE; if (CurrentExecutionLevel() == kTaskLevel) ptr = PoolAllocateResident(size + RM_PAGE_SIZE, 0); if (ptr == 0) { return (void *) MFAIL; } // save ptrs so they can be freed during cleanup our_os_pools[next_os_pool] = ptr; next_os_pool++; ptr = (void *) ((((size_t) ptr) + RM_PAGE_MASK) & ~RM_PAGE_MASK); sbrk_top = (char *) ptr + size; return ptr; } else if (size < 0) { // we don't currently support shrink behavior return (void *) MFAIL; } else { return sbrk_top; } } // cleanup any allocated memory pools // called as last thing before shutting down driver void osCleanupMem(void) { void **ptr; for (ptr = our_os_pools; ptr < &our_os_pools[MAX_POOL_ENTRIES]; ptr++) if (*ptr) { PoolDeallocate(*ptr); *ptr = 0; } } */ /* ----------------------------------------------------------------------- History: V2.8.4 (not yet released) * Fix bad error check in mspace_footprint * Adaptations for ptmalloc, courtesy of Wolfram Gloger. * Reentrant spin locks, courtesy of Earl Chew and others * Win32 improvements, courtesy of Niall Douglas and Earl Chew * Add NO_SEGMENT_TRAVERSAL and MAX_RELEASE_CHECK_RATE options * Various small adjustments to reduce warnings on some compilers * Extension hook in malloc_state V2.8.3 Thu Sep 22 11:16:32 2005 Doug Lea (dl at gee) * Add max_footprint functions * Ensure all appropriate literals are size_t * Fix conditional compilation problem for some #define settings * Avoid concatenating segments with the one provided in create_mspace_with_base * Rename some variables to avoid compiler shadowing warnings * Use explicit lock initialization. * Better handling of sbrk interference. * Simplify and fix segment insertion, trimming and mspace_destroy * Reinstate REALLOC_ZERO_BYTES_FREES option from 2.7.x * Thanks especially to Dennis Flanagan for help on these. V2.8.2 Sun Jun 12 16:01:10 2005 Doug Lea (dl at gee) * Fix memalign brace error. V2.8.1 Wed Jun 8 16:11:46 2005 Doug Lea (dl at gee) * Fix improper #endif nesting in C++ * Add explicit casts needed for C++ V2.8.0 Mon May 30 14:09:02 2005 Doug Lea (dl at gee) * Use trees for large bins * Support mspaces * Use segments to unify sbrk-based and mmap-based system allocation, removing need for emulation on most platforms without sbrk. * Default safety checks * Optional footer checks. Thanks to William Robertson for the idea. * Internal code refactoring * Incorporate suggestions and platform-specific changes. Thanks to Dennis Flanagan, Colin Plumb, Niall Douglas, Aaron Bachmann, Emery Berger, and others. * Speed up non-fastbin processing enough to remove fastbins. * Remove useless cfree() to avoid conflicts with other apps. * Remove internal memcpy, memset. Compilers handle builtins better. * Remove some options that no one ever used and rename others. V2.7.2 Sat Aug 17 09:07:30 2002 Doug Lea (dl at gee) * Fix malloc_state bitmap array misdeclaration V2.7.1 Thu Jul 25 10:58:03 2002 Doug Lea (dl at gee) * Allow tuning of FIRST_SORTED_BIN_SIZE * Use PTR_UINT as type for all ptr->int casts. Thanks to John Belmonte. * Better detection and support for non-contiguousness of MORECORE. Thanks to Andreas Mueller, Conal Walsh, and Wolfram Gloger * Bypass most of malloc if no frees. Thanks To Emery Berger. * Fix freeing of old top non-contiguous chunk im sysmalloc. * Raised default trim and map thresholds to 256K. * Fix mmap-related #defines. Thanks to Lubos Lunak. * Fix copy macros; added LACKS_FCNTL_H. Thanks to Neal Walfield. * Branch-free bin calculation * Default trim and mmap thresholds now 256K. V2.7.0 Sun Mar 11 14:14:06 2001 Doug Lea (dl at gee) * Introduce independent_comalloc and independent_calloc. Thanks to Michael Pachos for motivation and help. * Make optional .h file available * Allow > 2GB requests on 32bit systems. * new WIN32 sbrk, mmap, munmap, lock code from . Thanks also to Andreas Mueller , and Anonymous. * Allow override of MALLOC_ALIGNMENT (Thanks to Ruud Waij for helping test this.) * memalign: check alignment arg * realloc: don't try to shift chunks backwards, since this leads to more fragmentation in some programs and doesn't seem to help in any others. * Collect all cases in malloc requiring system memory into sysmalloc * Use mmap as backup to sbrk * Place all internal state in malloc_state * Introduce fastbins (although similar to 2.5.1) * Many minor tunings and cosmetic improvements * Introduce USE_PUBLIC_MALLOC_WRAPPERS, USE_MALLOC_LOCK * Introduce MALLOC_FAILURE_ACTION, MORECORE_CONTIGUOUS Thanks to Tony E. Bennett and others. * Include errno.h to support default failure action. V2.6.6 Sun Dec 5 07:42:19 1999 Doug Lea (dl at gee) * return null for negative arguments * Added Several WIN32 cleanups from Martin C. Fong * Add 'LACKS_SYS_PARAM_H' for those systems without 'sys/param.h' (e.g. WIN32 platforms) * Cleanup header file inclusion for WIN32 platforms * Cleanup code to avoid Microsoft Visual C++ compiler complaints * Add 'USE_DL_PREFIX' to quickly allow co-existence with existing memory allocation routines * Set 'malloc_getpagesize' for WIN32 platforms (needs more work) * Use 'assert' rather than 'ASSERT' in WIN32 code to conform to usage of 'assert' in non-WIN32 code * Improve WIN32 'sbrk()' emulation's 'findRegion()' routine to avoid infinite loop * Always call 'fREe()' rather than 'free()' V2.6.5 Wed Jun 17 15:57:31 1998 Doug Lea (dl at gee) * Fixed ordering problem with boundary-stamping V2.6.3 Sun May 19 08:17:58 1996 Doug Lea (dl at gee) * Added pvalloc, as recommended by H.J. Liu * Added 64bit pointer support mainly from Wolfram Gloger * Added anonymously donated WIN32 sbrk emulation * Malloc, calloc, getpagesize: add optimizations from Raymond Nijssen * malloc_extend_top: fix mask error that caused wastage after foreign sbrks * Add linux mremap support code from HJ Liu V2.6.2 Tue Dec 5 06:52:55 1995 Doug Lea (dl at gee) * Integrated most documentation with the code. * Add support for mmap, with help from Wolfram Gloger (Gloger@lrz.uni-muenchen.de). * Use last_remainder in more cases. * Pack bins using idea from colin@nyx10.cs.du.edu * Use ordered bins instead of best-fit threshhold * Eliminate block-local decls to simplify tracing and debugging. * Support another case of realloc via move into top * Fix error occuring when initial sbrk_base not word-aligned. * Rely on page size for units instead of SBRK_UNIT to avoid surprises about sbrk alignment conventions. * Add mallinfo, mallopt. Thanks to Raymond Nijssen (raymond@es.ele.tue.nl) for the suggestion. * Add `pad' argument to malloc_trim and top_pad mallopt parameter. * More precautions for cases where other routines call sbrk, courtesy of Wolfram Gloger (Gloger@lrz.uni-muenchen.de). * Added macros etc., allowing use in linux libc from H.J. Lu (hjl@gnu.ai.mit.edu) * Inverted this history list V2.6.1 Sat Dec 2 14:10:57 1995 Doug Lea (dl at gee) * Re-tuned and fixed to behave more nicely with V2.6.0 changes. * Removed all preallocation code since under current scheme the work required to undo bad preallocations exceeds the work saved in good cases for most test programs. * No longer use return list or unconsolidated bins since no scheme using them consistently outperforms those that don't given above changes. * Use best fit for very large chunks to prevent some worst-cases. * Added some support for debugging V2.6.0 Sat Nov 4 07:05:23 1995 Doug Lea (dl at gee) * Removed footers when chunks are in use. Thanks to Paul Wilson (wilson@cs.texas.edu) for the suggestion. V2.5.4 Wed Nov 1 07:54:51 1995 Doug Lea (dl at gee) * Added malloc_trim, with help from Wolfram Gloger (wmglo@Dent.MED.Uni-Muenchen.DE). V2.5.3 Tue Apr 26 10:16:01 1994 Doug Lea (dl at g) V2.5.2 Tue Apr 5 16:20:40 1994 Doug Lea (dl at g) * realloc: try to expand in both directions * malloc: swap order of clean-bin strategy; * realloc: only conditionally expand backwards * Try not to scavenge used bins * Use bin counts as a guide to preallocation * Occasionally bin return list chunks in first scan * Add a few optimizations from colin@nyx10.cs.du.edu V2.5.1 Sat Aug 14 15:40:43 1993 Doug Lea (dl at g) * faster bin computation & slightly different binning * merged all consolidations to one part of malloc proper (eliminating old malloc_find_space & malloc_clean_bin) * Scan 2 returns chunks (not just 1) * Propagate failure in realloc if malloc returns 0 * Add stuff to allow compilation on non-ANSI compilers from kpv@research.att.com V2.5 Sat Aug 7 07:41:59 1993 Doug Lea (dl at g.oswego.edu) * removed potential for odd address access in prev_chunk * removed dependency on getpagesize.h * misc cosmetics and a bit more internal documentation * anticosmetics: mangled names in macros to evade debugger strangeness * tested on sparc, hp-700, dec-mips, rs6000 with gcc & native cc (hp, dec only) allowing Detlefs & Zorn comparison study (in SIGPLAN Notices.) Trial version Fri Aug 28 13:14:29 1992 Doug Lea (dl at g.oswego.edu) * Based loosely on libg++-1.2X malloc. (It retains some of the overall structure of old version, but most details differ.) */ PyMetis-0.90/src/gklib/error.c0000640000175000017500000001102010662171744016022 0ustar andreasandreas/*! \file error.c \brief Various error-handling functions This file contains functions dealing with error reporting and termination \author George \date 1/1/2007 \version\verbatim $Id: error.c 1065 2007-03-06 23:11:52Z karypis $ \endverbatim */ #define _GK_ERROR_C_ /* this is needed to properly declare the gk_return_to_entry as an extern function in GKlib.h */ #include /* This is the jmp_buf for the graceful exit in case of severy error */ __thread jmp_buf gk_return_to_entry; /* These are the holders of the old singal handlers for the trapped signals */ typedef void (*sighandler_t)(int); /* this should be in signals.h, but is not there */ static __thread sighandler_t old_SIGFPE_handler; static __thread sighandler_t old_SIGILL_handler; static __thread sighandler_t old_SIGSEGV_handler; #ifndef WIN32 static __thread sighandler_t old_SIGBUS_handler; #endif static __thread sighandler_t old_SIGABRT_handler; static __thread sighandler_t old_SIGMEM_handler; /* Custom signal */ static __thread sighandler_t old_SIGERR_handler; /* Custom signal */ /************************************************************************* * This function prints an error message and exits **************************************************************************/ void errexit(char *f_str,...) { va_list argp; va_start(argp, f_str); vfprintf(stderr, f_str, argp); va_end(argp); fprintf(stderr,"\n"); fflush(stderr); exit(-2); } /************************************************************************* * This function prints an error message and raises a signum signal **************************************************************************/ void gk_errexit(int signum, char *f_str,...) { va_list argp; va_start(argp, f_str); vfprintf(stderr, f_str, argp); va_end(argp); fprintf(stderr,"\n"); fflush(stderr); raise(signum); } /*************************************************************************** * This function sets a number of signal handlers and sets the return point * of a longjmp ****************************************************************************/ void gk_SetSignalHandlers() { old_SIGFPE_handler = signal(SIGFPE, gk_NonLocalExit_Handler); old_SIGILL_handler = signal(SIGILL, gk_NonLocalExit_Handler); old_SIGSEGV_handler = signal(SIGSEGV, gk_NonLocalExit_Handler); #ifndef WIN32 old_SIGBUS_handler = signal(SIGBUS, gk_NonLocalExit_Handler); #endif old_SIGABRT_handler = signal(SIGABRT, gk_NonLocalExit_Handler); if (SIGMEM != SIGABRT) old_SIGMEM_handler = signal(SIGMEM, gk_NonLocalExit_Handler); if (SIGERR != SIGABRT) old_SIGERR_handler = signal(SIGERR, gk_NonLocalExit_Handler); } /*************************************************************************** * This function sets the handlers for the signals to their default handlers ****************************************************************************/ void gk_UnsetSignalHandlers() { signal(SIGFPE, old_SIGFPE_handler); signal(SIGILL, old_SIGILL_handler); signal(SIGSEGV, old_SIGSEGV_handler); #ifndef WIN32 signal(SIGBUS, old_SIGBUS_handler); #endif signal(SIGABRT, old_SIGABRT_handler); if (SIGMEM != SIGABRT) signal(SIGMEM, old_SIGMEM_handler); if (SIGERR != SIGABRT) signal(SIGERR, old_SIGERR_handler); } /************************************************************************* * This function is the handler for SIGUSR1 that implements the cleaning up * process prior to a non-local exit. **************************************************************************/ void gk_NonLocalExit_Handler(int signum) { gk_malloc_cleanup(); //printf("Calling longjmp...\n"); longjmp(gk_return_to_entry, signum); } /*************************************************************************/ /*! \brief Thread-safe implementation of strerror() */ /**************************************************************************/ char *gk_strerror(int errnum) { static __thread char buf[1024]; strerror_r(errnum, buf, 1024); buf[1023] = '\0'; return buf; } /************************************************************************* * This function prints a backtrace of callinf functions **************************************************************************/ void PrintBackTrace() { #ifdef LINUX void *array[10]; int i, size; char **strings; size = backtrace(array, 10); strings = backtrace_symbols(array, size); printf("Obtained %d stack frames.\n", size); for (i=0; i /************************************************************************* * This function checks if a file exists **************************************************************************/ int gk_fexists(char *fname) { struct stat status; if (stat(fname, &status) == -1) return 0; return S_ISREG(status.st_mode); } /************************************************************************* * This function checks if a directory exists **************************************************************************/ int gk_dexists(char *dirname) { struct stat status; if (stat(dirname, &status) == -1) return 0; return S_ISDIR(status.st_mode); } /*************************************************************************/ /*! \brief Returns the size of the file in bytes This function returns the size of a file as a 64 bit integer. If there were any errors in stat'ing the file, -1 is returned. \note That due to the -1 return code, the maximum file size is limited to 63 bits (which I guess is okay for now). */ /**************************************************************************/ intmax_t gk_getfsize(char *filename) { struct stat status; if (stat(filename, &status) == -1) return -1; return (intmax_t)(status.st_size); } /************************************************************************* * This function gets some basic statistics about the file **************************************************************************/ void gk_getfilestats(char *fname, int *r_nlines, int *r_ntokens, int *r_nbytes) { int nlines, ntokens, nbytes; size_t lnlen; FILE *fpin; char *line=NULL, delim[] = " \t", *token; fpin = gk_fopen(fname, "r", "gk_GetFileStats"); nlines = ntokens = nbytes = 0; while (gk_getline(&line, &lnlen, fpin)) { nlines++; nbytes += strlen(line); token = strtok(line, delim); while (token) { ntokens++; token = strtok(NULL, delim); } } gk_fclose(fpin); *r_nlines = nlines; *r_ntokens = ntokens; *r_nbytes = nbytes; gk_free((void *)&line, LTERM); } /************************************************************************* * This function takes in a potentially full path specification of a file * and just returns a string containing just the basename of the file. * The basename is derived from the actual filename by stripping the last * .ext part. **************************************************************************/ char *gk_getbasename(char *path) { char *startptr, *endptr; char *basename; if ((startptr = strrchr(path, '/')) == NULL) startptr = path; else startptr = startptr+1; basename = gk_strdup(startptr); if ((endptr = strrchr(basename, '.')) != NULL) *endptr = '\0'; return basename; } /************************************************************************* * This function takes in a potentially full path specification of a file * and just returns a string corresponding to its file extension. The * extension of a file is considered to be the string right after the * last '.' character. **************************************************************************/ char *gk_getextname(char *path) { char *startptr; if ((startptr = strrchr(path, '.')) == NULL) return gk_strdup(path); else return gk_strdup(startptr+1); } /************************************************************************* * This function takes in a potentially full path specification of a file * and just returns a string containing just the filename. **************************************************************************/ char *gk_getfilename(char *path) { char *startptr; if ((startptr = strrchr(path, '/')) == NULL) return gk_strdup(path); else return gk_strdup(startptr+1); } /************************************************************************* * This function takes in a potentially full path specification of a file * and extracts the directory path component if it exists, otherwise it * returns "./" as the path. The memory for it is dynamically allocated. **************************************************************************/ char *getpathname(char *path) { char *endptr, *tmp; if ((endptr = strrchr(path, '/')) == NULL) { return gk_strdup("."); } else { tmp = gk_strdup(path); *(strrchr(tmp, '/')) = '\0'; return tmp; } } /************************************************************************* * This function creates a path **************************************************************************/ int gk_mkpath(char *pathname) { char tmp[2048]; sprintf(tmp, "mkdir -p %s", pathname); return system(tmp); } /************************************************************************* * This function deletes a directory tree and all of its contents **************************************************************************/ int gk_rmpath(char *pathname) { char tmp[2048]; sprintf(tmp, "rm -r %s", pathname); return system(tmp); } PyMetis-0.90/src/gklib/getopt.c0000640000175000017500000007432610662171744016215 0ustar andreasandreas/*************************************************************************/ /*! \file getopt.c \brief Command line parsing This file contains a implementation of GNU's Getopt facility. The purpose for including it here is to ensure portability across different unix- and windows-based systems. \warning The implementation provided here uses the \c gk_ prefix for all variables used by the standard Getopt facility to communicate with the program. So, do read the documentation here. \verbatim Copyright (C) 1987,88,89,90,91,92,93,94,95,96,98,99,2000,2001 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. \endverbatim */ /*************************************************************************/ #include /*************************************************************************/ /* Local function prototypes */ /*************************************************************************/ static void exchange (char **); static const char *gk_getopt_initialize (int, char *const *, const char *); static int gk_getopt_internal(int argc, char *const *argv, const char *optstring, const struct gk_option *longopts, int *longind, int long_only); /*************************************************************************/ /*! \brief For communication arguments to the caller. This variable is set by getopt to point at the value of the option argument, for those options that accept arguments. */ /*************************************************************************/ char *gk_optarg; /*************************************************************************/ /*! \brief Index in ARGV of the next element to be scanned. This variable is set by getopt to the index of the next element of the argv array to be processed. Once getopt has found all of the option arguments, you can use this variable to determine where the remaining non-option arguments begin. */ /*************************************************************************/ int gk_optind = 1; /*************************************************************************/ /*! \brief Controls error reporting for unrecognized options. If the value of this variable is nonzero, then getopt prints an error message to the standard error stream if it encounters an unknown option character or an option with a missing required argument. This is the default behavior. If you set this variable to zero, getopt does not print any messages, but it still returns the character ? to indicate an error. */ /*************************************************************************/ int gk_opterr = 1; /*************************************************************************/ /*! \brief Stores unknown option characters When getopt encounters an unknown option character or an option with a missing required argument, it stores that option character in this variable. You can use this for providing your own diagnostic messages. */ /*************************************************************************/ int gk_optopt = '?'; /*************************************************************************/ /* Records that the getopt facility has been initialized. */ /*************************************************************************/ int gk_getopt_initialized; /*************************************************************************/ /* The next char to be scanned in the option-element in which the last option character we returned was found. This allows us to pick up the scan where we left off. If this is zero, or a null string, it means resume the scan by advancing to the next ARGV-element. */ /*************************************************************************/ static char *nextchar; /*************************************************************************/ /* Value of POSIXLY_CORRECT environment variable. */ /*************************************************************************/ static char *posixly_correct; /*************************************************************************/ /* Describe how to deal with options that follow non-option ARGV-elements. If the caller did not specify anything, the default is REQUIRE_ORDER if the environment variable POSIXLY_CORRECT is defined, PERMUTE otherwise. REQUIRE_ORDER means don't recognize them as options; stop option processing when the first non-option is seen. This is what Unix does. This mode of operation is selected by either setting the environment variable POSIXLY_CORRECT, or using `+' as the first character of the list of option characters. PERMUTE is the default. We permute the contents of ARGV as we scan, so that eventually all the non-options are at the end. This allows options to be given in any order, even with programs that were not written to expect this. RETURN_IN_ORDER is an option available to programs that were written to expect options and other ARGV-elements in any order and that care about the ordering of the two. We describe each non-option ARGV-element as if it were the argument of an option with character code 1. Using `-' as the first character of the list of option characters selects this mode of operation. The special argument `--' forces an end of option-scanning regardless of the value of `ordering'. In the case of RETURN_IN_ORDER, only `--' can cause `getopt' to return -1 with `gk_optind' != ARGC. */ /*************************************************************************/ static enum { REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER } ordering; /*************************************************************************/ /* Describe the part of ARGV that contains non-options that have been skipped. `first_nonopt' is the index in ARGV of the first of them; `last_nonopt' is the index after the last of them. */ /*************************************************************************/ static int first_nonopt; static int last_nonopt; /*************************************************************************/ /* Handle permutation of arguments. Exchange two adjacent subsequences of ARGV. One subsequence is elements [first_nonopt,last_nonopt) which contains all the non-options that have been skipped so far. The other is elements [last_nonopt,gk_optind), which contains all the options processed since those non-options were skipped. `first_nonopt' and `last_nonopt' are relocated so that they describe the new indices of the non-options in ARGV after they are moved. */ /*************************************************************************/ static void exchange (char **argv) { int bottom = first_nonopt; int middle = last_nonopt; int top = gk_optind; char *tem; /* Exchange the shorter segment with the far end of the longer segment. That puts the shorter segment into the right place. It leaves the longer segment in the right place overall, but it consists of two parts that need to be swapped next. */ while (top > middle && middle > bottom) { if (top - middle > middle - bottom) { /* Bottom segment is the short one. */ int len = middle - bottom; register int i; /* Swap it with the top part of the top segment. */ for (i = 0; i < len; i++) { tem = argv[bottom + i]; argv[bottom + i] = argv[top - (middle - bottom) + i]; argv[top - (middle - bottom) + i] = tem; } /* Exclude the moved bottom segment from further swapping. */ top -= len; } else { /* Top segment is the short one. */ int len = top - middle; register int i; /* Swap it with the bottom part of the bottom segment. */ for (i = 0; i < len; i++) { tem = argv[bottom + i]; argv[bottom + i] = argv[middle + i]; argv[middle + i] = tem; } /* Exclude the moved top segment from further swapping. */ bottom += len; } } /* Update records for the slots the non-options now occupy. */ first_nonopt += (gk_optind - last_nonopt); last_nonopt = gk_optind; } /*************************************************************************/ /* Initialize the internal data when the first call is made. */ /*************************************************************************/ static const char *gk_getopt_initialize (int argc, char *const *argv, const char *optstring) { /* Start processing options with ARGV-element 1 (since ARGV-element 0 is the program name); the sequence of previously skipped non-option ARGV-elements is empty. */ first_nonopt = last_nonopt = gk_optind; nextchar = NULL; posixly_correct = getenv("POSIXLY_CORRECT"); /* Determine how to handle the ordering of options and nonoptions. */ if (optstring[0] == '-') { ordering = RETURN_IN_ORDER; ++optstring; } else if (optstring[0] == '+') { ordering = REQUIRE_ORDER; ++optstring; } else if (posixly_correct != NULL) ordering = REQUIRE_ORDER; else ordering = PERMUTE; return optstring; } /*************************************************************************/ /* Scan elements of ARGV (whose length is ARGC) for option characters given in OPTSTRING. If an element of ARGV starts with '-', and is not exactly "-" or "--", then it is an option element. The characters of this element (aside from the initial '-') are option characters. If `getopt' is called repeatedly, it returns successively each of the option characters from each of the option elements. If `getopt' finds another option character, it returns that character, updating `gk_optind' and `nextchar' so that the next call to `getopt' can resume the scan with the following option character or ARGV-element. If there are no more option characters, `getopt' returns -1. Then `gk_optind' is the index in ARGV of the first ARGV-element that is not an option. (The ARGV-elements have been permuted so that those that are not options now come last.) OPTSTRING is a string containing the legitimate option characters. If an option character is seen that is not listed in OPTSTRING, return '?' after printing an error message. If you set `gk_opterr' to zero, the error message is suppressed but we still return '?'. If a char in OPTSTRING is followed by a colon, that means it wants an arg, so the following text in the same ARGV-element, or the text of the following ARGV-element, is returned in `gk_optarg'. Two colons mean an option that wants an optional arg; if there is text in the current ARGV-element, it is returned in `gk_optarg', otherwise `gk_optarg' is set to zero. If OPTSTRING starts with `-' or `+', it requests different methods of handling the non-option ARGV-elements. See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above. Long-named options begin with `--' instead of `-'. Their names may be abbreviated as long as the abbreviation is unique or is an exact match for some defined option. If they have an argument, it follows the option name in the same ARGV-element, separated from the option name by a `=', or else the in next ARGV-element. When `getopt' finds a long-named option, it returns 0 if that option's `flag' field is nonzero, the value of the option's `val' field if the `flag' field is zero. The elements of ARGV aren't really const, because we permute them. But we pretend they're const in the prototype to be compatible with other systems. LONGOPTS is a vector of `struct gk_option' terminated by an element containing a name which is zero. LONGIND returns the index in LONGOPT of the long-named option found. It is only valid when a long-named option has been found by the most recent call. If LONG_ONLY is nonzero, '-' as well as '--' can introduce long-named options. */ /*************************************************************************/ static int gk_getopt_internal(int argc, char *const *argv, const char *optstring, const struct gk_option *longopts, int *longind, int long_only) { int print_errors = gk_opterr; if (optstring[0] == ':') print_errors = 0; if (argc < 1) return -1; gk_optarg = NULL; if (gk_optind == 0 || !gk_getopt_initialized) { if (gk_optind == 0) gk_optind = 1; /* Don't scan ARGV[0], the program name. */ optstring = gk_getopt_initialize (argc, argv, optstring); gk_getopt_initialized = 1; } /* Test whether ARGV[gk_optind] points to a non-option argument. Either it does not have option syntax, or there is an environment flag from the shell indicating it is not an option. The later information is only used when the used in the GNU libc. */ # define NONOPTION_P (argv[gk_optind][0] != '-' || argv[gk_optind][1] == '\0') if (nextchar == NULL || *nextchar == '\0') { /* Advance to the next ARGV-element. */ /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been moved back by the user (who may also have changed the arguments). */ if (last_nonopt > gk_optind) last_nonopt = gk_optind; if (first_nonopt > gk_optind) first_nonopt = gk_optind; if (ordering == PERMUTE) { /* If we have just processed some options following some non-options, exchange them so that the options come first. */ if (first_nonopt != last_nonopt && last_nonopt != gk_optind) exchange ((char **) argv); else if (last_nonopt != gk_optind) first_nonopt = gk_optind; /* Skip any additional non-options and extend the range of non-options previously skipped. */ while (gk_optind < argc && NONOPTION_P) gk_optind++; last_nonopt = gk_optind; } /* The special ARGV-element `--' means premature end of options. Skip it like a null option, then exchange with previous non-options as if it were an option, then skip everything else like a non-option. */ if (gk_optind != argc && !strcmp (argv[gk_optind], "--")) { gk_optind++; if (first_nonopt != last_nonopt && last_nonopt != gk_optind) exchange ((char **) argv); else if (first_nonopt == last_nonopt) first_nonopt = gk_optind; last_nonopt = argc; gk_optind = argc; } /* If we have done all the ARGV-elements, stop the scan and back over any non-options that we skipped and permuted. */ if (gk_optind == argc) { /* Set the next-arg-index to point at the non-options that we previously skipped, so the caller will digest them. */ if (first_nonopt != last_nonopt) gk_optind = first_nonopt; return -1; } /* If we have come to a non-option and did not permute it, either stop the scan or describe it to the caller and pass it by. */ if (NONOPTION_P) { if (ordering == REQUIRE_ORDER) return -1; gk_optarg = argv[gk_optind++]; return 1; } /* We have found another option-ARGV-element. Skip the initial punctuation. */ nextchar = (argv[gk_optind] + 1 + (longopts != NULL && argv[gk_optind][1] == '-')); } /* Decode the current option-ARGV-element. */ /* Check whether the ARGV-element is a long option. If long_only and the ARGV-element has the form "-f", where f is a valid short option, don't consider it an abbreviated form of a long option that starts with f. Otherwise there would be no way to give the -f short option. On the other hand, if there's a long option "fubar" and the ARGV-element is "-fu", do consider that an abbreviation of the long option, just like "--fu", and not "-f" with arg "u". This distinction seems to be the most useful approach. */ if (longopts != NULL && (argv[gk_optind][1] == '-' || (long_only && (argv[gk_optind][2] || !strchr(optstring, argv[gk_optind][1]))))) { char *nameend; const struct gk_option *p; const struct gk_option *pfound = NULL; int exact = 0; int ambig = 0; int indfound = -1; int option_index; for (nameend = nextchar; *nameend && *nameend != '='; nameend++) /* Do nothing. */ ; /* Test all long options for either exact match or abbreviated matches. */ for (p = longopts, option_index = 0; p->name; p++, option_index++) { if (!strncmp (p->name, nextchar, nameend - nextchar)) { if ((unsigned int) (nameend - nextchar) == (unsigned int) strlen (p->name)) { /* Exact match found. */ pfound = p; indfound = option_index; exact = 1; break; } else if (pfound == NULL) { /* First nonexact match found. */ pfound = p; indfound = option_index; } else if (long_only || pfound->has_arg != p->has_arg || pfound->flag != p->flag || pfound->val != p->val) /* Second or later nonexact match found. */ ambig = 1; } } if (ambig && !exact) { if (print_errors) fprintf(stderr, "%s: option `%s' is ambiguous\n", argv[0], argv[gk_optind]); nextchar += strlen (nextchar); gk_optind++; gk_optopt = 0; return '?'; } if (pfound != NULL) { option_index = indfound; gk_optind++; if (*nameend) { /* Don't test has_arg with >, because some C compilers don't allow it to be used on enums. */ if (pfound->has_arg) gk_optarg = nameend + 1; else { if (print_errors) { if (argv[gk_optind - 1][1] == '-') /* --option */ fprintf(stderr, "%s: option `--%s' doesn't allow an argument\n", argv[0], pfound->name); else /* +option or -option */ fprintf(stderr, "%s: option `%c%s' doesn't allow an argument\n", argv[0], argv[gk_optind - 1][0], pfound->name); } nextchar += strlen (nextchar); gk_optopt = pfound->val; return '?'; } } else if (pfound->has_arg == 1) { if (gk_optind < argc) gk_optarg = argv[gk_optind++]; else { if (print_errors) fprintf(stderr, "%s: option `%s' requires an argument\n", argv[0], argv[gk_optind - 1]); nextchar += strlen (nextchar); gk_optopt = pfound->val; return optstring[0] == ':' ? ':' : '?'; } } nextchar += strlen (nextchar); if (longind != NULL) *longind = option_index; if (pfound->flag) { *(pfound->flag) = pfound->val; return 0; } return pfound->val; } /* Can't find it as a long option. If this is not getopt_long_only, or the option starts with '--' or is not a valid short option, then it's an error. Otherwise interpret it as a short option. */ if (!long_only || argv[gk_optind][1] == '-' || strchr(optstring, *nextchar) == NULL) { if (print_errors) { if (argv[gk_optind][1] == '-') /* --option */ fprintf(stderr, "%s: unrecognized option `--%s'\n", argv[0], nextchar); else /* +option or -option */ fprintf(stderr, "%s: unrecognized option `%c%s'\n", argv[0], argv[gk_optind][0], nextchar); } nextchar = (char *) ""; gk_optind++; gk_optopt = 0; return '?'; } } /* Look at and handle the next short option-character. */ { char c = *nextchar++; char *temp = strchr(optstring, c); /* Increment `gk_optind' when we start to process its last character. */ if (*nextchar == '\0') ++gk_optind; if (temp == NULL || c == ':') { if (print_errors) { if (posixly_correct) /* 1003.2 specifies the format of this message. */ fprintf(stderr, "%s: illegal option -- %c\n", argv[0], c); else fprintf(stderr, "%s: invalid option -- %c\n", argv[0], c); } gk_optopt = c; return '?'; } /* Convenience. Treat POSIX -W foo same as long option --foo */ if (temp[0] == 'W' && temp[1] == ';') { char *nameend; const struct gk_option *p; const struct gk_option *pfound = NULL; int exact = 0; int ambig = 0; int indfound = 0; int option_index; /* This is an option that requires an argument. */ if (*nextchar != '\0') { gk_optarg = nextchar; /* If we end this ARGV-element by taking the rest as an arg, we must advance to the next element now. */ gk_optind++; } else if (gk_optind == argc) { if (print_errors) { /* 1003.2 specifies the format of this message. */ fprintf(stderr, "%s: option requires an argument -- %c\n", argv[0], c); } gk_optopt = c; if (optstring[0] == ':') c = ':'; else c = '?'; return c; } else /* We already incremented `gk_optind' once; increment it again when taking next ARGV-elt as argument. */ gk_optarg = argv[gk_optind++]; /* gk_optarg is now the argument, see if it's in the table of longopts. */ for (nextchar = nameend = gk_optarg; *nameend && *nameend != '='; nameend++) /* Do nothing. */ ; /* Test all long options for either exact match or abbreviated matches. */ for (p = longopts, option_index = 0; p->name; p++, option_index++) { if (!strncmp (p->name, nextchar, nameend - nextchar)) { if ((unsigned int) (nameend - nextchar) == strlen (p->name)) { /* Exact match found. */ pfound = p; indfound = option_index; exact = 1; break; } else if (pfound == NULL) { /* First nonexact match found. */ pfound = p; indfound = option_index; } else /* Second or later nonexact match found. */ ambig = 1; } } if (ambig && !exact) { if (print_errors) fprintf(stderr, "%s: option `-W %s' is ambiguous\n", argv[0], argv[gk_optind]); nextchar += strlen (nextchar); gk_optind++; return '?'; } if (pfound != NULL) { option_index = indfound; if (*nameend) { /* Don't test has_arg with >, because some C compilers don't allow it to be used on enums. */ if (pfound->has_arg) gk_optarg = nameend + 1; else { if (print_errors) fprintf(stderr, "%s: option `-W %s' doesn't allow an argument\n", argv[0], pfound->name); nextchar += strlen (nextchar); return '?'; } } else if (pfound->has_arg == 1) { if (gk_optind < argc) gk_optarg = argv[gk_optind++]; else { if (print_errors) fprintf(stderr, "%s: option `%s' requires an argument\n", argv[0], argv[gk_optind - 1]); nextchar += strlen (nextchar); return optstring[0] == ':' ? ':' : '?'; } } nextchar += strlen (nextchar); if (longind != NULL) *longind = option_index; if (pfound->flag) { *(pfound->flag) = pfound->val; return 0; } return pfound->val; } nextchar = NULL; return 'W'; /* Let the application handle it. */ } if (temp[1] == ':') { if (temp[2] == ':') { /* This is an option that accepts an argument optionally. */ if (*nextchar != '\0') { gk_optarg = nextchar; gk_optind++; } else gk_optarg = NULL; nextchar = NULL; } else { /* This is an option that requires an argument. */ if (*nextchar != '\0') { gk_optarg = nextchar; /* If we end this ARGV-element by taking the rest as an arg, we must advance to the next element now. */ gk_optind++; } else if (gk_optind == argc) { if (print_errors) { /* 1003.2 specifies the format of this message. */ fprintf(stderr, "%s: option requires an argument -- %c\n", argv[0], c); } gk_optopt = c; if (optstring[0] == ':') c = ':'; else c = '?'; } else /* We already incremented `gk_optind' once; increment it again when taking next ARGV-elt as argument. */ gk_optarg = argv[gk_optind++]; nextchar = NULL; } } return c; } } /*************************************************************************/ /*! \brief Parse command-line arguments The gk_getopt() function gets the next option argument from the argument list specified by the \c argv and \c argc arguments. Normally these values come directly from the arguments received by main(). \param argc is the number of command line arguments passed to main(). \param argv is an array of strings storing the above command line arguments. \param options is a string that specifies the option characters that are valid for this program. An option character in this string can be followed by a colon (`:') to indicate that it takes a required argument. If an option character is followed by two colons (`::'), its argument is optional; this is a GNU extension. \return It returns the option character for the next command line option. When no more option arguments are available, it returns -1. There may still be more non-option arguments; you must compare the external variable #gk_optind against the \c argc parameter to check this. \return If the option has an argument, gk_getopt() returns the argument by storing it in the variable #gk_optarg. You don't ordinarily need to copy the #gk_optarg string, since it is a pointer into the original \c argv array, not into a static area that might be overwritten. \return If gk_getopt() finds an option character in \c argv that was not included in options, or a missing option argument, it returns `?' and sets the external variable #gk_optopt to the actual option character. If the first character of options is a colon (`:'), then gk_getopt() returns `:' instead of `?' to indicate a missing option argument. In addition, if the external variable #gk_opterr is nonzero (which is the default), gk_getopt() prints an error message. This variable is set by gk_getopt() to point at the value of the option argument, for those options that accept arguments. gk_getopt() has three ways to deal with options that follow non-options \c argv elements. The special argument `--' forces in all cases the end of option scanning. - The default is to permute the contents of \c argv while scanning it so that eventually all the non-options are at the end. This allows options to be given in any order, even with programs that were not written to expect this. - If the options argument string begins with a hyphen (`-'), this is treated specially. It permits arguments that are not options to be returned as if they were associated with option character `\\1'. - POSIX demands the following behavior: The first non-option stops option processing. This mode is selected by either setting the environment variable POSIXLY_CORRECT or beginning the options argument string with a plus sign (`+'). */ /*************************************************************************/ int gk_getopt(int argc, char **argv, const char *options) { return gk_getopt_internal(argc, argv, options, NULL, NULL, 0); } /*************************************************************************/ /*! \brief Parse command-line arguments with long options This function accepts GNU-style long options as well as single-character options. \param argc is the number of command line arguments passed to main(). \param argv is an array of strings storing the above command line arguments. \param options describes the short options to accept, just as it does in gk_getopt(). \param long_options describes the long options to accept. See the defintion of ::gk_option for more information. \param opt_index this is a returned variable. For any long option, gk_getopt_long() tells you the index in the array \c long_options of the options definition, by storing it into *opt_index. You can get the name of the option with longopts[*opt_index].name. So you can distinguish among long options either by the values in their val fields or by their indices. You can also distinguish in this way among long options that set flags. \return When gk_getopt_long() encounters a short option, it does the same thing that gk_getopt() would do: it returns the character code for the option, and stores the options argument (if it has one) in #gk_optarg. \return When gk_getopt_long() encounters a long option, it takes actions based on the flag and val fields of the definition of that option. \return If flag is a null pointer, then gk_getopt_long() returns the contents of val to indicate which option it found. You should arrange distinct values in the val field for options with different meanings, so you can decode these values after gk_getopt_long() returns. If the long option is equivalent to a short option, you can use the short option's character code in val. \return If flag is not a null pointer, that means this option should just set a flag in the program. The flag is a variable of type int that you define. Put the address of the flag in the flag field. Put in the val field the value you would like this option to store in the flag. In this case, gk_getopt_long() returns 0. \return When a long option has an argument, gk_getopt_long() puts the argument value in the variable #gk_optarg before returning. When the option has no argument, the value in #gk_optarg is a null pointer. This is how you can tell whether an optional argument was supplied. \return When gk_getopt_long() has no more options to handle, it returns -1, and leaves in the variable #gk_optind the index in argv of the next remaining argument. */ /*************************************************************************/ int gk_getopt_long( int argc, char *const *argv, const char *options, const struct gk_option *long_options, int *opt_index) { return gk_getopt_internal (argc, argv, options, long_options, opt_index, 0); } /*************************************************************************/ /*! \brief Parse command-line arguments with only long options Like gk_getopt_long(), but '-' as well as '--' can indicate a long option. If an option that starts with '-' (not '--') doesn't match a long option, but does match a short option, it is parsed as a short option instead. */ /*************************************************************************/ int gk_getopt_long_only(int argc, char *const *argv, const char *options, const struct gk_option *long_options, int *opt_index) { return gk_getopt_internal(argc, argv, options, long_options, opt_index, 1); } PyMetis-0.90/src/gklib/gk_arch.h0000640000175000017500000000301210662171744016276 0ustar andreasandreas/*! \file gk_arch.h \brief This file contains various architecture-specific declerations \date Started 3/27/2007 \author George \version\verbatim $Id: gk_arch.h 1430 2007-04-07 17:53:07Z karypis $ \endverbatim */ #ifndef _GK_ARCH_H_ #define _GK_ARCH_H_ /************************************************************************* * Architecture-specific differences in header files **************************************************************************/ #ifdef LINUX #if !defined(__USE_XOPEN) #define __USE_XOPEN #endif #if !defined(_XOPEN_SOURCE) #define _XOPEN_SOURCE 600 #endif #if !defined(__USE_XOPEN2K) #define __USE_XOPEN2K #endif #include #endif #ifdef __MSC__ #include #else #include #include #include #include #include #endif /************************************************************************* * Architecture-specific modifications **************************************************************************/ #ifdef WIN32 #define __thread __declspec( thread ) typedef __int32 int32_t; typedef __int64 int64_t; typedef unsigned __int32 uint32_t; typedef unsigned __int64 uint64_t; #endif #ifdef SUNOS #define __thread #endif #ifdef DARWIN #define __thread #endif #ifdef __MSC__ #define rint(x) ((int)((x)+0.5)) /* MSC does not have rint() function */ #endif #ifdef __GNUC__ #if !defined(strdup) extern char* strdup (const char *); #endif #endif #endif PyMetis-0.90/src/gklib/gk_blas.h0000640000175000017500000001241110662171744016305 0ustar andreasandreas/*! \file gk_blas.h \brief This file contains GKlib's code generators for BLAS-like routines \date Started 3/28/07 \author George \version\verbatim $Id: gk_blas.h 1421 2007-04-06 14:37:41Z karypis $ \endverbatim */ #ifndef _GK_BLAS_H_ #define _GK_BLAS_H_ /*************************************************************************/ /*! The macro for gk_?set()-class of routines */ /*************************************************************************/ #define GK_SET(NAME, TYPE) \ TYPE *NAME(size_t n, TYPE val, TYPE *x)\ {\ size_t i;\ \ for (i=0; i x[max] ? i : max);\ \ return max;\ } #define GK_ARGMAX_PROTO(NAME, TYPE) \ size_t NAME(size_t n, TYPE *x); /*************************************************************************/ /*! The macro for gk_?argmin()-class of routines */ /*************************************************************************/ #define GK_ARGMIN(NAME, TYPE) \ size_t NAME(size_t n, TYPE *x)\ {\ size_t i, min=0;\ \ for (i=1; i 0 ? (OUTTYPE)sqrt((double)partial) : 0.0);\ } #define GK_NORM2_PROTO(NAME, INTYPE, OUTTYPE) \ OUTTYPE NAME(size_t n, INTYPE *x, size_t incx); /*************************************************************************/ /*! The macro for gk_?dot()-class of routines */ /**************************************************************************/ #define GK_DOT(NAME, INTYPE, OUTTYPE) \ OUTTYPE NAME(size_t n, INTYPE *x, size_t incx, INTYPE *y, size_t incy)\ {\ size_t i;\ OUTTYPE partial = 0.0;\ \ for (i=0; i. Therefore, some of the comments below do not apply for this modified version. However, it is the intention to keep differences to Doug Lea's original version minimal, hence the comments were mostly left unchanged. ----------------------------------------------------------------------- This is a version (aka dlmalloc) of malloc/free/realloc written by Doug Lea and released to the public domain, as explained at http://creativecommons.org/licenses/publicdomain. Send questions, comments, complaints, performance data, etc to dl@cs.oswego.edu * Version pre-2.8.4 Wed Mar 29 19:46:29 2006 (dl at gee) Note: There may be an updated version of this malloc obtainable at ftp://gee.cs.oswego.edu/pub/misc/malloc.c Check before installing! \version\verbatim $Id: gk_dlmalloc.h 1421 2007-04-06 14:37:41Z karypis $\endverbatim */ /********************************************************************** * These are the compile-time options that are enabled by GKlib ***********************************************************************/ #define MSPACES 1 #define USE_LOCKS 0 #define FOOTERS 1 #define REALLOC_ZERO_BYTES_FREES 1 #define USE_DL_PREFIX /* * Quickstart This library is all in one file to simplify the most common usage: ftp it, compile it (-O3), and link it into another program. All of the compile-time options default to reasonable values for use on most platforms. You might later want to step through various compile-time and dynamic tuning options. For convenience, an include file for code using this malloc is at: ftp://gee.cs.oswego.edu/pub/misc/malloc-2.8.3.h You don't really need this .h file unless you call functions not defined in your system include files. The .h file contains only the excerpts from this file needed for using this malloc on ANSI C/C++ systems, so long as you haven't changed compile-time options about naming and tuning parameters. If you do, then you can create your own malloc.h that does include all settings by cutting at the point indicated below. Note that you may already by default be using a C library containing a malloc that is based on some version of this malloc (for example in linux). You might still want to use the one in this file to customize settings or to avoid overheads associated with library versions. * Vital statistics: Supported pointer/size_t representation: 4 or 8 bytes size_t MUST be an unsigned type of the same width as pointers. (If you are using an ancient system that declares size_t as a signed type, or need it to be a different width than pointers, you can use a previous release of this malloc (e.g. 2.7.2) supporting these.) Alignment: 8 bytes (default) This suffices for nearly all current machines and C compilers. However, you can define MALLOC_ALIGNMENT to be wider than this if necessary (up to 128bytes), at the expense of using more space. Minimum overhead per allocated chunk: 4 or 8 bytes (if 4byte sizes) 8 or 16 bytes (if 8byte sizes) Each malloced chunk has a hidden word of overhead holding size and status information, and additional cross-check word if FOOTERS is defined. Minimum allocated size: 4-byte ptrs: 16 bytes (including overhead) 8-byte ptrs: 32 bytes (including overhead) Even a request for zero bytes (i.e., malloc(0)) returns a pointer to something of the minimum allocatable size. The maximum overhead wastage (i.e., number of extra bytes allocated than were requested in malloc) is less than or equal to the minimum size, except for requests >= mmap_threshold that are serviced via mmap(), where the worst case wastage is about 32 bytes plus the remainder from a system page (the minimal mmap unit); typically 4096 or 8192 bytes. Security: static-safe; optionally more or less The "security" of malloc refers to the ability of malicious code to accentuate the effects of errors (for example, freeing space that is not currently malloc'ed or overwriting past the ends of chunks) in code that calls malloc. This malloc guarantees not to modify any memory locations below the base of heap, i.e., static variables, even in the presence of usage errors. The routines additionally detect most improper frees and reallocs. All this holds as long as the static bookkeeping for malloc itself is not corrupted by some other means. This is only one aspect of security -- these checks do not, and cannot, detect all possible programming errors. If FOOTERS is defined nonzero, then each allocated chunk carries an additional check word to verify that it was malloced from its space. These check words are the same within each execution of a program using malloc, but differ across executions, so externally crafted fake chunks cannot be freed. This improves security by rejecting frees/reallocs that could corrupt heap memory, in addition to the checks preventing writes to statics that are always on. This may further improve security at the expense of time and space overhead. (Note that FOOTERS may also be worth using with MSPACES.) By default detected errors cause the program to abort (calling "abort()"). You can override this to instead proceed past errors by defining PROCEED_ON_ERROR. In this case, a bad free has no effect, and a malloc that encounters a bad address caused by user overwrites will ignore the bad address by dropping pointers and indices to all known memory. This may be appropriate for programs that should continue if at all possible in the face of programming errors, although they may run out of memory because dropped memory is never reclaimed. If you don't like either of these options, you can define CORRUPTION_ERROR_ACTION and USAGE_ERROR_ACTION to do anything else. And if if you are sure that your program using malloc has no errors or vulnerabilities, you can define INSECURE to 1, which might (or might not) provide a small performance improvement. Thread-safety: NOT thread-safe unless USE_LOCKS defined When USE_LOCKS is defined, each public call to malloc, free, etc is surrounded with either a pthread mutex or a win32 spinlock (depending on WIN32). This is not especially fast, and can be a major bottleneck. It is designed only to provide minimal protection in concurrent environments, and to provide a basis for extensions. If you are using malloc in a concurrent program, consider instead using nedmalloc (http://www.nedprod.com/programs/portable/nedmalloc/) or ptmalloc (See http://www.malloc.de), which are derived from versions of this malloc. System requirements: Any combination of MORECORE and/or MMAP/MUNMAP This malloc can use unix sbrk or any emulation (invoked using the CALL_MORECORE macro) and/or mmap/munmap or any emulation (invoked using CALL_MMAP/CALL_MUNMAP) to get and release system memory. On most unix systems, it tends to work best if both MORECORE and MMAP are enabled. On Win32, it uses emulations based on VirtualAlloc. It also uses common C library functions like memset. Compliance: I believe it is compliant with the Single Unix Specification (See http://www.unix.org). Also SVID/XPG, ANSI C, and probably others as well. * Overview of algorithms This is not the fastest, most space-conserving, most portable, or most tunable malloc ever written. However it is among the fastest while also being among the most space-conserving, portable and tunable. Consistent balance across these factors results in a good general-purpose allocator for malloc-intensive programs. In most ways, this malloc is a best-fit allocator. Generally, it chooses the best-fitting existing chunk for a request, with ties broken in approximately least-recently-used order. (This strategy normally maintains low fragmentation.) However, for requests less than 256bytes, it deviates from best-fit when there is not an exactly fitting available chunk by preferring to use space adjacent to that used for the previous small request, as well as by breaking ties in approximately most-recently-used order. (These enhance locality of series of small allocations.) And for very large requests (>= 256Kb by default), it relies on system memory mapping facilities, if supported. (This helps avoid carrying around and possibly fragmenting memory used only for large chunks.) All operations (except malloc_stats and mallinfo) have execution times that are bounded by a constant factor of the number of bits in a size_t, not counting any clearing in calloc or copying in realloc, or actions surrounding MORECORE and MMAP that have times proportional to the number of non-contiguous regions returned by system allocation routines, which is often just 1. In real-time applications, you can optionally suppress segment traversals using NO_SEGMENT_TRAVERSAL, which assures bounded execution even when system allocators return non-contiguous spaces, at the typical expense of carrying around more memory and increased fragmentation. The implementation is not very modular and seriously overuses macros. Perhaps someday all C compilers will do as good a job inlining modular code as can now be done by brute-force expansion, but now, enough of them seem not to. Some compilers issue a lot of warnings about code that is dead/unreachable only on some platforms, and also about intentional uses of negation on unsigned types. All known cases of each can be ignored. For a longer but out of date high-level description, see http://gee.cs.oswego.edu/dl/html/malloc.html * MSPACES If MSPACES is defined, then in addition to malloc, free, etc., this file also defines mspace_malloc, mspace_free, etc. These are versions of malloc routines that take an "mspace" argument obtained using create_mspace, to control all internal bookkeeping. If ONLY_MSPACES is defined, only these versions are compiled. So if you would like to use this allocator for only some allocations, and your system malloc for others, you can compile with ONLY_MSPACES and then do something like... static mspace mymspace = create_mspace(0,0); // for example #define mymalloc(bytes) mspace_malloc(mymspace, bytes) (Note: If you only need one instance of an mspace, you can instead use "USE_DL_PREFIX" to relabel the global malloc.) You can similarly create thread-local allocators by storing mspaces as thread-locals. For example: static __thread mspace tlms = 0; void* tlmalloc(size_t bytes) { if (tlms == 0) tlms = create_mspace(0, 0); return mspace_malloc(tlms, bytes); } void tlfree(void* mem) { mspace_free(tlms, mem); } Unless FOOTERS is defined, each mspace is completely independent. You cannot allocate from one and free to another (although conformance is only weakly checked, so usage errors are not always caught). If FOOTERS is defined, then each chunk carries around a tag indicating its originating mspace, and frees are directed to their originating spaces. ------------------------- Compile-time options --------------------------- Be careful in setting #define values for numerical constants of type size_t. On some systems, literal values are not automatically extended to size_t precision unless they are explicitly casted. You can also use the symbolic values MAX_SIZE_T, SIZE_T_ONE, etc below. WIN32 default: defined if _WIN32 defined Defining WIN32 sets up defaults for MS environment and compilers. Otherwise defaults are for unix. MALLOC_ALIGNMENT default: (size_t)8 Controls the minimum alignment for malloc'ed chunks. It must be a power of two and at least 8, even on machines for which smaller alignments would suffice. It may be defined as larger than this though. Note however that code and data structures are optimized for the case of 8-byte alignment. MSPACES default: 0 (false) If true, compile in support for independent allocation spaces. This is only supported if HAVE_MMAP is true. ONLY_MSPACES default: 0 (false) If true, only compile in mspace versions, not regular versions. USE_LOCKS default: 0 (false) Causes each call to each public routine to be surrounded with pthread or WIN32 mutex lock/unlock. (If set true, this can be overridden on a per-mspace basis for mspace versions.) If set to a non-zero value other than 1, locks are used, but their implementation is left out, so lock functions must be supplied manually. USE_SPIN_LOCKS default: 1 iff USE_LOCKS and on x86 using gcc or MSC If true, uses custom spin locks for locking. This is currently supported only for x86 platforms using gcc or recent MS compilers. Otherwise, posix locks or win32 critical sections are used. FOOTERS default: 0 If true, provide extra checking and dispatching by placing information in the footers of allocated chunks. This adds space and time overhead. INSECURE default: 0 If true, omit checks for usage errors and heap space overwrites. USE_DL_PREFIX default: NOT defined Causes compiler to prefix all public routines with the string 'dl'. This can be useful when you only want to use this malloc in one part of a program, using your regular system malloc elsewhere. ABORT default: defined as abort() Defines how to abort on failed checks. On most systems, a failed check cannot die with an "assert" or even print an informative message, because the underlying print routines in turn call malloc, which will fail again. Generally, the best policy is to simply call abort(). It's not very useful to do more than this because many errors due to overwriting will show up as address faults (null, odd addresses etc) rather than malloc-triggered checks, so will also abort. Also, most compilers know that abort() does not return, so can better optimize code conditionally calling it. PROCEED_ON_ERROR default: defined as 0 (false) Controls whether detected bad addresses cause them to bypassed rather than aborting. If set, detected bad arguments to free and realloc are ignored. And all bookkeeping information is zeroed out upon a detected overwrite of freed heap space, thus losing the ability to ever return it from malloc again, but enabling the application to proceed. If PROCEED_ON_ERROR is defined, the static variable malloc_corruption_error_count is compiled in and can be examined to see if errors have occurred. This option generates slower code than the default abort policy. DEBUG default: NOT defined The DEBUG setting is mainly intended for people trying to modify this code or diagnose problems when porting to new platforms. However, it may also be able to better isolate user errors than just using runtime checks. The assertions in the check routines spell out in more detail the assumptions and invariants underlying the algorithms. The checking is fairly extensive, and will slow down execution noticeably. Calling malloc_stats or mallinfo with DEBUG set will attempt to check every non-mmapped allocated and free chunk in the course of computing the summaries. ABORT_ON_ASSERT_FAILURE default: defined as 1 (true) Debugging assertion failures can be nearly impossible if your version of the assert macro causes malloc to be called, which will lead to a cascade of further failures, blowing the runtime stack. ABORT_ON_ASSERT_FAILURE cause assertions failures to call abort(), which will usually make debugging easier. MALLOC_FAILURE_ACTION default: sets errno to ENOMEM, or no-op on win32 The action to take before "return 0" when malloc fails to be able to return memory because there is none available. HAVE_MORECORE default: 1 (true) unless win32 or ONLY_MSPACES True if this system supports sbrk or an emulation of it. MORECORE default: sbrk The name of the sbrk-style system routine to call to obtain more memory. See below for guidance on writing custom MORECORE functions. The type of the argument to sbrk/MORECORE varies across systems. It cannot be size_t, because it supports negative arguments, so it is normally the signed type of the same width as size_t (sometimes declared as "intptr_t"). It doesn't much matter though. Internally, we only call it with arguments less than half the max value of a size_t, which should work across all reasonable possibilities, although sometimes generating compiler warnings. See near the end of this file for guidelines for creating a custom version of MORECORE. MORECORE_CONTIGUOUS default: 1 (true) if HAVE_MORECORE If true, take advantage of fact that consecutive calls to MORECORE with positive arguments always return contiguous increasing addresses. This is true of unix sbrk. It does not hurt too much to set it true anyway, since malloc copes with non-contiguities. Setting it false when definitely non-contiguous saves time and possibly wasted space it would take to discover this though. MORECORE_CANNOT_TRIM default: NOT defined True if MORECORE cannot release space back to the system when given negative arguments. This is generally necessary only if you are using a hand-crafted MORECORE function that cannot handle negative arguments. NO_SEGMENT_TRAVERSAL default: 0 If non-zero, suppresses traversals of memory segments returned by either MORECORE or CALL_MMAP. This disables merging of segments that are contiguous, and selectively releasing them to the OS if unused, but bounds execution times. HAVE_MMAP default: 1 (true) True if this system supports mmap or an emulation of it. If so, and HAVE_MORECORE is not true, MMAP is used for all system allocation. If set and HAVE_MORECORE is true as well, MMAP is primarily used to directly allocate very large blocks. It is also used as a backup strategy in cases where MORECORE fails to provide space from system. Note: A single call to MUNMAP is assumed to be able to unmap memory that may have be allocated using multiple calls to MMAP, so long as they are adjacent. HAVE_MREMAP default: 1 on linux, else 0 If true realloc() uses mremap() to re-allocate large blocks and extend or shrink allocation spaces. MMAP_CLEARS default: 1 except on WINCE. True if mmap clears memory so calloc doesn't need to. This is true for standard unix mmap using /dev/zero and on WIN32 except for WINCE. USE_BUILTIN_FFS default: 0 (i.e., not used) Causes malloc to use the builtin ffs() function to compute indices. Some compilers may recognize and intrinsify ffs to be faster than the supplied C version. Also, the case of x86 using gcc is special-cased to an asm instruction, so is already as fast as it can be, and so this setting has no effect. Similarly for Win32 under recent MS compilers. (On most x86s, the asm version is only slightly faster than the C version.) malloc_getpagesize default: derive from system includes, or 4096. The system page size. To the extent possible, this malloc manages memory from the system in page-size units. This may be (and usually is) a function rather than a constant. This is ignored if WIN32, where page size is determined using getSystemInfo during initialization. USE_DEV_RANDOM default: 0 (i.e., not used) Causes malloc to use /dev/random to initialize secure magic seed for stamping footers. Otherwise, the current time is used. NO_MALLINFO default: 0 If defined, don't compile "mallinfo". This can be a simple way of dealing with mismatches between system declarations and those in this file. MALLINFO_FIELD_TYPE default: size_t The type of the fields in the mallinfo struct. This was originally defined as "int" in SVID etc, but is more usefully defined as size_t. The value is used only if HAVE_USR_INCLUDE_MALLOC_H is not set REALLOC_ZERO_BYTES_FREES default: not defined This should be set if a call to realloc with zero bytes should be the same as a call to free. Some people think it should. Otherwise, since this malloc returns a unique pointer for malloc(0), so does realloc(p, 0). LACKS_UNISTD_H, LACKS_FCNTL_H, LACKS_SYS_PARAM_H, LACKS_SYS_MMAN_H LACKS_STRINGS_H, LACKS_STRING_H, LACKS_SYS_TYPES_H, LACKS_ERRNO_H LACKS_STDLIB_H default: NOT defined unless on WIN32 Define these if your system does not have these header files. You might need to manually insert some of the declarations they provide. DEFAULT_GRANULARITY default: page size if MORECORE_CONTIGUOUS, system_info.dwAllocationGranularity in WIN32, otherwise 64K. Also settable using mallopt(M_GRANULARITY, x) The unit for allocating and deallocating memory from the system. On most systems with contiguous MORECORE, there is no reason to make this more than a page. However, systems with MMAP tend to either require or encourage larger granularities. You can increase this value to prevent system allocation functions to be called so often, especially if they are slow. The value must be at least one page and must be a power of two. Setting to 0 causes initialization to either page size or win32 region size. (Note: In previous versions of malloc, the equivalent of this option was called "TOP_PAD") DEFAULT_TRIM_THRESHOLD default: 2MB Also settable using mallopt(M_TRIM_THRESHOLD, x) The maximum amount of unused top-most memory to keep before releasing via malloc_trim in free(). Automatic trimming is mainly useful in long-lived programs using contiguous MORECORE. Because trimming via sbrk can be slow on some systems, and can sometimes be wasteful (in cases where programs immediately afterward allocate more large chunks) the value should be high enough so that your overall system performance would improve by releasing this much memory. As a rough guide, you might set to a value close to the average size of a process (program) running on your system. Releasing this much memory would allow such a process to run in memory. Generally, it is worth tuning trim thresholds when a program undergoes phases where several large chunks are allocated and released in ways that can reuse each other's storage, perhaps mixed with phases where there are no such chunks at all. The trim value must be greater than page size to have any useful effect. To disable trimming completely, you can set to MAX_SIZE_T. Note that the trick some people use of mallocing a huge space and then freeing it at program startup, in an attempt to reserve system memory, doesn't have the intended effect under automatic trimming, since that memory will immediately be returned to the system. DEFAULT_MMAP_THRESHOLD default: 256K Also settable using mallopt(M_MMAP_THRESHOLD, x) The request size threshold for using MMAP to directly service a request. Requests of at least this size that cannot be allocated using already-existing space will be serviced via mmap. (If enough normal freed space already exists it is used instead.) Using mmap segregates relatively large chunks of memory so that they can be individually obtained and released from the host system. A request serviced through mmap is never reused by any other request (at least not directly; the system may just so happen to remap successive requests to the same locations). Segregating space in this way has the benefits that: Mmapped space can always be individually released back to the system, which helps keep the system level memory demands of a long-lived program low. Also, mapped memory doesn't become `locked' between other chunks, as can happen with normally allocated chunks, which means that even trimming via malloc_trim would not release them. However, it has the disadvantage that the space cannot be reclaimed, consolidated, and then used to service later requests, as happens with normal chunks. The advantages of mmap nearly always outweigh disadvantages for "large" chunks, but the value of "large" may vary across systems. The default is an empirically derived value that works well in most systems. You can disable mmap by setting to MAX_SIZE_T. MAX_RELEASE_CHECK_RATE default: 255 unless not HAVE_MMAP The number of consolidated frees between checks to release unused segments when freeing. When using non-contiguous segments, especially with multiple mspaces, checking only for topmost space doesn't always suffice to trigger trimming. To compensate for this, free() will, with a period of MAX_RELEASE_CHECK_RATE (or the current number of segments, if greater) try to release unused segments to the OS when freeing chunks that result in consolidation. The best value for this parameter is a compromise between slowing down frees with relatively costly checks that rarely trigger versus holding on to unused memory. To effectively disable, set to MAX_SIZE_T. This may lead to a very slight speed improvement at the expense of carrying around more memory. */ #ifndef WIN32 #ifdef _WIN32 #define WIN32 1 #endif /* _WIN32 */ #endif /* WIN32 */ #ifdef WIN32 #define WIN32_LEAN_AND_MEAN #include #define HAVE_MMAP 1 #define HAVE_MORECORE 0 #define LACKS_UNISTD_H #define LACKS_SYS_PARAM_H #define LACKS_SYS_MMAN_H #define LACKS_STRING_H #define LACKS_STRINGS_H #define LACKS_SYS_TYPES_H #define LACKS_ERRNO_H #define MALLOC_FAILURE_ACTION #ifdef _WIN32_WCE /* WINCE reportedly does not clear */ #define MMAP_CLEARS 0 #else #define MMAP_CLEARS 1 #endif /* _WIN32_WCE */ #endif /* WIN32 */ #if defined(DARWIN) || defined(_DARWIN) /* Mac OSX docs advise not to use sbrk; it seems better to use mmap */ #ifndef HAVE_MORECORE #define HAVE_MORECORE 0 #define HAVE_MMAP 1 #endif /* HAVE_MORECORE */ #endif /* DARWIN */ #ifndef LACKS_SYS_TYPES_H #include /* For size_t */ #endif /* LACKS_SYS_TYPES_H */ /* The maximum possible size_t value has all bits set */ #define MAX_SIZE_T (~(size_t)0) #ifndef ONLY_MSPACES #define ONLY_MSPACES 0 #endif /* ONLY_MSPACES */ #ifndef MSPACES #if ONLY_MSPACES #define MSPACES 1 #else /* ONLY_MSPACES */ #define MSPACES 0 #endif /* ONLY_MSPACES */ #endif /* MSPACES */ #ifndef MALLOC_ALIGNMENT #define MALLOC_ALIGNMENT ((size_t)8U) #endif /* MALLOC_ALIGNMENT */ #ifndef FOOTERS #define FOOTERS 0 #endif /* FOOTERS */ #ifndef ABORT #define ABORT abort() #endif /* ABORT */ #ifndef ABORT_ON_ASSERT_FAILURE #define ABORT_ON_ASSERT_FAILURE 1 #endif /* ABORT_ON_ASSERT_FAILURE */ #ifndef PROCEED_ON_ERROR #define PROCEED_ON_ERROR 0 #endif /* PROCEED_ON_ERROR */ #ifndef USE_LOCKS #define USE_LOCKS 0 #endif /* USE_LOCKS */ #ifndef USE_SPIN_LOCKS #if USE_LOCKS && (defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))) || (defined(_MSC_VER) && _MSC_VER>=1310) #define USE_SPIN_LOCKS 1 #else #define USE_SPIN_LOCKS 0 #endif /* USE_LOCKS && ... */ #endif /* USE_SPIN_LOCKS */ #ifndef INSECURE #define INSECURE 0 #endif /* INSECURE */ #ifndef HAVE_MMAP #define HAVE_MMAP 1 #endif /* HAVE_MMAP */ #ifndef MMAP_CLEARS #define MMAP_CLEARS 1 #endif /* MMAP_CLEARS */ #ifndef HAVE_MREMAP #ifdef linux #define HAVE_MREMAP 1 #else /* linux */ #define HAVE_MREMAP 0 #endif /* linux */ #endif /* HAVE_MREMAP */ #ifndef MALLOC_FAILURE_ACTION #define MALLOC_FAILURE_ACTION errno = ENOMEM; #endif /* MALLOC_FAILURE_ACTION */ #ifndef HAVE_MORECORE #if ONLY_MSPACES #define HAVE_MORECORE 0 #else /* ONLY_MSPACES */ #define HAVE_MORECORE 1 #endif /* ONLY_MSPACES */ #endif /* HAVE_MORECORE */ #if !HAVE_MORECORE #define MORECORE_CONTIGUOUS 0 #else /* !HAVE_MORECORE */ #ifndef MORECORE #define MORECORE sbrk #endif /* MORECORE */ #ifndef MORECORE_CONTIGUOUS #define MORECORE_CONTIGUOUS 1 #endif /* MORECORE_CONTIGUOUS */ #endif /* HAVE_MORECORE */ #ifndef DEFAULT_GRANULARITY #if MORECORE_CONTIGUOUS #define DEFAULT_GRANULARITY (0) /* 0 means to compute in init_mparams */ #else /* MORECORE_CONTIGUOUS */ #define DEFAULT_GRANULARITY ((size_t)64U * (size_t)1024U) #endif /* MORECORE_CONTIGUOUS */ #endif /* DEFAULT_GRANULARITY */ #ifndef DEFAULT_TRIM_THRESHOLD #ifndef MORECORE_CANNOT_TRIM #define DEFAULT_TRIM_THRESHOLD ((size_t)2U * (size_t)1024U * (size_t)1024U) #else /* MORECORE_CANNOT_TRIM */ #define DEFAULT_TRIM_THRESHOLD MAX_SIZE_T #endif /* MORECORE_CANNOT_TRIM */ #endif /* DEFAULT_TRIM_THRESHOLD */ #ifndef DEFAULT_MMAP_THRESHOLD #if HAVE_MMAP #define DEFAULT_MMAP_THRESHOLD ((size_t)256U * (size_t)1024U) #else /* HAVE_MMAP */ #define DEFAULT_MMAP_THRESHOLD MAX_SIZE_T #endif /* HAVE_MMAP */ #endif /* DEFAULT_MMAP_THRESHOLD */ #ifndef MAX_RELEASE_CHECK_RATE #if HAVE_MMAP #define MAX_RELEASE_CHECK_RATE 255 #else #define MAX_RELEASE_CHECK_RATE MAX_SIZE_T #endif /* HAVE_MMAP */ #endif /* MAX_RELEASE_CHECK_RATE */ #ifndef USE_BUILTIN_FFS #define USE_BUILTIN_FFS 0 #endif /* USE_BUILTIN_FFS */ #ifndef USE_DEV_RANDOM #define USE_DEV_RANDOM 0 #endif /* USE_DEV_RANDOM */ #ifndef NO_MALLINFO #define NO_MALLINFO 0 #endif /* NO_MALLINFO */ #ifndef MALLINFO_FIELD_TYPE #define MALLINFO_FIELD_TYPE size_t #endif /* MALLINFO_FIELD_TYPE */ #ifndef NO_SEGMENT_TRAVERSAL #define NO_SEGMENT_TRAVERSAL 0 #endif /* NO_SEGMENT_TRAVERSAL */ /* mallopt tuning options. SVID/XPG defines four standard parameter numbers for mallopt, normally defined in malloc.h. None of these are used in this malloc, so setting them has no effect. But this malloc does support the following options. */ #define M_TRIM_THRESHOLD (-1) #define M_GRANULARITY (-2) #define M_MMAP_THRESHOLD (-3) /* ------------------------ Mallinfo declarations ------------------------ */ #if !NO_MALLINFO /* This version of malloc supports the standard SVID/XPG mallinfo routine that returns a struct containing usage properties and statistics. It should work on any system that has a /usr/include/malloc.h defining struct mallinfo. The main declaration needed is the mallinfo struct that is returned (by-copy) by mallinfo(). The malloinfo struct contains a bunch of fields that are not even meaningful in this version of malloc. These fields are are instead filled by mallinfo() with other numbers that might be of interest. HAVE_USR_INCLUDE_MALLOC_H should be set if you have a /usr/include/malloc.h file that includes a declaration of struct mallinfo. If so, it is included; else a compliant version is declared below. These must be precisely the same for mallinfo() to work. The original SVID version of this struct, defined on most systems with mallinfo, declares all fields as ints. But some others define as unsigned long. If your system defines the fields using a type of different width than listed here, you MUST #include your system version and #define HAVE_USR_INCLUDE_MALLOC_H. */ /* #define HAVE_USR_INCLUDE_MALLOC_H */ #ifdef HAVE_USR_INCLUDE_MALLOC_H #include "/usr/include/malloc.h" #else /* HAVE_USR_INCLUDE_MALLOC_H */ struct mallinfo { MALLINFO_FIELD_TYPE arena; /* non-mmapped space allocated from system */ MALLINFO_FIELD_TYPE ordblks; /* number of free chunks */ MALLINFO_FIELD_TYPE smblks; /* always 0 */ MALLINFO_FIELD_TYPE hblks; /* always 0 */ MALLINFO_FIELD_TYPE hblkhd; /* space in mmapped regions */ MALLINFO_FIELD_TYPE usmblks; /* maximum total allocated space */ MALLINFO_FIELD_TYPE fsmblks; /* always 0 */ MALLINFO_FIELD_TYPE uordblks; /* total allocated space */ MALLINFO_FIELD_TYPE fordblks; /* total free space */ MALLINFO_FIELD_TYPE keepcost; /* releasable (via malloc_trim) space */ }; #endif /* HAVE_USR_INCLUDE_MALLOC_H */ #endif /* NO_MALLINFO */ /* Try to persuade compilers to inline. The most critical functions for inlining are defined as macros, so these aren't used for them. */ #ifndef FORCEINLINE #if defined(__GNUC__) #define FORCEINLINE __inline __attribute__ ((always_inline)) #elif defined(_MSC_VER) #define FORCEINLINE __forceinline #endif #endif #ifndef NOINLINE #if defined(__GNUC__) #define NOINLINE __attribute__ ((noinline)) #elif defined(_MSC_VER) #define NOINLINE __declspec(noinline) #else #define NOINLINE #endif #endif #ifdef __cplusplus extern "C" { #ifndef FORCEINLINE #define FORCEINLINE inline #endif #endif /* __cplusplus */ #ifndef FORCEINLINE #define FORCEINLINE #endif #if !ONLY_MSPACES /* ------------------- Declarations of public routines ------------------- */ #ifndef USE_DL_PREFIX #define dlcalloc calloc #define dlfree free #define dlmalloc malloc #define dlmemalign memalign #define dlrealloc realloc #define dlvalloc valloc #define dlpvalloc pvalloc #define dlmallinfo mallinfo #define dlmallopt mallopt #define dlmalloc_trim malloc_trim #define dlmalloc_stats malloc_stats #define dlmalloc_usable_size malloc_usable_size #define dlmalloc_footprint malloc_footprint #define dlmalloc_max_footprint malloc_max_footprint #define dlindependent_calloc independent_calloc #define dlindependent_comalloc independent_comalloc #endif /* USE_DL_PREFIX */ /* malloc(size_t n) Returns a pointer to a newly allocated chunk of at least n bytes, or null if no space is available, in which case errno is set to ENOMEM on ANSI C systems. If n is zero, malloc returns a minimum-sized chunk. (The minimum size is 16 bytes on most 32bit systems, and 32 bytes on 64bit systems.) Note that size_t is an unsigned type, so calls with arguments that would be negative if signed are interpreted as requests for huge amounts of space, which will often fail. The maximum supported value of n differs across systems, but is in all cases less than the maximum representable value of a size_t. */ void* dlmalloc(size_t); /* free(void* p) Releases the chunk of memory pointed to by p, that had been previously allocated using malloc or a related routine such as realloc. It has no effect if p is null. If p was not malloced or already freed, free(p) will by default cause the current program to abort. */ void dlfree(void*); /* calloc(size_t n_elements, size_t element_size); Returns a pointer to n_elements * element_size bytes, with all locations set to zero. */ void* dlcalloc(size_t, size_t); /* realloc(void* p, size_t n) Returns a pointer to a chunk of size n that contains the same data as does chunk p up to the minimum of (n, p's size) bytes, or null if no space is available. The returned pointer may or may not be the same as p. The algorithm prefers extending p in most cases when possible, otherwise it employs the equivalent of a malloc-copy-free sequence. If p is null, realloc is equivalent to malloc. If space is not available, realloc returns null, errno is set (if on ANSI) and p is NOT freed. if n is for fewer bytes than already held by p, the newly unused space is lopped off and freed if possible. realloc with a size argument of zero (re)allocates a minimum-sized chunk. The old unix realloc convention of allowing the last-free'd chunk to be used as an argument to realloc is not supported. */ void* dlrealloc(void*, size_t); /* memalign(size_t alignment, size_t n); Returns a pointer to a newly allocated chunk of n bytes, aligned in accord with the alignment argument. The alignment argument should be a power of two. If the argument is not a power of two, the nearest greater power is used. 8-byte alignment is guaranteed by normal malloc calls, so don't bother calling memalign with an argument of 8 or less. Overreliance on memalign is a sure way to fragment space. */ void* dlmemalign(size_t, size_t); /* valloc(size_t n); Equivalent to memalign(pagesize, n), where pagesize is the page size of the system. If the pagesize is unknown, 4096 is used. */ void* dlvalloc(size_t); /* mallopt(int parameter_number, int parameter_value) Sets tunable parameters The format is to provide a (parameter-number, parameter-value) pair. mallopt then sets the corresponding parameter to the argument value if it can (i.e., so long as the value is meaningful), and returns 1 if successful else 0. SVID/XPG/ANSI defines four standard param numbers for mallopt, normally defined in malloc.h. None of these are use in this malloc, so setting them has no effect. But this malloc also supports other options in mallopt. See below for details. Briefly, supported parameters are as follows (listed defaults are for "typical" configurations). Symbol param # default allowed param values M_TRIM_THRESHOLD -1 2*1024*1024 any (MAX_SIZE_T disables) M_GRANULARITY -2 page size any power of 2 >= page size M_MMAP_THRESHOLD -3 256*1024 any (or 0 if no MMAP support) */ int dlmallopt(int, int); /* malloc_footprint(); Returns the number of bytes obtained from the system. The total number of bytes allocated by malloc, realloc etc., is less than this value. Unlike mallinfo, this function returns only a precomputed result, so can be called frequently to monitor memory consumption. Even if locks are otherwise defined, this function does not use them, so results might not be up to date. */ size_t dlmalloc_footprint(void); /* malloc_max_footprint(); Returns the maximum number of bytes obtained from the system. This value will be greater than current footprint if deallocated space has been reclaimed by the system. The peak number of bytes allocated by malloc, realloc etc., is less than this value. Unlike mallinfo, this function returns only a precomputed result, so can be called frequently to monitor memory consumption. Even if locks are otherwise defined, this function does not use them, so results might not be up to date. */ size_t dlmalloc_max_footprint(void); #if !NO_MALLINFO /* mallinfo() Returns (by copy) a struct containing various summary statistics: arena: current total non-mmapped bytes allocated from system ordblks: the number of free chunks smblks: always zero. hblks: current number of mmapped regions hblkhd: total bytes held in mmapped regions usmblks: the maximum total allocated space. This will be greater than current total if trimming has occurred. fsmblks: always zero uordblks: current total allocated space (normal or mmapped) fordblks: total free space keepcost: the maximum number of bytes that could ideally be released back to system via malloc_trim. ("ideally" means that it ignores page restrictions etc.) Because these fields are ints, but internal bookkeeping may be kept as longs, the reported values may wrap around zero and thus be inaccurate. */ struct mallinfo dlmallinfo(void); #endif /* NO_MALLINFO */ /* independent_calloc(size_t n_elements, size_t element_size, void* chunks[]); independent_calloc is similar to calloc, but instead of returning a single cleared space, it returns an array of pointers to n_elements independent elements that can hold contents of size elem_size, each of which starts out cleared, and can be independently freed, realloc'ed etc. The elements are guaranteed to be adjacently allocated (this is not guaranteed to occur with multiple callocs or mallocs), which may also improve cache locality in some applications. The "chunks" argument is optional (i.e., may be null, which is probably the most typical usage). If it is null, the returned array is itself dynamically allocated and should also be freed when it is no longer needed. Otherwise, the chunks array must be of at least n_elements in length. It is filled in with the pointers to the chunks. In either case, independent_calloc returns this pointer array, or null if the allocation failed. If n_elements is zero and "chunks" is null, it returns a chunk representing an array with zero elements (which should be freed if not wanted). Each element must be individually freed when it is no longer needed. If you'd like to instead be able to free all at once, you should instead use regular calloc and assign pointers into this space to represent elements. (In this case though, you cannot independently free elements.) independent_calloc simplifies and speeds up implementations of many kinds of pools. It may also be useful when constructing large data structures that initially have a fixed number of fixed-sized nodes, but the number is not known at compile time, and some of the nodes may later need to be freed. For example: struct Node { int item; struct Node* next; }; struct Node* build_list() { struct Node** pool; int n = read_number_of_nodes_needed(); if (n <= 0) return 0; pool = (struct Node**)(independent_calloc(n, sizeof(struct Node), 0); if (pool == 0) die(); // organize into a linked list... struct Node* first = pool[0]; for (i = 0; i < n-1; ++i) pool[i]->next = pool[i+1]; free(pool); // Can now free the array (or not, if it is needed later) return first; } */ void** dlindependent_calloc(size_t, size_t, void**); /* independent_comalloc(size_t n_elements, size_t sizes[], void* chunks[]); independent_comalloc allocates, all at once, a set of n_elements chunks with sizes indicated in the "sizes" array. It returns an array of pointers to these elements, each of which can be independently freed, realloc'ed etc. The elements are guaranteed to be adjacently allocated (this is not guaranteed to occur with multiple callocs or mallocs), which may also improve cache locality in some applications. The "chunks" argument is optional (i.e., may be null). If it is null the returned array is itself dynamically allocated and should also be freed when it is no longer needed. Otherwise, the chunks array must be of at least n_elements in length. It is filled in with the pointers to the chunks. In either case, independent_comalloc returns this pointer array, or null if the allocation failed. If n_elements is zero and chunks is null, it returns a chunk representing an array with zero elements (which should be freed if not wanted). Each element must be individually freed when it is no longer needed. If you'd like to instead be able to free all at once, you should instead use a single regular malloc, and assign pointers at particular offsets in the aggregate space. (In this case though, you cannot independently free elements.) independent_comallac differs from independent_calloc in that each element may have a different size, and also that it does not automatically clear elements. independent_comalloc can be used to speed up allocation in cases where several structs or objects must always be allocated at the same time. For example: struct Head { ... } struct Foot { ... } void send_message(char* msg) { int msglen = strlen(msg); size_t sizes[3] = { sizeof(struct Head), msglen, sizeof(struct Foot) }; void* chunks[3]; if (independent_comalloc(3, sizes, chunks) == 0) die(); struct Head* head = (struct Head*)(chunks[0]); char* body = (char*)(chunks[1]); struct Foot* foot = (struct Foot*)(chunks[2]); // ... } In general though, independent_comalloc is worth using only for larger values of n_elements. For small values, you probably won't detect enough difference from series of malloc calls to bother. Overuse of independent_comalloc can increase overall memory usage, since it cannot reuse existing noncontiguous small chunks that might be available for some of the elements. */ void** dlindependent_comalloc(size_t, size_t*, void**); /* pvalloc(size_t n); Equivalent to valloc(minimum-page-that-holds(n)), that is, round up n to nearest pagesize. */ void* dlpvalloc(size_t); /* malloc_trim(size_t pad); If possible, gives memory back to the system (via negative arguments to sbrk) if there is unused memory at the `high' end of the malloc pool or in unused MMAP segments. You can call this after freeing large blocks of memory to potentially reduce the system-level memory requirements of a program. However, it cannot guarantee to reduce memory. Under some allocation patterns, some large free blocks of memory will be locked between two used chunks, so they cannot be given back to the system. The `pad' argument to malloc_trim represents the amount of free trailing space to leave untrimmed. If this argument is zero, only the minimum amount of memory to maintain internal data structures will be left. Non-zero arguments can be supplied to maintain enough trailing space to service future expected allocations without having to re-obtain memory from the system. Malloc_trim returns 1 if it actually released any memory, else 0. */ int dlmalloc_trim(size_t); /* malloc_usable_size(void* p); Returns the number of bytes you can actually use in an allocated chunk, which may be more than you requested (although often not) due to alignment and minimum size constraints. You can use this many bytes without worrying about overwriting other allocated objects. This is not a particularly great programming practice. malloc_usable_size can be more useful in debugging and assertions, for example: p = malloc(n); assert(malloc_usable_size(p) >= 256); */ size_t dlmalloc_usable_size(void*); /* malloc_stats(); Prints on stderr the amount of space obtained from the system (both via sbrk and mmap), the maximum amount (which may be more than current if malloc_trim and/or munmap got called), and the current number of bytes allocated via malloc (or realloc, etc) but not yet freed. Note that this is the number of bytes allocated, not the number requested. It will be larger than the number requested because of alignment and bookkeeping overhead. Because it includes alignment wastage as being in use, this figure may be greater than zero even when no user-level chunks are allocated. The reported current and maximum system memory can be inaccurate if a program makes other calls to system memory allocation functions (normally sbrk) outside of malloc. malloc_stats prints only the most commonly interesting statistics. More information can be obtained by calling mallinfo. */ void dlmalloc_stats(void); #endif /* ONLY_MSPACES */ #if MSPACES /* mspace is an opaque type representing an independent region of space that supports mspace_malloc, etc. */ typedef void* mspace; /* create_mspace creates and returns a new independent space with the given initial capacity, or, if 0, the default granularity size. It returns null if there is no system memory available to create the space. If argument locked is non-zero, the space uses a separate lock to control access. The capacity of the space will grow dynamically as needed to service mspace_malloc requests. You can control the sizes of incremental increases of this space by compiling with a different DEFAULT_GRANULARITY or dynamically setting with mallopt(M_GRANULARITY, value). */ mspace create_mspace(size_t capacity, int locked); /* destroy_mspace destroys the given space, and attempts to return all of its memory back to the system, returning the total number of bytes freed. After destruction, the results of access to all memory used by the space become undefined. */ size_t destroy_mspace(mspace msp); /* create_mspace_with_base uses the memory supplied as the initial base of a new mspace. Part (less than 128*sizeof(size_t) bytes) of this space is used for bookkeeping, so the capacity must be at least this large. (Otherwise 0 is returned.) When this initial space is exhausted, additional memory will be obtained from the system. Destroying this space will deallocate all additionally allocated space (if possible) but not the initial base. */ mspace create_mspace_with_base(void* base, size_t capacity, int locked); /* mspace_malloc behaves as malloc, but operates within the given space. */ void* mspace_malloc(mspace msp, size_t bytes); /* mspace_free behaves as free, but operates within the given space. If compiled with FOOTERS==1, mspace_free is not actually needed. free may be called instead of mspace_free because freed chunks from any space are handled by their originating spaces. */ void mspace_free(mspace msp, void* mem); /* mspace_realloc behaves as realloc, but operates within the given space. If compiled with FOOTERS==1, mspace_realloc is not actually needed. realloc may be called instead of mspace_realloc because realloced chunks from any space are handled by their originating spaces. */ void* mspace_realloc(mspace msp, void* mem, size_t newsize); /* mspace_calloc behaves as calloc, but operates within the given space. */ void* mspace_calloc(mspace msp, size_t n_elements, size_t elem_size); /* mspace_memalign behaves as memalign, but operates within the given space. */ void* mspace_memalign(mspace msp, size_t alignment, size_t bytes); /* mspace_independent_calloc behaves as independent_calloc, but operates within the given space. */ void** mspace_independent_calloc(mspace msp, size_t n_elements, size_t elem_size, void* chunks[]); /* mspace_independent_comalloc behaves as independent_comalloc, but operates within the given space. */ void** mspace_independent_comalloc(mspace msp, size_t n_elements, size_t sizes[], void* chunks[]); /* mspace_footprint() returns the number of bytes obtained from the system for this space. */ size_t mspace_footprint(mspace msp); /* mspace_max_footprint() returns the peak number of bytes obtained from the system for this space. */ size_t mspace_max_footprint(mspace msp); #if !NO_MALLINFO /* mspace_mallinfo behaves as mallinfo, but reports properties of the given space. */ struct mallinfo mspace_mallinfo(mspace msp); #endif /* NO_MALLINFO */ /* mspace_malloc_stats behaves as malloc_stats, but reports properties of the given space. */ void mspace_malloc_stats(mspace msp); /* mspace_trim behaves as malloc_trim, but operates within the given space. */ int mspace_trim(mspace msp, size_t pad); /* An alias for mallopt. */ int mspace_mallopt(int, int); #endif /* MSPACES */ #ifdef __cplusplus }; /* end of extern "C" */ #endif /* __cplusplus */ PyMetis-0.90/src/gklib/gk_externs.h0000640000175000017500000000114610662171744017057 0ustar andreasandreas/*! \file gk_externs.h \brief This file contains definitions of external variables created by GKlib \date Started 3/27/2007 \author George \version\verbatim $Id: gk_externs.h 1277 2007-03-27 21:17:33Z karypis $ \endverbatim */ #ifndef _GK_EXTERNS_H_ #define _GK_EXTERNS_H_ /************************************************************************* * Extern variable definition. Hopefully, the __thread makes them thread-safe. **************************************************************************/ #ifndef _GK_ERROR_C_ extern __thread jmp_buf gk_return_to_entry; /* declared in error.c */ #endif #endif PyMetis-0.90/src/gklib/gk_getopt.h0000640000175000017500000000477510662171744016704 0ustar andreasandreas/*! \file gk_getopt.h \brief This file contains GNU's externs/structs/prototypes \date Started 3/27/2007 \author George \version\verbatim $Id: gk_getopt.h 1277 2007-03-27 21:17:33Z karypis $ \endverbatim */ #ifndef _GK_GETOPT_H_ #define _GK_GETOPT_H_ /* Externals from getopt.c */ extern char *gk_optarg; extern int gk_optind; extern int gk_opterr; extern int gk_optopt; /*! \brief The structure that stores the information about the command-line options This structure describes a single long option name for the sake of gk_getopt_long(). The argument long_options must be an array of these structures, one for each long option. Terminate the array with an element containing all zeros. */ struct gk_option { const char *name; /*!< This field is the name of the option. */ int has_arg; /*!< This field says whether the option takes an argument. It is an integer, and there are three legitimate values: no_argument, required_argument and optional_argument. \todo Need to better define/use the constants for this member variable. */ int *flag; /*!< See the discussion on ::gk_option#val */ int val; /*!< These fields control how to report or act on the option when it occurs. If flag is a null pointer, then the val is a value which identifies this option. Often these values are chosen to uniquely identify particular long options. If flag is not a null pointer, it should be the address of an int variable which is the flag for this option. The value in val is the value to store in the flag to indicate that the option was seen. */ }; /* Names for the values of the `has_arg' field of `struct gk_option'. */ #define no_argument 0 #define required_argument 1 #define optional_argument 2 /* Function prototypes */ extern int gk_getopt(int __argc, char **__argv, const char *__shortopts); extern int gk_getopt_long(int __argc, char *const *__argv, const char *__shortopts, const struct gk_option *__longopts, int *__longind); extern int gk_getopt_long_only (int __argc, char *const *__argv, const char *__shortopts, const struct gk_option *__longopts, int *__longind); #endif PyMetis-0.90/src/gklib/gk_macros.h0000640000175000017500000001025410662171744016653 0ustar andreasandreas/*! \file gk_macros.h \brief This file contains various macros \date Started 3/27/2007 \author George \version\verbatim $Id: gk_macros.h 1432 2007-04-07 20:06:19Z karypis $ \endverbatim */ #ifndef _GK_MACROS_H_ #define _GK_MACROS_H_ /*------------------------------------------------------------- * Usefull commands *-------------------------------------------------------------*/ #define amax(a, b) ((a) >= (b) ? (a) : (b)) #define amin(a, b) ((a) >= (b) ? (b) : (a)) #define amax3(a, b, c) ((a) >= (b) && (a) >= (c) ? (a) : ((b) >= (a) && (b) >= (c) ? (b) : (c))) #define SWAP(a, b, tmp) do {(tmp) = (a); (a) = (b); (b) = (tmp);} while(0) #define INC_DEC(a, b, val) do {(a) += (val); (b) -= (val);} while(0) #define gk_ccopy(n, a, b) (int *)memmove((void *)(b), (void *)(a), sizeof(char)*(n)) #define gk_icopy(n, a, b) (int *)memmove((void *)(b), (void *)(a), sizeof(int)*(n)) #define gk_fcopy(n, a, b) (float *)memmove((void *)(b), (void *)(a), sizeof(float)*(n)) #define gk_dcopy(n, a, b) (double *)memmove((void *)(b), (void *)(a), sizeof(double)*(n)) #define gk_idxcopy(n, a, b) (double *)memmove((void *)(b), (void *)(a), sizeof(gk_idx_t)*(n)) #define sign(a, b) ((a >= 0 ? b : -b)) #define ONEOVERRANDMAX (1.0/(RAND_MAX+1.0)) #define RandomInRange(u) ((int) (ONEOVERRANDMAX*(u)*rand())) /*------------------------------------------------------------- * Timing macros *-------------------------------------------------------------*/ #define gk_clearcputimer(tmr) (tmr = 0.0) #define gk_startcputimer(tmr) (tmr -= gk_CPUSeconds()) #define gk_stopcputimer(tmr) (tmr += gk_CPUSeconds()) #define gk_getcputimer(tmr) (tmr) #define gk_clearwctimer(tmr) (tmr = 0.0) #define gk_startwctimer(tmr) (tmr -= gk_WClockSeconds()) #define gk_stopwctimer(tmr) (tmr += gk_WClockSeconds()) #define gk_getwctimer(tmr) (tmr) /*------------------------------------------------------------- * dbglvl handling macros *-------------------------------------------------------------*/ #define IFSET(a, flag, cmd) if ((a)&(flag)) (cmd); /*------------------------------------------------------------- * gracefull library exit macro *-------------------------------------------------------------*/ #define GKSETJMP() (setjmp(gk_return_to_entry)) /*------------------------------------------------------------- * Debuging memory leaks *-------------------------------------------------------------*/ #ifdef DMALLOC # define MALLOC_CHECK(ptr) \ if (malloc_verify((ptr)) == DMALLOC_VERIFY_ERROR) { \ printf("***MALLOC_CHECK failed on line %d of file %s: " #ptr "\n", \ __LINE__, __FILE__); \ abort(); \ } #else # define MALLOC_CHECK(ptr) ; #endif /*------------------------------------------------------------- * CSR conversion macros *-------------------------------------------------------------*/ #define MAKECSR(i, n, a) \ do { \ for (i=1; i0; i--) a[i] = a[i-1]; \ a[0] = 0; \ } while(0) #define SHIFTCSR(i, n, a) \ do { \ for (i=n; i>0; i--) a[i] = a[i-1]; \ a[0] = 0; \ } while(0) /*------------------------------------------------------------- * Program Assertions *-------------------------------------------------------------*/ #ifdef DEBUG # define ASSERT(expr) \ if (!(expr)) { \ printf("***ASSERTION failed on line %d of file %s: " #expr "\n", \ __LINE__, __FILE__); \ abort(); \ } #else # define ASSERT(expr) ; #endif #ifdef DEBUG # define ASSERTP(expr,msg) \ if (!(expr)) { \ printf("***ASSERTION failed on line %d of file %s: " #expr "\n", \ __LINE__, __FILE__); \ printf msg ; \ printf("\n"); \ abort(); \ } #else # define ASSERTP(expr,msg) ; #endif #endif PyMetis-0.90/src/gklib/gk_memory.h0000640000175000017500000000640010662171744016675 0ustar andreasandreas/*! \file gk_memory.h \brief This file contains GKlib's code generators for memory allocation routines \date Started 3/29/07 \author George \version\verbatim $Id: gk_memory.h 1432 2007-04-07 20:06:19Z karypis $ \endverbatim */ #ifndef _GK_MEMORY_H_ #define _GK_MEMORY_H_ /*************************************************************************/ /*! The macro for gk_?malloc()-class of routines */ /**************************************************************************/ #define GK_XMALLOC(NAME, TYPE)\ TYPE *NAME(size_t n, char *msg)\ { return (TYPE *)gk_malloc(sizeof(TYPE)*n, msg); } #define GK_XMALLOC_PROTO(NAME, TYPE)\ TYPE *NAME(size_t n, char *msg); /*************************************************************************/ /*! The macro for gk_?realloc()-class of routines */ /**************************************************************************/ #define GK_XREALLOC(NAME, TYPE)\ TYPE *NAME(TYPE *ptr, size_t n, char *msg)\ { return (TYPE *)gk_realloc((void *)ptr, sizeof(TYPE)*n, msg); } #define GK_XREALLOC_PROTO(NAME, TYPE)\ TYPE *NAME(TYPE *ptr, size_t n, char *msg); /*************************************************************************/ /*! The macro for gk_?smalloc()-class of routines */ /**************************************************************************/ #define GK_XSMALLOC(NAME, TYPE, SET)\ TYPE *NAME(size_t n, TYPE ival, char *msg)\ { return SET(n, ival, (TYPE *)gk_malloc(sizeof(TYPE)*n, msg)); } #define GK_XSMALLOC_PROTO(NAME, TYPE)\ TYPE *NAME(size_t n, TYPE ival, char *msg); /*************************************************************************/ /*! The macro for gk_?AllocMatrix()-class of routines */ /**************************************************************************/ #define GK_ALLOCMATRIX(NAME, TYPE, ROWALLOC)\ TYPE **NAME(size_t ndim1, size_t ndim2, TYPE value, char *errmsg)\ {\ gk_loop_t i;\ TYPE **matrix;\ \ matrix = (TYPE **)gk_malloc(ndim1*sizeof(TYPE *), errmsg);\ for (i=0; ikey < (b)->key) * GKQSORT(struct elt, arr, n, elt_lt); * } * * And so on. */ /* Swap two items pointed to by A and B using temporary buffer t. */ #define _GKQSORT_SWAP(a, b, t) ((void)((t = *a), (*a = *b), (*b = t))) /* Discontinue quicksort algorithm when partition gets below this size. This particular magic number was chosen to work best on a Sun 4/260. */ #define _GKQSORT_MAX_THRESH 4 /* The next 4 #defines implement a very fast in-line stack abstraction. */ #define _GKQSORT_STACK_SIZE (8 * sizeof(size_t)) #define _GKQSORT_PUSH(top, low, high) (((top->_lo = (low)), (top->_hi = (high)), ++top)) #define _GKQSORT_POP(low, high, top) ((--top, (low = top->_lo), (high = top->_hi))) #define _GKQSORT_STACK_NOT_EMPTY (_stack < _top) /* The main code starts here... */ #define GKQSORT(GKQSORT_TYPE,GKQSORT_BASE,GKQSORT_NELT,GKQSORT_LT) \ { \ GKQSORT_TYPE *const _base = (GKQSORT_BASE); \ const size_t _elems = (GKQSORT_NELT); \ GKQSORT_TYPE _hold; \ \ if (_elems == 0) \ return; \ \ /* Don't declare two variables of type GKQSORT_TYPE in a single \ * statement: eg `TYPE a, b;', in case if TYPE is a pointer, \ * expands to `type* a, b;' wich isn't what we want. \ */ \ \ if (_elems > _GKQSORT_MAX_THRESH) { \ GKQSORT_TYPE *_lo = _base; \ GKQSORT_TYPE *_hi = _lo + _elems - 1; \ struct { \ GKQSORT_TYPE *_hi; GKQSORT_TYPE *_lo; \ } _stack[_GKQSORT_STACK_SIZE], *_top = _stack + 1; \ \ while (_GKQSORT_STACK_NOT_EMPTY) { \ GKQSORT_TYPE *_left_ptr; GKQSORT_TYPE *_right_ptr; \ \ /* Select median value from among LO, MID, and HI. Rearrange \ LO and HI so the three values are sorted. This lowers the \ probability of picking a pathological pivot value and \ skips a comparison for both the LEFT_PTR and RIGHT_PTR in \ the while loops. */ \ \ GKQSORT_TYPE *_mid = _lo + ((_hi - _lo) >> 1); \ \ if (GKQSORT_LT (_mid, _lo)) \ _GKQSORT_SWAP (_mid, _lo, _hold); \ if (GKQSORT_LT (_hi, _mid)) \ _GKQSORT_SWAP (_mid, _hi, _hold); \ else \ goto _jump_over; \ if (GKQSORT_LT (_mid, _lo)) \ _GKQSORT_SWAP (_mid, _lo, _hold); \ _jump_over:; \ \ _left_ptr = _lo + 1; \ _right_ptr = _hi - 1; \ \ /* Here's the famous ``collapse the walls'' section of quicksort. \ Gotta like those tight inner loops! They are the main reason \ that this algorithm runs much faster than others. */ \ do { \ while (GKQSORT_LT (_left_ptr, _mid)) \ ++_left_ptr; \ \ while (GKQSORT_LT (_mid, _right_ptr)) \ --_right_ptr; \ \ if (_left_ptr < _right_ptr) { \ _GKQSORT_SWAP (_left_ptr, _right_ptr, _hold); \ if (_mid == _left_ptr) \ _mid = _right_ptr; \ else if (_mid == _right_ptr) \ _mid = _left_ptr; \ ++_left_ptr; \ --_right_ptr; \ } \ else if (_left_ptr == _right_ptr) { \ ++_left_ptr; \ --_right_ptr; \ break; \ } \ } while (_left_ptr <= _right_ptr); \ \ /* Set up pointers for next iteration. First determine whether \ left and right partitions are below the threshold size. If so, \ ignore one or both. Otherwise, push the larger partition's \ bounds on the stack and continue sorting the smaller one. */ \ \ if (_right_ptr - _lo <= _GKQSORT_MAX_THRESH) { \ if (_hi - _left_ptr <= _GKQSORT_MAX_THRESH) \ /* Ignore both small partitions. */ \ _GKQSORT_POP (_lo, _hi, _top); \ else \ /* Ignore small left partition. */ \ _lo = _left_ptr; \ } \ else if (_hi - _left_ptr <= _GKQSORT_MAX_THRESH) \ /* Ignore small right partition. */ \ _hi = _right_ptr; \ else if (_right_ptr - _lo > _hi - _left_ptr) { \ /* Push larger left partition indices. */ \ _GKQSORT_PUSH (_top, _lo, _right_ptr); \ _lo = _left_ptr; \ } \ else { \ /* Push larger right partition indices. */ \ _GKQSORT_PUSH (_top, _left_ptr, _hi); \ _hi = _right_ptr; \ } \ } \ } \ \ /* Once the BASE array is partially sorted by quicksort the rest \ is completely sorted using insertion sort, since this is efficient \ for partitions below MAX_THRESH size. BASE points to the \ beginning of the array to sort, and END_PTR points at the very \ last element in the array (*not* one beyond it!). */ \ \ { \ GKQSORT_TYPE *const _end_ptr = _base + _elems - 1; \ GKQSORT_TYPE *_tmp_ptr = _base; \ register GKQSORT_TYPE *_run_ptr; \ GKQSORT_TYPE *_thresh; \ \ _thresh = _base + _GKQSORT_MAX_THRESH; \ if (_thresh > _end_ptr) \ _thresh = _end_ptr; \ \ /* Find smallest element in first threshold and place it at the \ array's beginning. This is the smallest array element, \ and the operation speeds up insertion sort's inner loop. */ \ \ for (_run_ptr = _tmp_ptr + 1; _run_ptr <= _thresh; ++_run_ptr) \ if (GKQSORT_LT (_run_ptr, _tmp_ptr)) \ _tmp_ptr = _run_ptr; \ \ if (_tmp_ptr != _base) \ _GKQSORT_SWAP (_tmp_ptr, _base, _hold); \ \ /* Insertion sort, running from left-hand-side \ * up to right-hand-side. */ \ \ _run_ptr = _base + 1; \ while (++_run_ptr <= _end_ptr) { \ _tmp_ptr = _run_ptr - 1; \ while (GKQSORT_LT (_run_ptr, _tmp_ptr)) \ --_tmp_ptr; \ \ ++_tmp_ptr; \ if (_tmp_ptr != _run_ptr) { \ GKQSORT_TYPE *_trav = _run_ptr + 1; \ while (--_trav >= _run_ptr) { \ GKQSORT_TYPE *_hi; GKQSORT_TYPE *_lo; \ _hold = *_trav; \ \ for (_hi = _lo = _trav; --_lo >= _tmp_ptr; _hi = _lo) \ *_hi = *_lo; \ *_hi = _hold; \ } \ } \ } \ } \ \ } #endif PyMetis-0.90/src/gklib/gk_struct.h0000640000175000017500000001046010662171744016712 0ustar andreasandreas/*! \file gk_struct.h \brief This file contains various datastructures used/provided by GKlib \date Started 3/27/2007 \author George \version\verbatim $Id: gk_struct.h 1421 2007-04-06 14:37:41Z karypis $ \endverbatim */ #ifndef _GK_STRUCT_H_ #define _GK_STRUCT_H_ /********************************************************************/ /*! Generator for gk_??KeyVal_t data structure */ /********************************************************************/ #define GK_KEYVALUE_T(NAME, KEYTYPE, VALTYPE) \ typedef struct {\ KEYTYPE key;\ VALTYPE val;\ } NAME\ /* The actual KeyVal data structures */ GK_KEYVALUE_T(gk_ckv_t, char, gk_idx_t); GK_KEYVALUE_T(gk_ikv_t, int, gk_idx_t); GK_KEYVALUE_T(gk_fkv_t, float, gk_idx_t); GK_KEYVALUE_T(gk_dkv_t, double, gk_idx_t); GK_KEYVALUE_T(gk_skv_t, char *, gk_idx_t); GK_KEYVALUE_T(gk_idxkv_t, gk_idx_t, gk_idx_t); /*------------------------------------------------------------- * The following data structure stores a sparse CSR format *-------------------------------------------------------------*/ typedef struct { int nrows, ncols; int *rowptr, *colptr; int *rowind, *colind; int *irowval, *icolval; float *frowval, *fcolval; } gk_CSR_t; /*------------------------------------------------------------- * The following data structure implements max-heap priority * queue *-------------------------------------------------------------*/ typedef struct { int nnodes; int maxnodes; /* Heap version of the data structure */ gk_fkv_t *heap; int *locator; } gk_PQueue_t; /*------------------------------------------------------------- * The following data structure implements a string-2-int mapping * table used for parsing command-line options *-------------------------------------------------------------*/ typedef struct { char *name; int id; } gk_StringMap_t; /*------------------------------------------------------------ * This structure implements a simple hash table *------------------------------------------------------------*/ typedef struct { int nelements; /* The overall size of the hash-table */ int htsize; /* The current size of the hash-table */ gk_ikv_t *harray; /* The actual hash-table */ } gk_HTable_t; /*------------------------------------------------------------ * This structure implements a gk_Tokens_t list returned by the * string tokenizer *------------------------------------------------------------*/ typedef struct { int ntoks; /* The number of tokens in the input string */ char *strbuf; /* The memory that stores all the entries */ char **list; /* Pointers to the strbuf for each element */ } gk_Tokens_t; /*------------------------------------------------------------ * This structure implements storage for an atom in a pdb file *------------------------------------------------------------*/ typedef struct { int serial; char *name; char altLoc; char *resname; char chainid; int rserial; char icode; char element; double x; double y; double z; double opcy; double tmpt; } atom; /*------------------------------------------------------------ * This structure implements storage for a pdb protein *------------------------------------------------------------*/ typedef struct { int natoms; /* Number of atoms */ int nresidues; /* Number of residues based on coordinates */ int ncas; int nbbs; int corruption; char *resSeq; /* Residue sequence based on coordinates */ atom *atoms; atom **bbs; atom **cas; } pdbf; /************************************************************* * Localization Structures for converting characters to integers *************************************************************/ typedef struct { int n; char *i2c; int *c2i; } gk_i2cc2i_t; /******************************************************************* *This structure implements storage of a protein sequence * *****************************************************************/ typedef struct { int len; /*Number of Residues */ int *sequence; /* Stores the sequence*/ int **pssm; /* Stores the pssm matrix */ int **psfm; /* Stores the psfm matrix */ char *name; /* Stores the name of the sequence */ int nsymbols; } gk_seq_t; #endif PyMetis-0.90/src/gklib/gk_types.h0000640000175000017500000000255010662171744016533 0ustar andreasandreas/*! \file gk_types.h \brief This file contains basic scalar datatype used in GKlib \date Started 3/27/2007 \author George \version\verbatim $Id: gk_types.h 1413 2007-04-05 02:43:48Z karypis $ \endverbatim */ #ifndef _GK_TYPES_H_ #define _GK_TYPES_H_ /************************************************************************* * Basic data type definitions. These definitions allow GKlib to separate * the following elemental types: * - loop iterator variables, which are set to size_t * - signed and unsigned int variables that can be set to any # of bits * - signed and unsigned long variables that can be set to any # of bits * - real variables, which can be set to single or double precision. **************************************************************************/ typedef ptrdiff_t gk_loop_t; /* loop index variable */ typedef ptrdiff_t gk_idx_t; /* index variable */ typedef int32_t gk_int_t; /* integer values */ typedef uint32_t gk_uint_t; /* unsigned integer values */ typedef int64_t gk_long_t; /* long integer values */ typedef uint64_t gk_ulong_t; /* unsigned long integer values */ typedef float gk_real_t; /* real type */ typedef double gk_dreal_t; /* double precission real type */ typedef time_t gk_wclock_t; /* wall-clock time */ #endif PyMetis-0.90/src/gklib/htable.c0000640000175000017500000001534010662171744016141 0ustar andreasandreas/* * Copyright 2004, Regents of the University of Minnesota * * This file contains routines for manipulating a direct-access hash table * * Started 3/22/04 * George * */ #include /****************************************************************************** * This function creates the hash-table *******************************************************************************/ gk_HTable_t *HTable_Create(int nelements) { gk_HTable_t *htable; htable = gk_malloc(sizeof(gk_HTable_t), "HTable_Create: htable"); htable->harray = gk_ikvmalloc(nelements, "HTable_Create: harray"); htable->nelements = nelements; HTable_Reset(htable); return htable; } /****************************************************************************** * This function resets the data-structures associated with the hash-table *******************************************************************************/ void HTable_Reset(gk_HTable_t *htable) { int i; for (i=0; inelements; i++) htable->harray[i].key = HTABLE_EMPTY; htable->htsize = 0; } /****************************************************************************** * This function resizes the hash-table *******************************************************************************/ void HTable_Resize(gk_HTable_t *htable, int nelements) { int i, old_nelements; gk_ikv_t *old_harray; old_nelements = htable->nelements; old_harray = htable->harray; /* prepare larger hash */ htable->nelements = nelements; htable->htsize = 0; htable->harray = gk_ikvmalloc(nelements, "HTable_Resize: harray"); for (i=0; iharray[i].key = HTABLE_EMPTY; /* reassign the values */ for (i=0; ihtsize > htable->nelements/2) HTable_Resize(htable, 2*htable->nelements); first = HTable_HFunction(htable->nelements, key); for (i=first; inelements; i++) { if (htable->harray[i].key == HTABLE_EMPTY || htable->harray[i].key == HTABLE_DELETED) { htable->harray[i].key = key; htable->harray[i].val = val; htable->htsize++; return; } } for (i=0; iharray[i].key == HTABLE_EMPTY || htable->harray[i].key == HTABLE_DELETED) { htable->harray[i].key = key; htable->harray[i].val = val; htable->htsize++; return; } } } /****************************************************************************** * This function deletes key from the htable *******************************************************************************/ void HTable_Delete(gk_HTable_t *htable, int key) { int i, first; first = HTable_HFunction(htable->nelements, key); for (i=first; inelements; i++) { if (htable->harray[i].key == key) { htable->harray[i].key = HTABLE_DELETED; htable->htsize--; return; } } for (i=0; iharray[i].key == key) { htable->harray[i].key = HTABLE_DELETED; htable->htsize--; return; } } } /****************************************************************************** * This function returns the data associated with the key in the hastable *******************************************************************************/ int HTable_Search(gk_HTable_t *htable, int key) { int i, first; first = HTable_HFunction(htable->nelements, key); for (i=first; inelements; i++) { if (htable->harray[i].key == key) return htable->harray[i].val; else if (htable->harray[i].key == HTABLE_EMPTY) return -1; } for (i=0; iharray[i].key == key) return htable->harray[i].val; else if (htable->harray[i].key == HTABLE_EMPTY) return -1; } return -1; } /****************************************************************************** * This function returns the next key/val *******************************************************************************/ int HTable_GetNext(gk_HTable_t *htable, int key, int *r_val, int type) { int i; static int first, last; if (type == HTABLE_FIRST) first = last = HTable_HFunction(htable->nelements, key); if (first > last) { for (i=first; inelements; i++) { if (htable->harray[i].key == key) { *r_val = htable->harray[i].val; first = i+1; return 1; } else if (htable->harray[i].key == HTABLE_EMPTY) return -1; } first = 0; } for (i=first; iharray[i].key == key) { *r_val = htable->harray[i].val; first = i+1; return 1; } else if (htable->harray[i].key == HTABLE_EMPTY) return -1; } return -1; } /****************************************************************************** * This function returns the data associated with the key in the hastable *******************************************************************************/ int HTable_SearchAndDelete(gk_HTable_t *htable, int key) { int i, first; first = HTable_HFunction(htable->nelements, key); for (i=first; inelements; i++) { if (htable->harray[i].key == key) { htable->harray[i].key = HTABLE_DELETED; htable->htsize--; return htable->harray[i].val; } else if (htable->harray[i].key == HTABLE_EMPTY) gk_errexit(SIGERR, "HTable_SearchAndDelete: Failed to find the key!\n"); } for (i=0; iharray[i].key == key) { htable->harray[i].key = HTABLE_DELETED; htable->htsize--; return htable->harray[i].val; } else if (htable->harray[i].key == HTABLE_EMPTY) gk_errexit(SIGERR, "HTable_SearchAndDelete: Failed to find the key!\n"); } return -1; } /****************************************************************************** * This function destroys the data structures associated with the hash-table *******************************************************************************/ void HTable_Destroy(gk_HTable_t *htable) { gk_free((void *)&htable->harray, &htable, LTERM); } /****************************************************************************** * This is the hash-function. Based on multiplication *******************************************************************************/ int HTable_HFunction(int nelements, int key) { return (int)(key%nelements); } PyMetis-0.90/src/gklib/io.c0000640000175000017500000000354110662171744015311 0ustar andreasandreas/*! \file io.c \brief Various file I/O functions. This file contains various functions that perform I/O. \date Started 4/10/95 \author George \version\verbatim $Id: io.c 1430 2007-04-07 17:53:07Z karypis $ \endverbatim */ #include /************************************************************************* * This function opens a file **************************************************************************/ FILE *gk_fopen(char *fname, char *mode, const char *msg) { FILE *fp; char errmsg[8192]; fp = fopen(fname, mode); if (fp != NULL) return fp; sprintf(errmsg,"file: %s, mode: %s, [%s]", fname, mode, msg); perror(errmsg); errexit("Failed on gk_fopen()\n"); return NULL; } /************************************************************************* * This function closes a file **************************************************************************/ void gk_fclose(FILE *fp) { fclose(fp); } /************************************************************************* * This function is the GKlib implementation of glibc's getline() * function. **************************************************************************/ gk_loop_t gk_getline(char **lineptr, size_t *n, FILE *stream) { size_t i; int ch; if (feof(stream)) return -1; /* Initial memory allocation if *lineptr is NULL */ if (*lineptr == NULL || *n == 0) { *n = 1024; *lineptr = gk_malloc((*n)*sizeof(char), "gk_getline: lineptr"); } /* get into the main loop */ for (i = 0; (ch = getc(stream)) != EOF; i++) { (*lineptr)[i] = (char)ch; /* reallocate memory if reached at the end of the buffer. The +2 is for '\0' */ if (i+2 == *n) { *n = 2* (*n); *lineptr = gk_realloc(*lineptr, (*n)*sizeof(char), "gk_getline: lineptr"); } if (ch == '\n') break; } (*lineptr)[i+1] = '\0'; return i; } PyMetis-0.90/src/gklib/memory.c0000640000175000017500000002242310662171744016212 0ustar andreasandreas/*! \file memory.c \brief This file contains various allocation routines The allocation routines included are for 1D and 2D arrays of the most datatypes that GKlib support. Many of these routines are defined with the help of the macros in gk_memory.h. These macros can be used to define other memory allocation routines. \date Started 4/3/2007 \author George \version\verbatim $Id: memory.c 1432 2007-04-07 20:06:19Z karypis $ \endverbatim */ #include #ifdef GKMSPACE /* This is the mspace for all the gk_malloc() calls. This is a thread local allocation */ static __thread mspace gk_mspace = 0; /* This function is mostly for debugging */ void gk_printmspaceaddr() { printf("mspace: %p\n", (void *)gk_mspace); } #endif /*************************************************************************/ /*! Routines for allocating an array of a particular data type */ /**************************************************************************/ GK_XMALLOC(gk_cmalloc, char) GK_XMALLOC(gk_imalloc, int) GK_XMALLOC(gk_fmalloc, float) GK_XMALLOC(gk_dmalloc, double) GK_XMALLOC(gk_idxmalloc, gk_idx_t) GK_XMALLOC(gk_ckvmalloc, gk_ckv_t) GK_XMALLOC(gk_ikvmalloc, gk_ikv_t) GK_XMALLOC(gk_fkvmalloc, gk_fkv_t) GK_XMALLOC(gk_dkvmalloc, gk_dkv_t) GK_XMALLOC(gk_skvmalloc, gk_skv_t) GK_XMALLOC(gk_idxkvmalloc, gk_idxkv_t) /*************************************************************************/ /*! Routines for reallocating an array of a particular data type */ /**************************************************************************/ GK_XREALLOC(gk_crealloc, char) GK_XREALLOC(gk_irealloc, int) GK_XREALLOC(gk_frealloc, float) GK_XREALLOC(gk_drealloc, double) GK_XREALLOC(gk_idxrealloc, gk_idx_t) GK_XREALLOC(gk_ckvrealloc, gk_ckv_t) GK_XREALLOC(gk_ikvrealloc, gk_ikv_t) GK_XREALLOC(gk_fkvrealloc, gk_fkv_t) GK_XREALLOC(gk_dkvrealloc, gk_dkv_t) GK_XREALLOC(gk_skvrealloc, gk_skv_t) GK_XREALLOC(gk_idxkvrealloc, gk_idxkv_t) /*************************************************************************/ /*! Routines for allocating and setting array of a particular data type */ /**************************************************************************/ GK_XSMALLOC(gk_csmalloc, char, gk_cset) GK_XSMALLOC(gk_ismalloc, int, gk_iset) GK_XSMALLOC(gk_fsmalloc, float, gk_fset) GK_XSMALLOC(gk_dsmalloc, double, gk_dset) GK_XSMALLOC(gk_idxsmalloc, gk_idx_t, gk_idxset) /*************************************************************************/ /*! Routines for allocating/setting 2D arrays of a particular data type */ /**************************************************************************/ GK_ALLOCMATRIX(gk_cAllocMatrix, char, gk_csmalloc) GK_ALLOCMATRIX(gk_iAllocMatrix, int, gk_ismalloc) GK_ALLOCMATRIX(gk_fAllocMatrix, float, gk_fsmalloc) GK_ALLOCMATRIX(gk_dAllocMatrix, double, gk_dsmalloc) GK_ALLOCMATRIX(gk_idxAllocMatrix, gk_idx_t, gk_idxsmalloc) /*************************************************************************/ /*! Routines for freeing 2D arrays of a particular data type */ /**************************************************************************/ GK_FREEMATRIX(gk_cFreeMatrix, char) GK_FREEMATRIX(gk_iFreeMatrix, int) GK_FREEMATRIX(gk_fFreeMatrix, float) GK_FREEMATRIX(gk_dFreeMatrix, double) GK_FREEMATRIX(gk_idxFreeMatrix, gk_idx_t) /*************************************************************************/ /*! Routines for filling a 2D array with a constant value */ /**************************************************************************/ GK_SETMATRIX(gk_cSetMatrix, char) GK_SETMATRIX(gk_iSetMatrix, int) GK_SETMATRIX(gk_fSetMatrix, float) GK_SETMATRIX(gk_dSetMatrix, double) GK_SETMATRIX(gk_idxSetMatrix, gk_idx_t) /************************************************************************* * This function allocates a two-dimensional matrix **************************************************************************/ void gk_AllocMatrix(void ***r_matrix, size_t elmlen, size_t ndim1, size_t ndim2) { gk_idx_t i; void **matrix; matrix = (void **)gk_malloc(ndim1*sizeof(void *), "GKAllocMatrix: matrix"); for (i=0; i #if !defined(__OPENMP__) void omp_set_num_threads(int num_threads) { return; } int omp_get_num_threads(void) { return 1; } int omp_get_max_threads(void) { return 1; } int omp_get_thread_num(void) { return 1; } int omp_get_num_procs(void) { return 1; } int omp_in_parallel(void) { return 0; } void omp_set_dynamic(int num_threads) { return; } int omp_get_dynamic(void) { return 0; } void omp_set_nested(int nested) { return; } int omp_get_nested(void) { return 0; } #endif PyMetis-0.90/src/gklib/pdb.c0000640000175000017500000003226010662171744015447 0ustar andreasandreas/************************************************************************/ /*! \file pdb.c \brief Functions for parsing pdb files. Pdb reader (parser). Loads arrays of pointers for easy backbone access. \date Started 10/20/06 \author Kevin \version $Id: pdb.c 1414 2007-04-05 02:52:46Z karypis $ */ /************************************************************************/ #include #include #include #include /************************************************************************/ /*! \brief Converts three-letter amino acid codes to one-leter codes. This function takes a three letter \c * and converts it to a single \c \param res is the three-letter code to be converted. \returns A \c representing the amino acid. */ /************************************************************************/ char gk_threetoone(char *res) { /* {{{ */ /* make sure the matching works */ res[0] = toupper(res[0]); res[1] = toupper(res[1]); res[2] = toupper(res[2]); if(strcmp(res,"ALA") == 0) { return 'A'; } else if(strcmp(res,"CYS") == 0) { return 'C'; } else if(strcmp(res,"ASP") == 0) { return 'D'; } else if(strcmp(res,"GLU") == 0) { return 'E'; } else if(strcmp(res,"PHE") == 0) { return 'F'; } else if(strcmp(res,"GLY") == 0) { return 'G'; } else if(strcmp(res,"HIS") == 0) { return 'H'; } else if(strcmp(res,"ILE") == 0) { return 'I'; } else if(strcmp(res,"LYS") == 0) { return 'K'; } else if(strcmp(res,"LEU") == 0) { return 'L'; } else if(strcmp(res,"MET") == 0) { return 'M'; } else if(strcmp(res,"ASN") == 0) { return 'N'; } else if(strcmp(res,"PRO") == 0) { return 'P'; } else if(strcmp(res,"GLN") == 0) { return 'Q'; } else if(strcmp(res,"ARG") == 0) { return 'R'; } else if(strcmp(res,"SER") == 0) { return 'S'; } else if(strcmp(res,"THR") == 0) { return 'T'; } else if(strcmp(res,"SCY") == 0) { return 'U'; } else if(strcmp(res,"VAL") == 0) { return 'V'; } else if(strcmp(res,"TRP") == 0) { return 'W'; } else if(strcmp(res,"TYR") == 0) { return 'Y'; } else { return 'X'; } } /* }}} */ /************************************************************************/ /*! \brief Frees the memory of a pdbf structure. This function takes a pdbf pointer and frees all the memory below it. \param p is the pdbf structure to be freed. */ /************************************************************************/ void gk_freepdbf(pdbf *p) { /* {{{ */ int i; if(p != NULL) { gk_free((void *)&p->resSeq, LTERM); for(i=0; inatoms; i++) { gk_free((void *)&p->atoms[i].name, &p->atoms[i].resname, LTERM); } /* this may look like it's wrong, but it's just a 1-d array of pointers, and the pointers themselves are freed above */ gk_free((void *)&p->bbs, &p->cas, &p->atoms, LTERM); } gk_free((void *)&p, LTERM); } /* }}} */ /************************************************************************/ /*! \brief Reads a pdb file into a pdbf structure This function allocates a pdbf structure and reads the file fname into that structure. \param fname is the file name to be read \returns A filled pdbf structure. */ /************************************************************************/ pdbf *gk_readpdbfile(char *fname) { /* {{{ */ int i=0, res=0; char linetype[6]; int aserial; char aname[5] = " \0"; char altLoc = ' '; char rname[4] = " \0"; char chainid = ' '; char oldchainid = ' '; int rserial; int oldRserial = -37; char icode = ' '; char element = ' '; double x; double y; double z; double opcy; double tmpt; char line[MAXLINELEN]; int corruption=0; int atoms=0, residues=0, cas=0, bbs=0, firstres=1; pdbf *toFill = gk_malloc(sizeof(pdbf),"fillme"); FILE *FPIN; FPIN = gk_fopen(fname,"r",fname); while(fgets(line, 256, FPIN)) { sscanf(line,"%s ",linetype); /* It seems the only reliable parts are through temperature, so we only use these parts */ /* if(strstr(linetype, "ATOM") != NULL || strstr(linetype, "HETATM") != NULL) { */ if(strstr(linetype, "ATOM") != NULL) { sscanf(line, "%6s%5d%*1c%4c%1c%3c%*1c%1c%4d%1c%*3c%8lf%8lf%8lf%6lf%6lf %c\n", linetype,&aserial,aname,&altLoc,rname,&chainid,&rserial,&icode,&x,&y,&z,&opcy,&tmpt,&element); sscanf(linetype, " %s ",linetype); sscanf(aname, " %s ",aname); sscanf(rname, " %s ",rname); if(altLoc != ' ') { corruption = corruption|CRP_ALTLOCS; } if(firstres == 1) { oldRserial = rserial; oldchainid = chainid; residues++; firstres = 0; } if(oldRserial != rserial) { residues++; oldRserial = rserial; } if(oldchainid != chainid) { corruption = corruption|CRP_MULTICHAIN; } oldchainid = chainid; atoms++; if(strcmp(aname,"CA") == 0) { cas++; } if(strcmp(aname,"N") == 0 || strcmp(aname,"CA") == 0 || strcmp(aname,"C") == 0 || strcmp(aname,"O") == 0) { bbs++; } } else if(strstr(linetype, "ENDMDL") != NULL || strstr(linetype, "END") != NULL || strstr(linetype, "TER") != NULL) { break; } } fclose(FPIN); /* printf("File has coordinates for %d atoms in %d residues\n",atoms,residues); */ toFill->natoms = atoms; toFill->ncas = cas; toFill->nbbs = bbs; toFill->nresidues = residues; toFill->resSeq = (char *)gk_malloc (residues*sizeof(char),"residue seq"); toFill->atoms = (atom *)gk_malloc(atoms*sizeof(atom), "atoms"); toFill->bbs = (atom **)gk_malloc( bbs*sizeof(atom *),"bbs"); toFill->cas = (atom **)gk_malloc( cas*sizeof(atom *),"cas"); res=0; firstres=1; cas=0; bbs=0; i=0; FPIN = gk_fopen(fname,"r",fname); while(fgets(line, 256, FPIN)) { sscanf(line,"%s ",linetype); /* It seems the only reliable parts are through temperature, so we only use these parts */ /* if(strstr(linetype, "ATOM") != NULL || strstr(linetype, "HETATM") != NULL) { */ if(strstr(linetype, "ATOM") != NULL ) { /* to ensure our memory doesn't get corrupted by the biologists, we only read this far */ sscanf(line, "%6s%5d%*1c%4c%1c%3c%*1c%1c%4d%1c%*3c%8lf%8lf%8lf%6lf%6lf %c\n", linetype,&aserial,aname,&altLoc,rname,&chainid,&rserial,&icode,&x,&y,&z,&opcy,&tmpt,&element); sscanf(aname, "%s",aname); sscanf(rname, "%s",rname); if(firstres == 1) { toFill->resSeq[res] = gk_threetoone(rname); oldRserial = rserial; res++; firstres = 0; } if(oldRserial != rserial) { toFill->resSeq[res] = gk_threetoone(rname); res++; oldRserial = rserial; } toFill->atoms[i].x = x; toFill->atoms[i].y = y; toFill->atoms[i].z = z; toFill->atoms[i].opcy = opcy; toFill->atoms[i].tmpt = tmpt; toFill->atoms[i].element = element; toFill->atoms[i].serial = aserial; toFill->atoms[i].chainid = chainid; toFill->atoms[i].altLoc = altLoc; toFill->atoms[i].rserial = rserial; toFill->atoms[i].icode = icode; toFill->atoms[i].name = gk_strdup(aname); toFill->atoms[i].resname = gk_strdup(rname); /* Set up pointers for the backbone and c-alpha shortcuts */ if(strcmp(aname,"CA") == 0) { toFill->cas[cas] = &(toFill->atoms[i]); cas++; } if(strcmp(aname,"N") == 0 || strcmp(aname,"CA") == 0 || strcmp(aname,"C") == 0 || strcmp(aname,"O") == 0) { toFill->bbs[bbs] = &(toFill->atoms[i]); bbs++; } i++; } else if(strstr(linetype, "ENDMDL") != NULL || strstr(linetype, "END") != NULL || strstr(linetype, "TER") != NULL) { break; } } /* Begin test code */ if(cas != residues) { printf("Number of residues and CA coordinates differs by %d (!)\n",residues-cas); if(cas < residues) { corruption = corruption|CRP_MISSINGCA; } else if(cas > residues) { corruption = corruption|CRP_MULTICA; } } if(bbs < residues*4) { corruption = corruption|CRP_MISSINGBB; } else if(bbs > residues*4) { corruption = corruption|CRP_MULTIBB; } fclose(FPIN); toFill->corruption = corruption; /* if(corruption == 0) printf("File was clean!\n"); */ return(toFill); } /* }}} */ /************************************************************************/ /*! \brief Writes the sequence of residues from a pdb file. This function takes a pdbf structure and a filename, and writes out the amino acid sequence according to the atomic coordinates. The output is in fasta format. \param p is the pdbf structure with the sequence of interest \param fname is the file name to be written */ /************************************************************************/ void gk_writefastafrompdb(pdbf *pb, char *fname) { int i; FILE *OUT = gk_fopen(fname,"w",fname); fprintf(OUT,"> %s\n",fname); for(i=0; inresidues; i++) fprintf(OUT,"%c",pb->resSeq[i]); fprintf(OUT,"\n"); fclose(OUT); } /************************************************************************/ /*! \brief Writes all atoms in p in pdb-format to file fname. This function takes a pdbf structure and writes out all the atom information to file fname. \param p is the pdbf structure to write out \param fname is the file name to be written */ /************************************************************************/ void gk_writefullatom(pdbf *p, char *fname) { int i; FILE *FPIN; FPIN = gk_fopen(fname,"w",fname); for(i=0; inatoms; i++) { fprintf(FPIN,"%-6s%5d %4s%1c%3s %1c%4d%1c %8.3lf%8.3lf%8.3lf%6.2f%6.2f\n", "ATOM ",p->atoms[i].serial,p->atoms[i].name,p->atoms[i].altLoc,p->atoms[i].resname,p->atoms[i].chainid,p->atoms[i].rserial,p->atoms[i].icode,p->atoms[i].x,p->atoms[i].y,p->atoms[i].z,p->atoms[i].opcy,p->atoms[i].tmpt); } fclose(FPIN); } /************************************************************************/ /*! \brief Writes out all the backbone atoms of a structure in pdb format This function takes a pdbf structure p and writes only the backbone atoms to a filename fname. \param p is the pdb structure to write out. \param fname is the file name to be written. */ /************************************************************************/ void gk_writebackbone(pdbf *p, char *fname) { int i; FILE *FPIN; FPIN = gk_fopen(fname,"w",fname); for(i=0; inbbs; i++) { fprintf(FPIN,"%-6s%5d %4s%1c%3s %1c%4d%1c %8.3lf%8.3lf%8.3lf%6.2f%6.2f\n", "ATOM ",p->bbs[i]->serial,p->bbs[i]->name,p->bbs[i]->altLoc,p->bbs[i]->resname,p->bbs[i]->chainid,p->bbs[i]->rserial,p->bbs[i]->icode,p->bbs[i]->x,p->bbs[i]->y,p->bbs[i]->z,p->bbs[i]->opcy,p->bbs[i]->tmpt); } fclose(FPIN); } /************************************************************************/ /*! \brief Writes out all the alpha carbon atoms of a structure This function takes a pdbf structure p and writes only the alpha carbon atoms to a filename fname. \param p is the pdb structure to write out. \param fname is the file name to be written. */ /************************************************************************/ void gk_writealphacarbons(pdbf *p, char *fname) { int i; FILE *FPIN; FPIN = gk_fopen(fname,"w",fname); for(i=0; incas; i++) { fprintf(FPIN,"%-6s%5d %4s%1c%3s %1c%4d%1c %8.3lf%8.3lf%8.3lf%6.2f%6.2f\n", "ATOM ",p->cas[i]->serial,p->cas[i]->name,p->cas[i]->altLoc,p->cas[i]->resname,p->cas[i]->chainid,p->cas[i]->rserial,p->cas[i]->icode,p->cas[i]->x,p->cas[i]->y,p->cas[i]->z,p->cas[i]->opcy,p->cas[i]->tmpt); } fclose(FPIN); } /************************************************************************/ /*! \brief Decodes the corruption bitswitch and prints any problems Due to the totally unreliable nature of the pdb format, reading a pdb file stores a corruption bitswitch, and this function decodes that switch and prints the result on stdout. \param p is the pdb structure to write out. \param fname is the file name to be written. */ /************************************************************************/ void gk_showcorruption(pdbf *p) { int corruption = p->corruption; if(corruption&CRP_ALTLOCS) printf("Multiple coordinate sets for at least one atom\n"); if(corruption&CRP_MISSINGCA) printf("Missing coordiantes for at least one CA atom\n"); if(corruption&CRP_MISSINGBB) printf("Missing coordiantes for at least one backbone atom (N,CA,C,O)\n"); if(corruption&CRP_MULTICHAIN) printf("File contains coordinates for multiple chains\n"); if(corruption&CRP_MULTICA) printf("Multiple CA atoms found for the same residue (could be alternate locators)\n"); if(corruption&CRP_MULTICA) printf("Multiple copies of backbone atoms found for the same residue (could be alternate locators)\n"); } /* sscanf(line, "%6s%5d%*1c%4s%1c%3s%*1c%1c%4d%1c%*3c%8lf%8lf%8lf%6lf%6lf%*6c%4s%2s%2s\n", linetype,&aserial,aname,&altLoc,rname,&chainid,&rserial,&icode,&x,&y,&z,&opcy,&tmpt,segId,element,charge); printf(".%s.%s.%s.\n",segId,element,charge); printf("%-6s%5d%-1s%-4s%1c%3s%1s%1c%4d%1c%3s%8.3lf%8.3lf%8.3lf%6.2f%6.2f%6s%4s%2s%2s\n", linetype,aserial," ",aname,altLoc,rname," ",chainid,rserial,icode," ",x,y,z,opcy,tmpt," ",segId,element,charge); */ /* and we could probably get away with this using astral files, */ /* sscanf(line, "%6s%5d%*1c%4s%1c%3s%*1c%1c%4d%1c%*3c%8lf%8lf%8lf%6lf%6lf%*6c%6s\n", linetype,&aserial,aname,&altLoc,rname,&chainid,&rserial,&icode,&x,&y,&z,&opcy,&tmpt,element); printf("%-6s%5d%-1s%-4s%1c%3s%1s%1c%4d%1c%3s%8.3lf%8.3lf%8.3lf%6.2f%6.2f%6s%6s\n", linetype,aserial," ",aname,altLoc,rname," ",chainid,rserial,icode," ",x,y,z,opcy,tmpt," ",element); */ PyMetis-0.90/src/gklib/pqueue.c0000640000175000017500000002257610662171744016217 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * pqueue.c * * This file contains functions for manipulating the bucket list * representation of the gains associated with each vertex in a graph. * These functions are used by the refinement algorithms * * Started 9/2/94 * George * * $Id: pqueue.c 1414 2007-04-05 02:52:46Z karypis $ * */ #include /************************************************************************* * This function initializes the data structures of the priority queue **************************************************************************/ void gk_PQueueInit(gk_PQueue_t *queue, int maxnodes) { queue->nnodes = 0; queue->maxnodes = maxnodes; queue->heap = gk_fkvmalloc(maxnodes, "gk_PQueueInit: heap"); queue->locator = gk_ismalloc(maxnodes, -1, "gk_PQueueInit: locator"); } /************************************************************************* * This function resets the buckets **************************************************************************/ void gk_PQueueReset(gk_PQueue_t *queue) { queue->nnodes = 0; gk_iset(queue->maxnodes, -1, queue->locator); } /************************************************************************* * This function frees the buckets **************************************************************************/ void gk_PQueueFree(gk_PQueue_t *queue) { gk_free((void *)&queue->heap, &queue->locator, LTERM); queue->maxnodes = 0; } /************************************************************************* * This function returns the number of nodes in the queue **************************************************************************/ int gk_PQueueGetSize(gk_PQueue_t *queue) { return queue->nnodes; } /************************************************************************* * This function adds an item in the priority queue **************************************************************************/ int gk_PQueueInsert(gk_PQueue_t *queue, int node, float key) { int i, j; int *locator; gk_fkv_t *heap; ASSERT(gk_CheckHeap(queue)); heap = queue->heap; locator = queue->locator; ASSERT(locator[node] == -1); i = queue->nnodes++; while (i > 0) { j = (i-1)/2; if (heap[j].key < key) { heap[i] = heap[j]; locator[heap[i].val] = i; i = j; } else break; } ASSERT(i >= 0); heap[i].key = key; heap[i].val = node; locator[node] = i; ASSERT(gk_CheckHeap(queue)); return 0; } /************************************************************************* * This function deletes an item from the priority queue **************************************************************************/ int gk_PQueueDelete(gk_PQueue_t *queue, int node) { int i, j; float newkey, oldkey; int *locator; gk_fkv_t *heap; heap = queue->heap; locator = queue->locator; ASSERT(locator[node] != -1); ASSERT(heap[locator[node]].val == node); ASSERT(gk_CheckHeap(queue)); i = locator[node]; locator[node] = -1; if (--queue->nnodes > 0 && heap[queue->nnodes].val != node) { node = heap[queue->nnodes].val; newkey = heap[queue->nnodes].key; oldkey = heap[i].key; if (oldkey < newkey) { /* Filter-up */ while (i > 0) { j = (i-1)>>1; if (heap[j].key < newkey) { heap[i] = heap[j]; locator[heap[i].val] = i; i = j; } else break; } } else { /* Filter down */ while ((j=2*i+1) < queue->nnodes) { if (heap[j].key > newkey) { if (j+1 < queue->nnodes && heap[j+1].key > heap[j].key) j = j+1; heap[i] = heap[j]; locator[heap[i].val] = i; i = j; } else if (j+1 < queue->nnodes && heap[j+1].key > newkey) { j = j+1; heap[i] = heap[j]; locator[heap[i].val] = i; i = j; } else break; } } heap[i].key = newkey; heap[i].val = node; locator[node] = i; } ASSERT(gk_CheckHeap(queue)); return 0; } /************************************************************************* * This function deletes a node from a partition and reinserts it with * an updated key value **************************************************************************/ int gk_PQueueUpdate(gk_PQueue_t *queue, int node, float newkey) { int i, j; int *locator; gk_fkv_t *heap; float oldkey; heap = queue->heap; locator = queue->locator; oldkey = heap[locator[node]].key; ASSERT(locator[node] != -1); ASSERT(heap[locator[node]].val == node); ASSERT(gk_CheckHeap(queue)); i = locator[node]; if (oldkey < newkey) { /* Filter-up */ while (i > 0) { j = (i-1)>>1; if (heap[j].key < newkey) { heap[i] = heap[j]; locator[heap[i].val] = i; i = j; } else break; } } else { /* Filter down */ while ((j=2*i+1) < queue->nnodes) { if (heap[j].key > newkey) { if (j+1 < queue->nnodes && heap[j+1].key > heap[j].key) j = j+1; heap[i] = heap[j]; locator[heap[i].val] = i; i = j; } else if (j+1 < queue->nnodes && heap[j+1].key > newkey) { j = j+1; heap[i] = heap[j]; locator[heap[i].val] = i; i = j; } else break; } } heap[i].key = newkey; heap[i].val = node; locator[node] = i; ASSERT(gk_CheckHeap(queue)); return 0; } /************************************************************************* * This function returns the item with the largest key-value and removes * it from the priority queue **************************************************************************/ int gk_PQueueGetMax(gk_PQueue_t *queue) { int vtx, i, j, node; int *locator; gk_fkv_t *heap; float key; if (queue->nnodes == 0) return -1; queue->nnodes--; heap = queue->heap; locator = queue->locator; vtx = heap[0].val; locator[vtx] = -1; if ((i = queue->nnodes) > 0) { key = heap[i].key; node = heap[i].val; i = 0; while ((j=2*i+1) < queue->nnodes) { if (heap[j].key > key) { if (j+1 < queue->nnodes && heap[j+1].key > heap[j].key) j = j+1; heap[i] = heap[j]; locator[heap[i].val] = i; i = j; } else if (j+1 < queue->nnodes && heap[j+1].key > key) { j = j+1; heap[i] = heap[j]; locator[heap[i].val] = i; i = j; } else break; } heap[i].key = key; heap[i].val = node; locator[node] = i; } ASSERT(gk_CheckHeap(queue)); return vtx; } /************************************************************************* * This function returns the vertex with the largest gain from a partition **************************************************************************/ int gk_PQueueSeeMaxVal(gk_PQueue_t *queue) { return (queue->nnodes == 0 ? -1 : queue->heap[0].val); } /************************************************************************* * This function returns the vertex with the largest gain from a partition **************************************************************************/ float gk_PQueueSeeMaxKey(gk_PQueue_t *queue) { return (queue->nnodes == 0 ? FLT_MAX : queue->heap[0].key); } /************************************************************************* * This function returns the length of the queue **************************************************************************/ int gk_PQueueLength(gk_PQueue_t *queue) { return queue->nnodes; } /************************************************************************* * This function returns the vertex with the largest gain from a partition **************************************************************************/ int gk_PQueueSeeConstraintMax(gk_PQueue_t *queue, float maxwgt, double *wgts) { int i; if (queue->nnodes == 0) return -1; if (maxwgt <= 1000) return gk_PQueueSeeMaxVal(queue); for (i=0; innodes; i++) { if (queue->heap[i].key > 0) { if (wgts[queue->heap[i].val] <= maxwgt) return queue->heap[i].val; } else { if (queue->heap[i/2].key <= 0) break; } } return queue->heap[0].val; } /************************************************************************* * This function returns the key of a specific node **************************************************************************/ float gk_PQueueSeeKey(gk_PQueue_t *queue, int node) { int *locator; gk_fkv_t *heap; heap = queue->heap; locator = queue->locator; return heap[locator[node]].key; } /************************************************************************* * This functions checks the consistency of the heap **************************************************************************/ int gk_CheckHeap(gk_PQueue_t *queue) { int i, j, nnodes; int *locator; gk_fkv_t *heap; heap = queue->heap; locator = queue->locator; nnodes = queue->nnodes; if (nnodes == 0) return 1; ASSERT(locator[heap[0].val] == 0); for (i=1; imaxnodes; i++) { if (locator[i] != -1) j++; } ASSERTP(j == nnodes, ("%d %d\n", j, nnodes)); return 1; } PyMetis-0.90/src/gklib/seq.c0000640000175000017500000000765410662171744015503 0ustar andreasandreas/* * * Sequence handler library by Huzefa Rangwala * Date : 03.01.2007 * * * */ #include /*********************************************************/ /* ! \brief Initializes the gk_seq_t variable \param A pointer to gk_seq_t itself \returns null */ /***********************************************************************/ void gk_seq_init(gk_seq_t *seq) { seq->len = 0; seq->sequence = NULL; seq->pssm = NULL; seq->psfm = NULL; seq->name = NULL; } /***********************************************************************/ /*! \brief This function creates the localizations for the various sequences \param string i.e amino acids, nucleotides, sequences \returns gk_i2cc2i_t variable */ /*********************************************************************/ gk_i2cc2i_t *gk_i2cc2i_create_common(char *alphabet) { int nsymbols; gk_loop_t i; gk_i2cc2i_t *t; nsymbols = strlen(alphabet); t = gk_malloc(sizeof(gk_i2cc2i_t),"gk_i2c_create_common"); t->n = nsymbols; t->i2c = gk_cmalloc(256, "gk_i2c_create_common"); t->c2i = gk_imalloc(256, "gk_i2c_create_common"); gk_cset(256, -1, t->i2c); gk_iset(256, -1, t->c2i); for(i=0;ii2c[i] = alphabet[i]; t->c2i[(int)alphabet[i]] = i; } return t; } /*********************************************************************/ /*! \brief This function reads a pssm in the format of gkmod pssm \param file_name is the name of the pssm file \returns gk_seq_t */ /********************************************************************/ gk_seq_t *gk_seq_ReadGKMODPSSM(char *filename) { gk_seq_t *seq; gk_loop_t i, j, ii; int ntokens,nbytes,len; FILE *fpin; gk_Tokens_t tokens; static char *AAORDER = "ARNDCQEGHILKMFPSTWYVBZX*"; static int PSSMWIDTH = 20; char header[PSSMWIDTH], line[MAXLINELEN]; gk_i2cc2i_t *converter; converter = gk_i2cc2i_create_common(AAORDER); gk_getfilestats(filename, &len, &ntokens, &nbytes); len --; seq = gk_malloc(sizeof(gk_seq_t),"gk_seq_ReadGKMODPSSM"); gk_seq_init(seq); seq->len = len; seq->sequence = gk_imalloc(len, "gk_seq_ReadGKMODPSSM"); seq->pssm = gk_iAllocMatrix(len, PSSMWIDTH, 0, "gk_seq_ReadGKMODPSSM"); seq->psfm = gk_iAllocMatrix(len, PSSMWIDTH, 0, "gk_seq_ReadGKMODPSSM"); seq->nsymbols = PSSMWIDTH; seq->name = gk_getbasename(filename); fpin = gk_fopen(filename,"r","gk_seq_ReadGKMODPSSM"); /* Read the header line */ fgets(line, MAXLINELEN-1, fpin); gk_strtoupper(line); gk_strtokenize(line, " \t\n", &tokens); for (i=0; isequence[i] = converter->c2i[(int)tokens.list[1][0]]; for (j=0; jpssm[i][converter->c2i[(int)header[j]]] = atoi(tokens.list[2+j]); seq->psfm[i][converter->c2i[(int)header[j]]] = atoi(tokens.list[2+PSSMWIDTH+j]); } gk_freetokenslist(&tokens); i++; } seq->len = i; /* Reset the length if certain characters were skipped */ gk_fclose(fpin); return seq; } /**************************************************************************/ /*! \brief This function frees the memory allocated to the seq structure. \param gk_seq_t \returns nothing */ /**************************************************************************/ void gk_seq_free(gk_seq_t *seq) { gk_iFreeMatrix(&seq->pssm, seq->len, seq->nsymbols); gk_iFreeMatrix(&seq->psfm, seq->len, seq->nsymbols); gk_free((void **)&seq->name, &seq->sequence, LTERM); //gk_free((void **)&seq, LTERM); gk_free((void **) &seq, LTERM); } PyMetis-0.90/src/gklib/sort.c0000640000175000017500000001704010662171744015670 0ustar andreasandreas/*! \file sort.c \brief This file contains GKlib's various sorting routines These routines are implemented using the GKSORT macro that is defined in gk_qsort.h and is based on GNU's GLIBC qsort() implementation. Additional sorting routines can be created using the same way that these routines where defined. \date Started 4/4/07 \author George \version\verbatim $Id: sort.c 1421 2007-04-06 14:37:41Z karypis $ \endverbatim */ #include /*************************************************************************/ /*! Sorts an array of chars in increasing order */ /*************************************************************************/ void gk_icsort(int n, char *base) { #define char_lt(a, b) ((*a) < (*b)) GKQSORT(char, base, n, char_lt); } /*************************************************************************/ /*! Sorts an array of chars in decreasing order */ /*************************************************************************/ void gk_dcsort(int n, char *base) { #define char_gt(a, b) ((*a) > (*b)) GKQSORT(char, base, n, char_gt); } /*************************************************************************/ /*! Sorts an array of integers in increasing order */ /*************************************************************************/ void gk_iisort(int n, int *base) { #define int_lt(a, b) ((*a) < (*b)) GKQSORT(int, base, n, int_lt); } /*************************************************************************/ /*! Sorts an array of integers in decreasing order */ /*************************************************************************/ void gk_disort(int n, int *base) { #define int_gt(a, b) ((*a) > (*b)) GKQSORT(int, base, n, int_gt); } /*************************************************************************/ /*! Sorts an array of floats in increasing order */ /*************************************************************************/ void gk_ifsort(int n, float *base) { #define float_lt(a, b) ((*a) < (*b)) GKQSORT(float, base, n, float_lt); } /*************************************************************************/ /*! Sorts an array of floats in decreasing order */ /*************************************************************************/ void gk_dfsort(int n, float *base) { #define float_gt(a, b) ((*a) > (*b)) GKQSORT(float, base, n, float_gt); } /*************************************************************************/ /*! Sorts an array of doubles in increasing order */ /*************************************************************************/ void gk_idsort(int n, double *base) { #define double_lt(a, b) ((*a) < (*b)) GKQSORT(double, base, n, double_lt); } /*************************************************************************/ /*! Sorts an array of doubles in decreasing order */ /*************************************************************************/ void gk_ddsort(int n, double *base) { #define double_gt(a, b) ((*a) > (*b)) GKQSORT(double, base, n, double_gt); } /*************************************************************************/ /*! Sorts an array of gk_idx_t in increasing order */ /*************************************************************************/ void gk_iidxsort(int n, gk_idx_t *base) { #define idx_lt(a, b) ((*a) < (*b)) GKQSORT(gk_idx_t, base, n, idx_lt); } /*************************************************************************/ /*! Sorts an array of gk_idx_t in decreasing order */ /*************************************************************************/ void gk_didxsort(int n, gk_idx_t *base) { #define idx_gt(a, b) ((*a) > (*b)) GKQSORT(gk_idx_t, base, n, idx_gt); } /*************************************************************************/ /*! Sorts an array of gk_ckv_t in increasing order */ /*************************************************************************/ void gk_ickvsort(int n, gk_ckv_t *base) { #define ckey_lt(a, b) ((a)->key < (b)->key) GKQSORT(gk_ckv_t, base, n, ckey_lt); } /*************************************************************************/ /*! Sorts an array of gk_ckv_t in decreasing order */ /*************************************************************************/ void gk_dckvsort(int n, gk_ckv_t *base) { #define ckey_gt(a, b) ((a)->key > (b)->key) GKQSORT(gk_ckv_t, base, n, ckey_gt); } /*************************************************************************/ /*! Sorts an array of gk_ikv_t in increasing order */ /*************************************************************************/ void gk_iikvsort(int n, gk_ikv_t *base) { #define ikey_lt(a, b) ((a)->key < (b)->key) GKQSORT(gk_ikv_t, base, n, ikey_lt); } /*************************************************************************/ /*! Sorts an array of gk_ikv_t in decreasing order */ /*************************************************************************/ void gk_dikvsort(int n, gk_ikv_t *base) { #define ikey_gt(a, b) ((a)->key > (b)->key) GKQSORT(gk_ikv_t, base, n, ikey_gt); } /*************************************************************************/ /*! Sorts an array of gk_fkv_t in increasing order */ /*************************************************************************/ void gk_ifkvsort(int n, gk_fkv_t *base) { #define fkey_lt(a, b) ((a)->key < (b)->key) GKQSORT(gk_fkv_t, base, n, fkey_lt); } /*************************************************************************/ /*! Sorts an array of gk_fkv_t in decreasing order */ /*************************************************************************/ void gk_dfkvsort(int n, gk_fkv_t *base) { #define fkey_gt(a, b) ((a)->key > (b)->key) GKQSORT(gk_fkv_t, base, n, fkey_gt); } /*************************************************************************/ /*! Sorts an array of gk_dkv_t in increasing order */ /*************************************************************************/ void gk_idkvsort(int n, gk_dkv_t *base) { #define dkey_lt(a, b) ((a)->key < (b)->key) GKQSORT(gk_dkv_t, base, n, dkey_lt); } /*************************************************************************/ /*! Sorts an array of gk_fkv_t in decreasing order */ /*************************************************************************/ void gk_ddkvsort(int n, gk_dkv_t *base) { #define dkey_gt(a, b) ((a)->key > (b)->key) GKQSORT(gk_dkv_t, base, n, dkey_gt); } /*************************************************************************/ /*! Sorts an array of gk_skv_t in increasing order */ /*************************************************************************/ void gk_iskvsort(int n, gk_skv_t *base) { #define skey_lt(a, b) (strcmp((a)->key, (b)->key) < 0) GKQSORT(gk_skv_t, base, n, skey_lt); } /*************************************************************************/ /*! Sorts an array of gk_skv_t in decreasing order */ /*************************************************************************/ void gk_dskvsort(int n, gk_skv_t *base) { #define skey_gt(a, b) (strcmp((a)->key, (b)->key) > 0) GKQSORT(gk_skv_t, base, n, skey_gt); } /*************************************************************************/ /*! Sorts an array of gk_idxkv_t in increasing order */ /*************************************************************************/ void gk_iidxkvsort(int n, gk_idxkv_t *base) { #define idxkey_lt(a, b) ((a)->key < (b)->key) GKQSORT(gk_idxkv_t, base, n, idxkey_lt); } /*************************************************************************/ /*! Sorts an array of gk_idxkv_t in decreasing order */ /*************************************************************************/ void gk_didxkvsort(int n, gk_idxkv_t *base) { #define idxkey_gt(a, b) ((a)->key > (b)->key) GKQSORT(gk_idxkv_t, base, n, idxkey_gt); } PyMetis-0.90/src/gklib/string.c0000640000175000017500000003465010662171744016215 0ustar andreasandreas/************************************************************************/ /*! \file string.c \brief Functions for manipulating strings. Various functions for manipulating strings. Some of these functions provide new functionality, whereas others are drop-in replacements of standard functions (but with enhanced functionality). \date Started 11/1/99 \author George \version $Id: string.c 1421 2007-04-06 14:37:41Z karypis $ */ /************************************************************************/ #include /************************************************************************/ /*! \brief Replaces certain characters in a string. This function takes a string and replaces all the characters in the \c fromlist with the corresponding characters from the \c tolist. That is, each occurence of fromlist[i] is replaced by tolist[i]. If the \c tolist is shorter than \c fromlist, then the corresponding characters are deleted. The modifications on \c str are done in place. It tries to provide a functionality similar to Perl's \b tr// function. \param str is the string whose characters will be replaced. \param fromlist is the set of characters to be replaced. \param tolist is the set of replacement characters . \returns A pointer to \c str itself. */ /************************************************************************/ char *gk_strchr_replace(char *str, char *fromlist, char *tolist) { gk_idx_t i, j, k; size_t len, fromlen, tolen; len = strlen(str); fromlen = strlen(fromlist); tolen = strlen(tolist); for (i=j=0; i s// regular-expression based substitution function. \param str is the input string on which the operation will be performed. \param pattern is the regular expression for the pattern to be matched for substitution. \param replacement is the replacement string, in which the possible captured pattern substrings are referred to as $1, $2, ..., $9. The entire matched pattern is refered to as $0. \param options is a string specified options for the substitution operation. Currently the "i" (case insensitive) and "g" (global substitution) are supported. \param new_str is a reference to a pointer that will store a pointer to the newly created string that results from the substitutions. This string is allocated via gk_malloc() and needs to be freed using gk_free(). The string is returned even if no substitutions were performed. \returns If successful, it returns 1 + the number of substitutions that were performed. Thus, if no substitutions were performed, the returned value will be 1. Otherwise it returns 0. In case of error, a meaningful error message is returned in newstr, which also needs to be freed afterwards. */ /************************************************************************/ int gk_strstr_replace(char *str, char *pattern, char *replacement, char *options, char **new_str) { gk_idx_t i; int j, rc, flags, global, nmatches; size_t len, rlen, nlen, offset, noffset; regex_t re; regmatch_t matches[10]; /* Parse the options */ flags = REG_EXTENDED; if (strchr(options, 'i') != NULL) flags = flags | REG_ICASE; global = (strchr(options, 'g') != NULL ? 1 : 0); /* Compile the regex */ if ((rc = regcomp(&re, pattern, flags)) != 0) { len = regerror(rc, &re, NULL, 0); *new_str = gk_cmalloc(len, "gk_strstr_replace: new_str"); regerror(rc, &re, *new_str, len); return 0; } /* Prepare the output string */ len = strlen(str); nlen = 2*len; noffset = 0; *new_str = gk_cmalloc(nlen+1, "gk_strstr_replace: new_str"); /* Get into the matching-replacing loop */ rlen = strlen(replacement); offset = 0; nmatches = 0; do { rc = regexec(&re, str+offset, 10, matches, 0); if (rc == REG_ESPACE) { gk_free((void **)new_str, LTERM); *new_str = gk_strdup("regexec ran out of memory."); regfree(&re); return 0; } else if (rc == REG_NOMATCH) { if (nlen-noffset < len-offset) { nlen += (len-offset) - (nlen-noffset); *new_str = (char *)gk_realloc(*new_str, (nlen+1)*sizeof(char), "gk_strstr_replace: new_str"); } strcpy(*new_str+noffset, str+offset); noffset += (len-offset); break; } else { /* A match was found! */ nmatches++; /* Copy the left unmatched portion of the string */ if (matches[0].rm_so > 0) { if (nlen-noffset < matches[0].rm_so) { nlen += matches[0].rm_so - (nlen-noffset); *new_str = (char *)gk_realloc(*new_str, (nlen+1)*sizeof(char), "gk_strstr_replace: new_str"); } strncpy(*new_str+noffset, str+offset, matches[0].rm_so); noffset += matches[0].rm_so; } /* Go and append the replacement string */ for (i=0; i 9) { gk_free((void **)new_str, LTERM); *new_str = gk_strdup("Error in captured subexpression specification."); regfree(&re); return 0; } if (nlen-noffset < matches[j].rm_eo-matches[j].rm_so) { nlen += nlen + (matches[j].rm_eo-matches[j].rm_so); *new_str = (char *)gk_realloc(*new_str, (nlen+1)*sizeof(char), "gk_strstr_replace: new_str"); } strncpy(*new_str+noffset, str+offset+matches[j].rm_so, matches[j].rm_eo); noffset += matches[j].rm_eo-matches[j].rm_so; } else { gk_free((void **)new_str, LTERM); *new_str = gk_strdup("Error in replacement string. Missing subexpression number folloing '$'."); regfree(&re); return 0; } break; default: if (nlen-noffset < 1) { nlen += nlen + 1; *new_str = (char *)gk_realloc(*new_str, (nlen+1)*sizeof(char), "gk_strstr_replace: new_str"); } (*new_str)[noffset++] = replacement[i]; } } /* Update the offset of str for the next match */ offset += matches[0].rm_eo; if (!global) { /* Copy the right portion of the string if no 'g' option */ if (nlen-noffset < len-offset) { nlen += (len-offset) - (nlen-noffset); *new_str = (char *)gk_realloc(*new_str, (nlen+1)*sizeof(char), "gk_strstr_replace: new_str"); } strcpy(*new_str+noffset, str+offset); noffset += (len-offset); } } } while (global); (*new_str)[noffset] = '\0'; regfree(&re); return nmatches + 1; } /************************************************************************/ /*! \brief Prunes characters from the end of the string. This function removes any trailing characters that are included in the \c rmlist. The trimming stops at the last character (i.e., first character from the end) that is not in \c rmlist. This function can be used to removed trailing spaces, newlines, etc. This is a distructive operation as it modifies the string. \param str is the string that will be trimmed. \param rmlist contains the set of characters that will be removed. \returns A pointer to \c str itself. \sa gk_strhprune() */ /*************************************************************************/ char *gk_strtprune(char *str, char *rmlist) { gk_idx_t i, j; size_t len; len = strlen(rmlist); for (i=strlen(str)-1; i>=0; i--) { for (j=0; j0) { /* If something needs to be removed */ for (j=0; str[i]; i++, j++) str[j] = str[i]; str[j] = '\0'; } return str; } /************************************************************************/ /*! \brief Converts a string to upper case. This function converts a string to upper case. This operation modifies the string itself. \param str is the string whose case will be changed. \returns A pointer to \c str itself. \sa gk_strtolower() */ /*************************************************************************/ char *gk_strtoupper(char *str) { int i; for (i=0; str[i]!='\0'; str[i]=toupper(str[i]), i++); return str; } /************************************************************************/ /*! \brief Converts a string to lower case. This function converts a string to lower case. This operation modifies the string itself. \param str is the string whose case will be changed. \returns A pointer to \c str itself. \sa gk_strtoupper() */ /*************************************************************************/ char *gk_strtolower(char *str) { int i; for (i=0; str[i]!='\0'; str[i]=tolower(str[i]), i++); return str; } /************************************************************************/ /*! \brief Duplicates a string This function is a replacement for C's standard strdup() function. The key differences between the two are that gk_strdup(): - uses the dynamic memory allocation routines of \e GKlib. - it correctly handles NULL input strings. The string that is returned must be freed by gk_free(). \param orgstr is the string that will be duplicated. \returns A pointer to the newly created string. \sa gk_free() */ /*************************************************************************/ char *gk_strdup(char *orgstr) { int len; char *str=NULL; if (orgstr != NULL) { len = strlen(orgstr)+1; str = gk_malloc(len*sizeof(char), "gk_strdup: str"); strcpy(str, orgstr); } return str; } /************************************************************************/ /*! \brief Case insensitive string comparison. This function compares two strings for equality by ignoring the case of the strings. \warning This function is \b not equivalent to a case-insensitive strcmp() function, as it does not return ordering information. \todo Remove the above warning. \param s1 is the first string to be compared. \param s2 is the second string to be compared. \retval 1 if the strings are identical, \retval 0 otherwise. */ /*************************************************************************/ int gk_strcasecmp(char *s1, char *s2) { int i=0; if (strlen(s1) != strlen(s2)) return 0; while (s1[i] != '\0') { if (tolower(s1[i]) != tolower(s2[i])) return 0; i++; } return 1; } /************************************************************************/ /*! \brief Converts a time_t time into a string This function takes a time_t-specified time and returns a string-formated representation of the corresponding time. The format of the string is mm/dd/yyyy hh:mm:ss, in which the hours are in military time. \param time is the time to be converted. \return It returns a pointer to a statically allocated string that is over-written in successive calls of this function. If the conversion failed, it returns NULL. */ /*************************************************************************/ char *gk_time2str(time_t time) { static char datestr[128]; struct tm *tm; tm = localtime(&time); if (strftime(datestr, 128, "%m/%d/%Y %H:%M:%S", tm) == 0) return NULL; else return datestr; } /************************************************************************/ /*! \brief Converts a date/time string into its equivalent time_t value This function takes date and/or time specification and converts it in the equivalent time_t representation. The conversion is done using the strptime() function. The format that gk_str2time() understands is mm/dd/yyyy hh:mm:ss, in which the hours are in military time. \param str is the date/time string to be converted. \return If the conversion was successful it returns the time, otherwise it returns -1. */ /*************************************************************************/ time_t gk_str2time(char *str) { struct tm time; time_t rtime; memset(&time, '\0', sizeof(time)); if (strptime(str, "%m/%d/%Y %H:%M:%S", &time) == NULL) return -1; rtime = mktime(&time); return (rtime < 0 ? 0 : rtime); } /************************************************************************* * This function returns the ID of a particular string based on the * supplied StringMap array **************************************************************************/ int gk_GetStringID(gk_StringMap_t *strmap, char *key) { int i; for (i=0; strmap[i].name; i++) { if (gk_strcasecmp(key, strmap[i].name)) return strmap[i].id; } return -1; } PyMetis-0.90/src/gklib/timers.c0000640000175000017500000000173610662171744016211 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * time.c * * This file contains various functions that do with time * * $Id: timers.c 934 2007-02-21 18:31:42Z karypis $ * */ #include /************************************************************************* * This function returns the CPU seconds **************************************************************************/ gk_wclock_t gk_WClockSeconds(void) { return time(NULL); } /************************************************************************* * This function returns the CPU seconds **************************************************************************/ double gk_CPUSeconds(void) { #ifdef __OPENMP__ return omp_get_wtime(); #else #ifdef WIN32 return((double) clock()/CLOCKS_PER_SEC); #else struct rusage r; getrusage(RUSAGE_SELF, &r); return ((r.ru_utime.tv_sec + r.ru_stime.tv_sec) + 1.0e-6*(r.ru_utime.tv_usec + r.ru_stime.tv_usec)); #endif #endif } PyMetis-0.90/src/gklib/tokenizer.c0000640000175000017500000000375410662171744016722 0ustar andreasandreas/* * tokenizer.c * * This file contains various routines for splitting an input string into * tokens and returning them in form of a list. The goal is to mimic * perl's split function * * Started 11/23/04 * George * * $Id: tokenizer.c 1414 2007-04-05 02:52:46Z karypis $ * */ #include /************************************************************************ * This function tokenizes a string based on the user-supplied delimiters * list. The resulting tokens are returned into an array of strings. *************************************************************************/ void gk_strtokenize(char *str, char *delim, gk_Tokens_t *tokens) { int i, ntoks, slen; tokens->strbuf = gk_strdup(str); slen = strlen(str); str = tokens->strbuf; /* Scan once to determine the number of tokens */ for (ntoks=0, i=0; intoks = ntoks; tokens->list = (char **)gk_malloc(ntoks*sizeof(char *), "strtokenize: tokens->list"); /* Scan a second time to mark and link the tokens */ for (ntoks=0, i=0; ilist[ntoks++] = str+i; /* Consume all the consecutive characters from the token */ while (ilist, &tokens->strbuf, LTERM); } PyMetis-0.90/src/gklib/util.c0000640000175000017500000000460510662171744015661 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * util.c * * This file contains utility functions * * $Id: util.c 1421 2007-04-06 14:37:41Z karypis $ * */ #include /************************************************************************* * This file randomly permutes the contents of an array. * flag == 0, don't initialize perm * flag == 1, set p[i] = i **************************************************************************/ void gk_RandomPermute(size_t n, int *p, int flag) { gk_idx_t i, u, v; int tmp; if (flag == 1) { for (i=0; i 1; i++, a = a>>1); return i-1; } /************************************************************************* * This function checks if the argument is a power of 2 **************************************************************************/ int gk_ispow2(int a) { return (a == (1< /************************************************************************* * This function is the entry poidxtype of the bisection balancing algorithms. **************************************************************************/ void Balance2Way(CtrlType *ctrl, GraphType *graph, idxtype *tpwgts, float ubfactor) { idxtype i, j, nvtxs, from, imax, gain, mindiff; idxtype *id, *ed; /* Return right away if the balance is OK */ mindiff = idxtype_abs(tpwgts[0]-graph->pwgts[0]); if (mindiff < 3*(graph->pwgts[0]+graph->pwgts[1])/graph->nvtxs) return; if (graph->pwgts[0] > tpwgts[0] && graph->pwgts[0] < (int)(ubfactor*tpwgts[0])) return; if (graph->pwgts[1] > tpwgts[1] && graph->pwgts[1] < (int)(ubfactor*tpwgts[1])) return; if (graph->nbnd > 0) Bnd2WayBalance(ctrl, graph, tpwgts); else General2WayBalance(ctrl, graph, tpwgts); } /************************************************************************* * This function balances two partitions by moving boundary nodes * from the domain that is overweight to the one that is underweight. **************************************************************************/ void Bnd2WayBalance(CtrlType *ctrl, GraphType *graph, idxtype *tpwgts) { idxtype i, ii, j, k, kwgt, nvtxs, nbnd, nswaps, from, to, pass, me, tmp; idxtype *xadj, *vwgt, *adjncy, *adjwgt, *where, *id, *ed, *bndptr, *bndind, *pwgts; idxtype *moved, *perm; PQueueType parts; idxtype higain, oldgain, mincut, mindiff; nvtxs = graph->nvtxs; xadj = graph->xadj; vwgt = graph->vwgt; adjncy = graph->adjncy; adjwgt = graph->adjwgt; where = graph->where; id = graph->id; ed = graph->ed; pwgts = graph->pwgts; bndptr = graph->bndptr; bndind = graph->bndind; moved = idxwspacemalloc(ctrl, nvtxs); perm = idxwspacemalloc(ctrl, nvtxs); /* Determine from which domain you will be moving data */ mindiff = idxtype_abs(tpwgts[0]-pwgts[0]); from = (pwgts[0] < tpwgts[0] ? 1 : 0); to = (from+1)%2; IFSET(ctrl->dbglvl, DBG_REFINE, mprintf("Partitions: [%6D %6D] T[%6D %6D], Nv-Nb[%6D %6D]. ICut: %6D [B]\n", pwgts[0], pwgts[1], tpwgts[0], tpwgts[1], graph->nvtxs, graph->nbnd, graph->mincut)); tmp = graph->adjwgtsum[idxargmax(nvtxs, graph->adjwgtsum)]; PQueueInit(ctrl, &parts, nvtxs, tmp); idxset(nvtxs, -1, moved); ASSERT(ComputeCut(graph, where) == graph->mincut); ASSERT(CheckBnd(graph)); /* Insert the boundary nodes of the proper partition whose size is OK in the priority queue */ nbnd = graph->nbnd; RandomPermute(nbnd, perm, 1); for (ii=0; ii 0 || id[bndind[i]] == 0); ASSERT(bndptr[bndind[i]] != -1); if (where[bndind[i]] == from && vwgt[bndind[i]] <= mindiff) PQueueInsert(&parts, bndind[i], ed[bndind[i]]-id[bndind[i]]); } mincut = graph->mincut; for (nswaps=0; nswaps tpwgts[to]) break; mincut -= (ed[higain]-id[higain]); INC_DEC(pwgts[to], pwgts[from], vwgt[higain]); where[higain] = to; moved[higain] = nswaps; IFSET(ctrl->dbglvl, DBG_MOVEINFO, mprintf("Moved %6D from %D. [%3D %3D] %5D [%4D %4D]\n", higain, from, ed[higain]-id[higain], vwgt[higain], mincut, pwgts[0], pwgts[1])); /************************************************************** * Update the id[i]/ed[i] values of the affected nodes ***************************************************************/ SWAP(id[higain], ed[higain], tmp); if (ed[higain] == 0 && xadj[higain] < xadj[higain+1]) BNDDelete(nbnd, bndind, bndptr, higain); for (j=xadj[higain]; j 0) { /* It will now become a boundary vertex */ BNDInsert(nbnd, bndind, bndptr, k); if (moved[k] == -1 && where[k] == from && vwgt[k] <= mindiff) PQueueInsert(&parts, k, ed[k]-id[k]); } } } } IFSET(ctrl->dbglvl, DBG_REFINE, mprintf("\tMinimum cut: %6D, PWGTS: [%6D %6D], NBND: %6D\n", mincut, pwgts[0], pwgts[1], nbnd)); graph->mincut = mincut; graph->nbnd = nbnd; PQueueFree(ctrl, &parts); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); } /************************************************************************* * This function balances two partitions by moving the highest gain * (including negative gain) vertices to the other domain. * It is used only when tha unbalance is due to non contigous * subdomains. That is, the are no boundary vertices. * It moves vertices from the domain that is overweight to the one that * is underweight. **************************************************************************/ void General2WayBalance(CtrlType *ctrl, GraphType *graph, idxtype *tpwgts) { idxtype i, ii, j, k, kwgt, nvtxs, nbnd, nswaps, from, to, pass, me, tmp; idxtype *xadj, *vwgt, *adjncy, *adjwgt, *where, *id, *ed, *bndptr, *bndind, *pwgts; idxtype *moved, *perm; PQueueType parts; idxtype higain, oldgain, mincut, mindiff; nvtxs = graph->nvtxs; xadj = graph->xadj; vwgt = graph->vwgt; adjncy = graph->adjncy; adjwgt = graph->adjwgt; where = graph->where; id = graph->id; ed = graph->ed; pwgts = graph->pwgts; bndptr = graph->bndptr; bndind = graph->bndind; moved = idxwspacemalloc(ctrl, nvtxs); perm = idxwspacemalloc(ctrl, nvtxs); /* Determine from which domain you will be moving data */ mindiff = idxtype_abs(tpwgts[0]-pwgts[0]); from = (pwgts[0] < tpwgts[0] ? 1 : 0); to = (from+1)%2; IFSET(ctrl->dbglvl, DBG_REFINE, mprintf("Partitions: [%6D %6D] T[%6D %6D], Nv-Nb[%6D %6D]. ICut: %6D [B]\n", pwgts[0], pwgts[1], tpwgts[0], tpwgts[1], graph->nvtxs, graph->nbnd, graph->mincut)); tmp = graph->adjwgtsum[idxargmax(nvtxs, graph->adjwgtsum)]; PQueueInit(ctrl, &parts, nvtxs, tmp); idxset(nvtxs, -1, moved); ASSERT(ComputeCut(graph, where) == graph->mincut); ASSERT(CheckBnd(graph)); /* Insert the nodes of the proper partition whose size is OK in the priority queue */ RandomPermute(nvtxs, perm, 1); for (ii=0; iimincut; nbnd = graph->nbnd; for (nswaps=0; nswaps tpwgts[to]) break; mincut -= (ed[higain]-id[higain]); INC_DEC(pwgts[to], pwgts[from], vwgt[higain]); where[higain] = to; moved[higain] = nswaps; IFSET(ctrl->dbglvl, DBG_MOVEINFO, mprintf("Moved %6D from %D. [%3D %3D] %5D [%4D %4D]\n", higain, from, ed[higain]-id[higain], vwgt[higain], mincut, pwgts[0], pwgts[1])); /************************************************************** * Update the id[i]/ed[i] values of the affected nodes ***************************************************************/ SWAP(id[higain], ed[higain], tmp); if (ed[higain] == 0 && bndptr[higain] != -1 && xadj[higain] < xadj[higain+1]) BNDDelete(nbnd, bndind, bndptr, higain); if (ed[higain] > 0 && bndptr[higain] == -1) BNDInsert(nbnd, bndind, bndptr, higain); for (j=xadj[higain]; j 0 && bndptr[k] == -1) BNDInsert(nbnd, bndind, bndptr, k); } } IFSET(ctrl->dbglvl, DBG_REFINE, mprintf("\tMinimum cut: %6D, PWGTS: [%6D %6D], NBND: %6D\n", mincut, pwgts[0], pwgts[1], nbnd)); graph->mincut = mincut; graph->nbnd = nbnd; PQueueFree(ctrl, &parts); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); } PyMetis-0.90/src/metis/bucketsort.c0000640000175000017500000000173710662171744017125 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * bucketsort.c * * This file contains code that implement a variety of counting sorting * algorithms * * Started 7/25/97 * George * */ #include /************************************************************************* * This function uses simple counting sort to return a permutation array * corresponding to the sorted order. The keys are agk_fsumed to start from * 0 and they are positive. This sorting is used during matching. **************************************************************************/ void BucketSortKeysInc(idxtype n, idxtype max, idxtype *keys, idxtype *tperm, idxtype *perm) { idxtype i, ii; idxtype *counts; counts = idxsmalloc(max+2, 0, "BucketSortKeysInc: counts"); for (i=0; i /************************************************************************* * This function creates the coarser graph **************************************************************************/ void CreateCoarseGraph(CtrlType *ctrl, GraphType *graph, idxtype cnvtxs, idxtype *match, idxtype *perm) { idxtype i, j, jj, k, kk, l, m, istart, iend, nvtxs, nedges, ncon, cnedges, v, u, mask, dovsize; idxtype *xadj, *vwgt, *vsize, *adjncy, *adjwgt, *adjwgtsum, *auxadj; idxtype *cmap, *htable; idxtype *cxadj, *cvwgt, *cvsize, *cadjncy, *cadjwgt, *cadjwgtsum; float *nvwgt, *cnvwgt; GraphType *cgraph; dovsize = (ctrl->optype == OP_KVMETIS ? 1 : 0); mask = HTLENGTH; if (cnvtxs < 8*mask || graph->nedges/graph->nvtxs > 15) { CreateCoarseGraphNoMask(ctrl, graph, cnvtxs, match, perm); return; } IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->ContractTmr)); nvtxs = graph->nvtxs; ncon = graph->ncon; xadj = graph->xadj; vwgt = graph->vwgt; vsize = graph->vsize; nvwgt = graph->nvwgt; adjncy = graph->adjncy; adjwgt = graph->adjwgt; adjwgtsum = graph->adjwgtsum; cmap = graph->cmap; /* Initialize the coarser graph */ cgraph = SetUpCoarseGraph(graph, cnvtxs, dovsize); cxadj = cgraph->xadj; cvwgt = cgraph->vwgt; cvsize = cgraph->vsize; cnvwgt = cgraph->nvwgt; cadjwgtsum = cgraph->adjwgtsum; cadjncy = cgraph->adjncy; cadjwgt = cgraph->adjwgt; iend = xadj[nvtxs]; auxadj = ctrl->wspace.auxcore; memcpy(auxadj, adjncy, iend*sizeof(idxtype)); for (i=0; i= 0 && cadjncy[jj] != cnvtxs) { for (jj=0; jj= 0 && cadjncy[jj] == cnvtxs) { /* This 2nd check is needed for non-adjacent matchings */ cadjwgtsum[cnvtxs] -= cadjwgt[jj]; cadjncy[jj] = cadjncy[--nedges]; cadjwgt[jj] = cadjwgt[nedges]; } } ASSERTP(cadjwgtsum[cnvtxs] == idxsum(nedges, cadjwgt), ("%d %d %d %d %d\n", cnvtxs, cadjwgtsum[cnvtxs], idxsum(nedges, cadjwgt), adjwgtsum[u], adjwgtsum[v])); for (j=0; jnedges = cnedges; ReAdjustMemory(graph, cgraph, dovsize); IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->ContractTmr)); idxwspacefree(ctrl, mask+1); } /************************************************************************* * This function creates the coarser graph **************************************************************************/ void CreateCoarseGraphNoMask(CtrlType *ctrl, GraphType *graph, idxtype cnvtxs, idxtype *match, idxtype *perm) { idxtype i, j, k, m, istart, iend, nvtxs, nedges, ncon, cnedges, v, u, dovsize; idxtype *xadj, *vwgt, *vsize, *adjncy, *adjwgt, *adjwgtsum, *auxadj; idxtype *cmap, *htable; idxtype *cxadj, *cvwgt, *cvsize, *cadjncy, *cadjwgt, *cadjwgtsum; float *nvwgt, *cnvwgt; GraphType *cgraph; dovsize = (ctrl->optype == OP_KVMETIS ? 1 : 0); IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->ContractTmr)); nvtxs = graph->nvtxs; ncon = graph->ncon; xadj = graph->xadj; vwgt = graph->vwgt; vsize = graph->vsize; nvwgt = graph->nvwgt; adjncy = graph->adjncy; adjwgt = graph->adjwgt; adjwgtsum = graph->adjwgtsum; cmap = graph->cmap; /* Initialize the coarser graph */ cgraph = SetUpCoarseGraph(graph, cnvtxs, dovsize); cxadj = cgraph->xadj; cvwgt = cgraph->vwgt; cvsize = cgraph->vsize; cnvwgt = cgraph->nvwgt; cadjwgtsum = cgraph->adjwgtsum; cadjncy = cgraph->adjncy; cadjwgt = cgraph->adjwgt; htable = idxset(cnvtxs, -1, idxwspacemalloc(ctrl, cnvtxs)); iend = xadj[nvtxs]; auxadj = ctrl->wspace.auxcore; memcpy(auxadj, adjncy, iend*sizeof(idxtype)); for (i=0; inedges = cnedges; ReAdjustMemory(graph, cgraph, dovsize); IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->ContractTmr)); idxwspacefree(ctrl, cnvtxs); } /************************************************************************* * This function creates the coarser graph **************************************************************************/ void CreateCoarseGraph_NVW(CtrlType *ctrl, GraphType *graph, idxtype cnvtxs, idxtype *match, idxtype *perm) { idxtype i, j, jj, k, kk, l, m, istart, iend, nvtxs, nedges, ncon, cnedges, v, u, mask; idxtype *xadj, *adjncy, *adjwgtsum, *auxadj; idxtype *cmap, *htable; idxtype *cxadj, *cvwgt, *cadjncy, *cadjwgt, *cadjwgtsum; float *nvwgt, *cnvwgt; GraphType *cgraph; IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->ContractTmr)); nvtxs = graph->nvtxs; ncon = graph->ncon; xadj = graph->xadj; nvwgt = graph->nvwgt; adjncy = graph->adjncy; adjwgtsum = graph->adjwgtsum; cmap = graph->cmap; /* Initialize the coarser graph */ cgraph = SetUpCoarseGraph(graph, cnvtxs, 0); cxadj = cgraph->xadj; cvwgt = cgraph->vwgt; cnvwgt = cgraph->nvwgt; cadjwgtsum = cgraph->adjwgtsum; cadjncy = cgraph->adjncy; cadjwgt = cgraph->adjwgt; iend = xadj[nvtxs]; auxadj = ctrl->wspace.auxcore; memcpy(auxadj, adjncy, iend*sizeof(idxtype)); for (i=0; i= 0 && cadjncy[jj] != cnvtxs) { for (jj=0; jj= 0 && cadjncy[jj] == cnvtxs) { /* This 2nd check is needed for non-adjacent matchings */ cadjwgtsum[cnvtxs] -= cadjwgt[jj]; cadjncy[jj] = cadjncy[--nedges]; cadjwgt[jj] = cadjwgt[nedges]; } } ASSERTP(cadjwgtsum[cnvtxs] == idxsum(nedges, cadjwgt), ("%d %d %d %d %d\n", cnvtxs, cadjwgtsum[cnvtxs], idxsum(nedges, cadjwgt), adjwgtsum[u], adjwgtsum[v])); for (j=0; jnedges = cnedges; ReAdjustMemory(graph, cgraph, 0); IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->ContractTmr)); idxwspacefree(ctrl, mask+1); } /************************************************************************* * Setup the various arrays for the coarse graph **************************************************************************/ GraphType *SetUpCoarseGraph(GraphType *graph, idxtype cnvtxs, idxtype dovsize) { GraphType *cgraph; cgraph = CreateGraph(); cgraph->nvtxs = cnvtxs; cgraph->ncon = graph->ncon; cgraph->finer = graph; graph->coarser = cgraph; /* Allocate memory for the coarser graph */ cgraph->xadj = idxmalloc(cnvtxs+1, "SetUpCoarseGraph: xadj"); cgraph->adjwgtsum = idxmalloc(cnvtxs, "SetUpCoarseGraph: adjwgtsum"); cgraph->cmap = idxmalloc(cnvtxs, "SetUpCoarseGraph: cmap"); cgraph->adjncy = idxmalloc(graph->nedges, "SetUpCoarseGraph: adjncy"); cgraph->adjwgt = idxmalloc(graph->nedges, "SetUpCoarseGraph: adjwgt"); if (graph->ncon == 1) cgraph->vwgt = idxmalloc(cnvtxs, "SetUpCoarseGraph: vwgt"); else cgraph->nvwgt = gk_fmalloc(graph->ncon*cnvtxs, "SetUpCoarseGraph: nvwgt"); if (dovsize) cgraph->vsize = idxmalloc(cnvtxs, "SetUpCoarseGraph: vsize"); return cgraph; } /************************************************************************* * This function re-adjusts the amount of memory that was allocated if * it will lead to significant savings **************************************************************************/ void ReAdjustMemory(GraphType *graph, GraphType *cgraph, idxtype dovsize) { if (cgraph->nedges > 10000 && cgraph->nedges < 0.8*graph->nedges) { cgraph->adjncy = idxrealloc(cgraph->adjncy, cgraph->nedges, "ReAdjustMemory: adjncy"); cgraph->adjwgt = idxrealloc(cgraph->adjwgt, cgraph->nedges, "ReAdjustMemory: adjwgt"); } } PyMetis-0.90/src/metis/checkgraph.c0000640000175000017500000000604610662171744017035 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * checkgraph.c * * This file contains routines related to I/O * * Started 8/28/94 * George * */ #include /************************************************************************* * This function checks if a graph is valid **************************************************************************/ idxtype CheckGraph(GraphType *graph) { idxtype i, j, k, l; idxtype nvtxs, ncon, err=0; idxtype minedge, maxedge, minewgt, maxewgt; float minvwgt[MAXNCON], maxvwgt[MAXNCON]; idxtype *xadj, *adjncy, *adjwgt, *htable; float *nvwgt, ntvwgts[MAXNCON]; nvtxs = graph->nvtxs; ncon = graph->ncon; xadj = graph->xadj; nvwgt = graph->nvwgt; adjncy = graph->adjncy; adjwgt = graph->adjwgt; htable = idxsmalloc(nvtxs, 0, "htable"); if (ncon > 1) { for (j=0; j 1) { for (j=0; j maxvwgt[j]) ? nvwgt[i*ncon+j] : maxvwgt[j]; } } for (j=xadj[i]; j maxedge) ? k : maxedge; minewgt = (adjwgt[j] < minewgt) ? adjwgt[j] : minewgt; maxewgt = (adjwgt[j] > maxewgt) ? adjwgt[j] : maxewgt; if (i == k) { mprintf("Vertex %D contains a self-loop (i.e., diagonal entry in the matrix)!\n", i); err++; } else { for (l=xadj[k]; l 1) { for (j=0; j 0.0001) { mprintf("Normalized vwgts don't sum to one. Weight %D = %.8f.\n", j, ntvwgts[j]); err++; } } } /* mprintf("errs: %D, adjncy: [%D %D], adjwgt: [%D %D]\n", err, minedge, maxedge, minewgt, maxewgt); if (ncon > 1) { for (j=0; j 0) { mprintf("A total of %D errors exist in the input file. Correct them, and run again!\n", err); } gk_free((void **)&htable, LTERM); return (err == 0 ? 1 : 0); } PyMetis-0.90/src/metis/cmetis.c0000640000175000017500000012032310662171744016215 0ustar andreasandreas/* * Copyright 2003, Regents of the University of Minnesota * * kmetis.c * * This file contains the top level routines for the contact-friendly partitioning * algorithm CMETIS. * * Started 4/3/03 * George * */ #include #define DEPSILON 1.0e-012 #define _PRINTSTAT /************************************************************************* * This function is the entry point for KMETIS **************************************************************************/ void *METIS_PartGraphForContact(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, double *xyzcoords, idxtype *sflag, idxtype *numflag, idxtype *nparts, idxtype *options, idxtype *edgecut, idxtype *part) { idxtype i, j, ii, dim, ncon, wgtflag, mcnumflag, nnodes, nlnodes, nclean, naclean, ndirty, maxdepth, rwgtflag, rnumflag; idxtype *mcvwgt, *dtpart, *marker, *leafpart; idxtype *adjwgt; float rubvec[2], lbvec[2]; GraphType graph, *cgraph; ContactInfoType *cinfo; DKeyValueType *xyzcand[3]; if (*numflag == 1) Change2CNumbering(*nvtxs, xadj, adjncy); /*--------------------------------------------------------------------- * Allocate memory for the contact info type *---------------------------------------------------------------------*/ cinfo = (ContactInfoType *)gk_malloc(sizeof(ContactInfoType), "METIS_PartGraphForContact: cinfo"); cinfo->leafptr = idxsmalloc(*nvtxs+1, 0, "METIS_PartGraphForContact: leafptr"); cinfo->leafind = idxsmalloc(*nvtxs, 0, "METIS_PartGraphForContact: leafind"); cinfo->leafwgt = idxsmalloc(*nvtxs, 0, "METIS_PartGraphForContact: leafwgt"); cinfo->part = idxsmalloc(*nvtxs, 0, "METIS_PartGraphForContact: part"); leafpart = cinfo->leafpart = idxmalloc(*nvtxs, "METIS_PartGraphForContact: leafpart"); cinfo->dtree = (DTreeNodeType *)gk_malloc(sizeof(DTreeNodeType)*(*nvtxs), "METIS_PartGraphForContact: cinfo->dtree"); cinfo->nvtxs = *nvtxs; /*--------------------------------------------------------------------- * Compute the initial k-way partitioning *---------------------------------------------------------------------*/ mcvwgt = idxsmalloc(2*(*nvtxs), 0, "METIS_PartGraphForContact: mcvwgt"); for (i=0; i<*nvtxs; i++) { mcvwgt[2*i+0] = 1; mcvwgt[2*i+1] = (sflag[i] == 0 ? 0 : 1); } adjwgt = idxmalloc(xadj[*nvtxs], "METIS_PartGraphForContact: adjwgt"); for (i=0; i<*nvtxs; i++) { for (j=xadj[i]; jdtree, leafpart, dtpart, &nclean, &naclean, &ndirty, &maxdepth, marker); mprintf("NNodes: %5D, NLNodes: %5D, NClean: %5D, NAClean: %5D, NDirty: %5D, MaxDepth: %3D\n", nnodes, nlnodes, nclean, naclean, ndirty, maxdepth); /*--------------------------------------------------------------------- * Create the tree-induced coarse graph and refine it *---------------------------------------------------------------------*/ cgraph = CreatePartitionGraphForContact(*nvtxs, xadj, adjncy, mcvwgt, adjwgt, nlnodes, leafpart); for (i=0; i<*nvtxs; i++) part[leafpart[i]] = dtpart[i]; ComputePartitionBalance(cgraph, *nparts, part, lbvec); mprintf(" %D-way Edge-Cut: %7D, Balance: %5.2f %5.2f\n", *nparts, ComputeCut(cgraph, part), lbvec[0], lbvec[1]); rwgtflag = 3; rnumflag = 0; METIS_mCRefineGraphKway(&(cgraph->nvtxs), &ncon, cgraph->xadj, cgraph->adjncy, cgraph->vwgt, cgraph->adjwgt, &rwgtflag, &rnumflag, nparts, rubvec, options, edgecut, part); ComputePartitionBalance(cgraph, *nparts, part, lbvec); mprintf(" %D-way Edge-Cut: %7D, Balance: %5.2f %5.2f\n", *nparts, ComputeCut(cgraph, part), lbvec[0], lbvec[1]); /*--------------------------------------------------------------------- * Use that to compute the partition of the original graph *---------------------------------------------------------------------*/ idxcopy(cgraph->nvtxs, part, dtpart); for (i=0; i<*nvtxs; i++) part[i] = dtpart[leafpart[i]]; ComputePartitionBalance(&graph, *nparts, part, lbvec); idxset(*nvtxs, 1, graph.vwgt); mprintf(" %D-way Edge-Cut: %7D, Volume: %7D, Balance: %5.2f %5.2f\n", *nparts, ComputeCut(&graph, part), ComputeVolume(&graph, part), lbvec[0], lbvec[1]); /*--------------------------------------------------------------------- * Induce the final decission tree *---------------------------------------------------------------------*/ nnodes = nlnodes = nclean = naclean = ndirty = maxdepth = 0; InduceDecissionTree(*nvtxs, xyzcand, sflag, *nparts, part, *nvtxs/((40)*(*nparts)), 1, 1.00, &nnodes, &nlnodes, cinfo->dtree, leafpart, dtpart, &nclean, &naclean, &ndirty, &maxdepth, marker); mprintf("NNodes: %5D, NLNodes: %5D, NClean: %5D, NAClean: %5D, NDirty: %5D, MaxDepth: %3D\n", nnodes, nlnodes, nclean, naclean, ndirty, maxdepth); /*--------------------------------------------------------------------- * Populate the remaining fields of the cinfo data structure *---------------------------------------------------------------------*/ cinfo->nnodes = nnodes; cinfo->nleafs = nlnodes; idxcopy(*nvtxs, part, cinfo->part); BuildDTLeafContents(cinfo, sflag); CheckDTree(*nvtxs, xyzcoords, part, cinfo); gk_free((void **)&mcvwgt, &dtpart, &xyzcand[0], &xyzcand[1], &xyzcand[2], &marker, &adjwgt, LTERM); if (*numflag == 1) Change2FNumbering(*nvtxs, xadj, adjncy, part); return (void *)cinfo; } /************************************************************************* * This function is the entry point for KMETIS **************************************************************************/ void METIS_UpdateContactInfo(void *raw_cinfo, idxtype *nvtxs, double *xyzcoords, idxtype *sflag) { idxtype i, root, nchanges; ContactInfoType *cinfo; DTreeNodeType *dtree; cinfo = (ContactInfoType *)raw_cinfo; dtree = cinfo->dtree; if (cinfo->nvtxs != *nvtxs) errexit("The provided number of vertices do not match the initial information: %d %d\n", *nvtxs, cinfo->nvtxs); /* Go and reset the nsvtxs fields of all the nodes */ for (i=0; innodes; i++) { dtree[i].nvtxs = 0; dtree[i].nsvtxs = 0; } /* Go and traverse each surface node and see where it gets assigned (We only focus on surface nodes. Right???) */ for (nchanges=0, i=0; i<*nvtxs; i++) { if (1 || sflag[i]) { for (root=0; dtree[root].leafid == -1;) root = (xyzcoords[3*i+dtree[root].dim] <= dtree[root].value ? dtree[root].left : dtree[root].right); if (cinfo->leafpart[i] != dtree[root].leafid && sflag[i]) nchanges++; cinfo->leafpart[i] = dtree[root].leafid; dtree[root].nvtxs++; if (sflag[i]) dtree[root].nsvtxs++; } } mprintf("NChanges: %D\n", nchanges); BuildDTLeafContents(cinfo, sflag); return; for (i=0; innodes; i++) { if (dtree[i].leafid != -1) mprintf("%4D %4D %4D %4D\n", dtree[i].nvtxs, dtree[i].nsvtxs, dtree[i].leafid, dtree[i].partid); } } /************************************************************************* * This function is the entry point for KMETIS **************************************************************************/ void *METIS_SetupContact0(idxtype *nvtxs, double *xyzcoords, idxtype *sflag, idxtype *nparts, idxtype *part) { idxtype i, j, ii, dim, ncontacts, wgtflag, mcnumflag, nnodes, nlnodes, nclean, naclean, ndirty, maxdepth, rwgtflag, rnumflag; idxtype *mcvwgt, *dtpart, *marker, *leafpart, *csflag, *cpart; idxtype *adjwgt; GraphType graph, *cgraph; ContactInfoType *cinfo; DKeyValueType *xyzcand[3]; /*--------------------------------------------------------------------- * Allocate memory for the contact info type *---------------------------------------------------------------------*/ cinfo = (ContactInfoType *)gk_malloc(sizeof(ContactInfoType), "METIS_PartGraphForContact: cinfo"); cinfo->leafptr = idxsmalloc(*nvtxs+1, 0, "METIS_PartGraphForContact: leafptr"); cinfo->leafind = idxsmalloc(*nvtxs, 0, "METIS_PartGraphForContact: leafind"); cinfo->leafwgt = idxsmalloc(*nvtxs, 0, "METIS_PartGraphForContact: leafwgt"); cinfo->part = idxsmalloc(*nvtxs, 0, "METIS_PartGraphForContact: part"); leafpart = cinfo->leafpart = idxmalloc(*nvtxs, "METIS_PartGraphForContact: leafpart"); cinfo->dtree = (DTreeNodeType *)gk_malloc(sizeof(DTreeNodeType)*(*nvtxs), "METIS_PartGraphForContact: cinfo->dtree"); cinfo->nvtxs = *nvtxs; /*--------------------------------------------------------------------- * Induce the decission tree *---------------------------------------------------------------------*/ dtpart = idxmalloc(*nvtxs, "METIS_PartGraphForContact: dtpart"); marker = idxsmalloc(*nvtxs, 0, "METIS_PartGraphForContact: marker"); for (dim=0; dim<3; dim++) xyzcand[dim] = (DKeyValueType *)gk_malloc(sizeof(DKeyValueType)*(*nvtxs), "METIS_PartGraphForContact: xyzcand[dim]"); for (ncontacts=0, i=0; i<*nvtxs; i++) { if (sflag[i]) { for (dim=0; dim<3; dim++) { xyzcand[dim][ncontacts].key = xyzcoords[3*i+dim]; xyzcand[dim][ncontacts].val = i; } ncontacts++; } } for (dim=0; dim<3; dim++) idkeysort(ncontacts, xyzcand[dim]); nnodes = nlnodes = nclean = naclean = ndirty = maxdepth = 0; InduceDecissionTree(ncontacts, xyzcand, sflag, *nparts, part, ncontacts, 1, 1.00, &nnodes, &nlnodes, cinfo->dtree, leafpart, dtpart, &nclean, &naclean, &ndirty, &maxdepth, marker); mprintf("NNodes: %5D, NLNodes: %5D, NClean: %5D, NAClean: %5D, NDirty: %5D, MaxDepth: %3D\n", nnodes, nlnodes, nclean, naclean, ndirty, maxdepth); /*--------------------------------------------------------------------- * Populate the remaining fields of the cinfo data structure *---------------------------------------------------------------------*/ cinfo->nnodes = nnodes; cinfo->nleafs = nlnodes; idxcopy(*nvtxs, part, cinfo->part); BuildDTLeafContents(cinfo, sflag); CheckDTreeSurface(*nvtxs, xyzcoords, part, cinfo, sflag); gk_free((void **)&dtpart, &xyzcand[0], &xyzcand[1], &xyzcand[2], &marker, LTERM); /* for (i=0; idtree[i].leafid, cinfo->dtree[i].nsvtxs); */ return (void *)cinfo; } /************************************************************************* * This function is the entry point for KMETIS **************************************************************************/ void *METIS_SetupContact(idxtype *nvtxs, double *xyzcoords, idxtype *sflag, idxtype *nparts, idxtype *part) { idxtype i, j, ii, dim, ncontacts, wgtflag, mcnumflag, nnodes, nlnodes, nclean, naclean, ndirty, maxdepth, rwgtflag, rnumflag; idxtype *mcvwgt, *dtpart, *marker, *leafpart, *csflag, *cpart; idxtype *adjwgt; GraphType graph, *cgraph; ContactInfoType *cinfo; DKeyValueType *xyzcand[3]; /*--------------------------------------------------------------------- * Allocate memory for the contact info type *---------------------------------------------------------------------*/ cinfo = (ContactInfoType *)gk_malloc(sizeof(ContactInfoType), "METIS_PartGraphForContact: cinfo"); cinfo->leafptr = idxsmalloc(*nvtxs+1, 0, "METIS_PartGraphForContact: leafptr"); cinfo->leafind = idxsmalloc(*nvtxs, 0, "METIS_PartGraphForContact: leafind"); cinfo->leafwgt = idxsmalloc(*nvtxs, 0, "METIS_PartGraphForContact: leafwgt"); cinfo->part = idxsmalloc(*nvtxs, 0, "METIS_PartGraphForContact: part"); leafpart = cinfo->leafpart = idxmalloc(*nvtxs, "METIS_PartGraphForContact: leafpart"); cinfo->dtree = (DTreeNodeType *)gk_malloc(sizeof(DTreeNodeType)*(*nvtxs), "METIS_PartGraphForContact: cinfo->dtree"); cinfo->nvtxs = *nvtxs; /*--------------------------------------------------------------------- * Induce the decission tree *---------------------------------------------------------------------*/ dtpart = idxmalloc(*nvtxs, "METIS_PartGraphForContact: dtpart"); marker = idxsmalloc(*nvtxs, 0, "METIS_PartGraphForContact: marker"); for (dim=0; dim<3; dim++) { xyzcand[dim] = (DKeyValueType *)gk_malloc(sizeof(DKeyValueType)*(*nvtxs), "METIS_PartGraphForContact: xyzcand[dim]"); for (i=0; i<*nvtxs; i++) { xyzcand[dim][i].key = xyzcoords[3*i+dim]; xyzcand[dim][i].val = i; } idkeysort(*nvtxs, xyzcand[dim]); } nnodes = nlnodes = nclean = naclean = ndirty = maxdepth = 0; InduceDecissionTree(*nvtxs, xyzcand, sflag, *nparts, part, *nvtxs, 1, 1.00, &nnodes, &nlnodes, cinfo->dtree, leafpart, dtpart, &nclean, &naclean, &ndirty, &maxdepth, marker); mprintf("NNodes: %5D, NLNodes: %5D, NClean: %5D, NAClean: %5D, NDirty: %5D, MaxDepth: %3D\n", nnodes, nlnodes, nclean, naclean, ndirty, maxdepth); /*--------------------------------------------------------------------- * Populate the remaining fields of the cinfo data structure *---------------------------------------------------------------------*/ cinfo->nnodes = nnodes; cinfo->nleafs = nlnodes; idxcopy(*nvtxs, part, cinfo->part); BuildDTLeafContents(cinfo, sflag); CheckDTree(*nvtxs, xyzcoords, part, cinfo); gk_free((void **)&dtpart, &xyzcand[0], &xyzcand[1], &xyzcand[2], &marker, LTERM); /* for (i=0; idtree[i].leafid, cinfo->dtree[i].nsvtxs); */ return (void *)cinfo; } /************************************************************************* * This function is the entry point for detecting contacts between * bounding boxes and surface nodes **************************************************************************/ void METIS_FindContacts(void *raw_cinfo, idxtype *nboxes, double *boxcoords, idxtype *nparts, idxtype **r_cntptr, idxtype **r_cntind) { idxtype i, ncnts, tncnts, maxtncnts; idxtype *cntptr, *cntind, *auxcntind, *stack, *marker; ContactInfoType *cinfo; cinfo = (ContactInfoType *)raw_cinfo; maxtncnts = 6*(*nboxes); cntptr = idxsmalloc(*nboxes+1, 0, "METIS_FindContacts: cntptr"); cntind = idxmalloc(maxtncnts, "METIS_FindContacts: cntind"); auxcntind = idxmalloc(*nparts, "METIS_FindContacts: auxcntind"); stack = idxmalloc(cinfo->nnodes, "METIS_FindContacts: stack"); marker = idxsmalloc(*nparts, 0, "METIS_FindContacts: marker"); /* Go through each box and determine its contacting partitions */ for (tncnts=0, i=0; i<*nboxes; i++) { ncnts = FindBoxContacts(cinfo, boxcoords+i*6, stack, auxcntind, marker); if (ncnts == 0) mprintf("CSearchError: Box has no contacts!\n"); if (ncnts + tncnts >= maxtncnts) { maxtncnts += (tncnts+ncnts)*(*nboxes-i)/i; if ((cntind = (idxtype *)realloc(cntind, maxtncnts*sizeof(idxtype))) == NULL) errexit("Realloc failed! of %d words!\n", maxtncnts); } cntptr[i] = ncnts; idxcopy(ncnts, auxcntind, cntind+tncnts); tncnts += ncnts; } MAKECSR(i, *nboxes, cntptr); *r_cntptr = cntptr; *r_cntind = cntind; gk_free((void **)&auxcntind, &stack, &marker, LTERM); } /************************************************************************* * This function is the entry point for KMETIS **************************************************************************/ void METIS_FreeContactInfo(void *raw_cinfo) { ContactInfoType *cinfo; cinfo = (ContactInfoType *)raw_cinfo; gk_free((void **)&(cinfo->leafptr), &(cinfo->leafind), &(cinfo->leafwgt), &(cinfo->part), &(cinfo->leafpart), &(cinfo->dtree), &cinfo, LTERM); } /****************************************************************************** * This function creates a coarse graph corresponding to the partitioning vector *******************************************************************************/ GraphType *CreatePartitionGraphForContact(idxtype nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype cnvtxs, idxtype *part) { idxtype i, ii, j, jj, k, cnedges; idxtype *cxadj, *cadjncy, *cvwgt, *cadjwgt; idxtype *ptr, *ind, *marker; GraphType *cgraph; ptr = idxsmalloc(cnvtxs+1, 0, "CreatePartitionGraph: ptr"); ind = idxmalloc(nvtxs, "CreatePartitionGraph: ind"); marker = idxsmalloc(cnvtxs, -1, "CreatePartitionGraph: marker"); cgraph = CreateGraph(); cgraph->ncon = 2; cgraph->nvtxs = cnvtxs; cxadj = cgraph->xadj = idxsmalloc(cnvtxs+1, 0, "CreatePartitionGraph: cxadj"); cadjncy = cgraph->adjncy = idxmalloc(xadj[nvtxs], "CreatePartitionGraph: cadjncy"); cvwgt = cgraph->vwgt = idxmalloc(2*cnvtxs, "CreatePartitionGraph: cvwgt"); cadjwgt = cgraph->adjwgt = idxmalloc(xadj[nvtxs], "CreatePartitionGraph: cadjwgt"); for (i=0; i 0 ? 1 : 0); //mprintf("LEAF3: %5D %5D Skipping small node!\n", nvtxs, k); *r_ndirty += nvtxs*k; isleaf = 1; } else if (nvtxs < maxnvtxs && tpwgts[pid] >= (int)(minfrac*nvtxs)) { /* Determine if mostly one class */ //mprintf("LEAF2: %5D %5D %4D Almost pure node!\n", nvtxs, tpwgts[idxargmax(nparts, tpwgts)], idxargmax(nparts, tpwgts)); *r_naclean += nvtxs; isleaf = 1; } else { /* Check if all coordinates are the same */ for (dim=0; dim<3; dim++) { for (i=1; i DEPSILON) break; } if (i != nvtxs) break; } if (dim == 3) { /* All coordinates matched! Treat it as a dirty node! */ for (k=0, i=0; i 0 ? 1 : 0); mprintf("LEAF4: %5D %5D Skipping same coord-nodes! (%D %D)\n", nvtxs, k, isclean, part[xyzcand[0][0].val]); *r_ndirty += nvtxs*k; isleaf = 1; } } if (isleaf) { for (i=0; i DEPSILON) { scores[dim] = sqrt(sum2[0])+sqrt(sum2[1]); points[dim] = (xyzcand[dim][i].key+xyzcand[dim][i+1].key)/2.0; lnvtxs[dim] = nleft; break; } } #ifdef PRINTSTAT if (i == nvtxs-1) mprintf("DTree: Initial Scan Along dim %D failed!\n", dim); #endif /* Continue with the rest */ for (i++; i= nvtxs/2) { if (fabs(xyzcand[dim][i].key - xyzcand[dim][i+1].key) < DEPSILON) continue; scores[dim] = xyzcand[dim][nvtxs-1].key - xyzcand[dim][0].key; /* Use the axis span as the score */ points[dim] = (xyzcand[dim][i].key+xyzcand[dim][i+1].key)/2.0; lnvtxs[dim] = nleft; break; } } else { if (newscore > scores[dim]) { if (fabs(xyzcand[dim][i].key - xyzcand[dim][i+1].key) < DEPSILON) continue; scores[dim] = newscore; points[dim] = (xyzcand[dim][i].key+xyzcand[dim][i+1].key)/2.0; lnvtxs[dim] = nleft; } } //mprintf("%5D %f %f %f\n", nleft, newscore, sum2[0], sum2[1]); } #ifdef PRINTSTAT /* Print some Stats */ if (scores[dim] >= 0) { mprintf("Dim: %3D, Score: %f, Point: %f [%5D %5D] [%f %f]\n", dim, scores[dim], points[dim], lnvtxs[dim], nvtxs-lnvtxs[dim], xyzcand[dim][0].key, xyzcand[dim][nvtxs-1].key); idxcopy(nparts, tpwgts, pwgts[1]); idxset(nparts, 0, pwgts[0]); for (i=0; i 0) mprintf("%5D => %5D %5D\n", j, pwgts[0][j], pwgts[1][j]); } #endif } /* Determine the best overall score */ bestdim = 0; bestscore = scores[0]; bestpoint = points[0]; for (dim=1; dim<3; dim++) { if (scores[dim] > bestscore) { bestscore = scores[dim]; bestpoint = points[dim]; bestdim = dim; } } if (bestscore <= 0.0) errexit("Major Failure... Non-seperable! %4d nodes. Needs to be fixed!\n", nvtxs); dtree[mynodeID].dim = bestdim; dtree[mynodeID].value = bestpoint; //mprintf("BestDim: %D!\n", bestdim); /*----------------------------------------------------------------------- * Ok, now go and do the split *-----------------------------------------------------------------------*/ nleft = lnvtxs[bestdim]; nright = nvtxs - nleft; for (dim=0; dim<3; dim++) { lxyzcand[dim] = (DKeyValueType *)gk_malloc(sizeof(DKeyValueType)*nleft, "InduceDecissionTree: lxyzcand[dim]"); rxyzcand[dim] = (DKeyValueType *)gk_malloc(sizeof(DKeyValueType)*nright, "InduceDecissionTree: rxyzcand[dim]"); } /* Mark the left vertices */ for (i=0; invtxs; nleafs = cinfo->nleafs; part = cinfo->part; leafpart = cinfo->leafpart; leafptr = cinfo->leafptr; leafind = cinfo->leafind; leafwgt = cinfo->leafwgt; cand = (KeyValueType *)gk_malloc(sizeof(KeyValueType)*nvtxs, "BuildDTLeafContents: cand"); for (ncontacts=0, i=0; i 1) { mprintf("%4D, ", i); for (j=leafptr[i]; j ", i); for (j=leafptr[i]; jleafptr; leafind = cinfo->leafind; dtree = cinfo->dtree; //mprintf("%e %e %e %e %e %e\n", coords[0], coords[1], coords[2], coords[3], coords[4], coords[5]); stack[0] = 0; k = 1; ncnts = 0; while (k > 0) { root = stack[--k]; /* See if you hit a leaf */ if ((leafid = dtree[root].leafid) != -1) { //mprintf("Got to a leaf.... %D %D %D\n", leafid, dtree[root].nsvtxs, leafptr[leafid+1]-leafptr[leafid]); if (dtree[root].nsvtxs > 0) { /* Add unique processor IDs. */ for (j=leafptr[leafid]; j ", dtree[root].dim, dtree[root].value, dtree[root].left, dtree[root].right); if (coords[dtree[root].dim] <= dtree[root].value) { /* min <= value */ stack[k++] = dtree[root].left; //mprintf(" %D", stack[k-1]); } if (coords[3+dtree[root].dim] >= dtree[root].value) { /* max >= value */ stack[k++] = dtree[root].right; //mprintf(" %D", stack[k-1]); } //mprintf("\n"); } for (i=0; ileafptr; leafind = cinfo->leafind; dtree = cinfo->dtree; for (i=0; ileafpart[i] != dtree[root].leafid) mprintf("DTError! %4D %4D %4D %4D %4D\n", i, cinfo->leafpart[i], dtree[root].leafid, part[i], leafind[leafptr[dtree[root].leafid]]); } } /*********************************************************************************** * This function checks the DT to see if it properly "classifies" all points ************************************************************************************/ void CheckDTreeSurface(idxtype nvtxs, double *xyzcoords, idxtype *part, ContactInfoType *cinfo, idxtype *sflag) { idxtype i, j, k, root; idxtype *leafptr, *leafind; DTreeNodeType *dtree; leafptr = cinfo->leafptr; leafind = cinfo->leafind; dtree = cinfo->dtree; for (i=0; ileafpart[i] != dtree[root].leafid) mprintf("SDTError! %4D %4D %4D %4D %4D\n", i, cinfo->leafpart[i], dtree[root].leafid, part[i], leafind[leafptr[dtree[root].leafid]]); } } /************************************************************************* * This function is the entry point for KMETIS **************************************************************************/ void *METIS_PartSurfForContactRCB(idxtype *nvtxs, double *xyzcoords, idxtype *sflag, idxtype *nparts, idxtype *part, idxtype *bestdims) { idxtype i, j, nsurf, dim, ncon, nnodes, nlnodes; idxtype *marker, *spart; ContactInfoType *cinfo; DKeyValueType *xyzcand[3]; double *myxyzcoords; /*--------------------------------------------------------------------- * Allocate memory for the contact info type *---------------------------------------------------------------------*/ cinfo = (ContactInfoType *)gk_malloc(sizeof(ContactInfoType), "METIS_PartGraphForContact: cinfo"); cinfo->leafptr = idxsmalloc(*nvtxs+1, 0, "METIS_PartGraphForContact: leafptr"); cinfo->leafind = idxsmalloc(*nvtxs, 0, "METIS_PartGraphForContact: leafind"); cinfo->leafwgt = idxsmalloc(*nvtxs, 0, "METIS_PartGraphForContact: leafwgt"); cinfo->part = idxsmalloc(*nvtxs, 0, "METIS_PartGraphForContact: part"); cinfo->leafpart = idxmalloc(*nvtxs, "METIS_PartGraphForContact: leafpart"); cinfo->dtree = (DTreeNodeType *)gk_malloc(sizeof(DTreeNodeType)*(*nvtxs), "METIS_PartGraphForContact: cinfo->dtree"); /*--------------------------------------------------------------------- * Induce the decission tree *---------------------------------------------------------------------*/ myxyzcoords = gk_dmalloc(3*(*nvtxs), "METIS_PartSurfForContactRCB: myxyzcoords"); marker = idxsmalloc(*nvtxs, 0, "METIS_PartGraphForContact: marker"); for (dim=0; dim<3; dim++) { xyzcand[dim] = (DKeyValueType *)gk_malloc(sizeof(DKeyValueType)*(*nvtxs), "METIS_PartGraphForContact: xyzcand[dim]"); for (nsurf=0, i=0; i<*nvtxs; i++) { if (sflag[i]) { myxyzcoords[3*nsurf+dim] = xyzcoords[3*i+dim]; xyzcand[dim][nsurf].key = xyzcoords[3*i+dim]; xyzcand[dim][nsurf].val = nsurf++; } } idkeysort(nsurf, xyzcand[dim]); } spart = idxsmalloc(nsurf, 0, "METIS_PartGraphForContact: spart"); nnodes = nlnodes = 0; InduceRCBTree(nsurf, xyzcand, 0, *nparts, &nnodes, &nlnodes, cinfo->dtree, cinfo->leafpart, spart, marker, bestdims); mprintf("NNodes: %5D, NLNodes: %5D\n", nnodes, nlnodes); /* Project the partition back to the original space */ for (nsurf=0, i=0; i<*nvtxs; i++) part[i] = (sflag[i] ? spart[nsurf++] : -1); /*--------------------------------------------------------------------- * Populate the remaining fields of the cinfo data structure *---------------------------------------------------------------------*/ cinfo->nvtxs = nsurf; cinfo->nnodes = nnodes; cinfo->nleafs = nlnodes; idxcopy(nsurf, spart, cinfo->part); idxset(nsurf, 1, marker); BuildDTLeafContents(cinfo, marker); CheckDTree(nsurf, myxyzcoords, spart, cinfo); gk_free((void **)&xyzcand[0], &xyzcand[1], &xyzcand[2], &myxyzcoords, &marker, &spart, LTERM); for (i=0; innodes; i++) bestdims[i] = cinfo->dtree[i].dim; return (void *)cinfo; } /************************************************************************* * This function induces a DT that satisfied the given size requirements **************************************************************************/ idxtype InduceRCBTree(idxtype nvtxs, DKeyValueType **xyzcand, idxtype firstPID, idxtype nparts, idxtype *r_nnodes, idxtype *r_nlnodes, DTreeNodeType *dtree, idxtype *leafpart, idxtype *part, idxtype *marker, idxtype *oldBestDims) { idxtype i, nr, nl, j, k, mynodeID, dim, bestdim, lnvtxs, rnvtxs, lnparts, rnparts; DKeyValueType *lxyzcand[3], *rxyzcand[3]; double bestpoint; mynodeID = (*r_nnodes)++; dtree[mynodeID].nvtxs = nvtxs; dtree[mynodeID].nsvtxs = nvtxs; dtree[mynodeID].leafid = -1; /*----------------------------------------------------------------------- * Check the exit conditions *-----------------------------------------------------------------------*/ if (nparts == 1) { //mprintf("Pid:%D, Size:%D\n", firstPID, nvtxs); for (i=0; i DEPSILON) break; } lnvtxs++; rnvtxs = nvtxs - lnvtxs; } if (rnvtxs <= 0) { if (bestdim != -1) mprintf("Finding a dimension for %D points...\n", nvtxs); lnparts = nparts/2; rnparts = nparts - lnparts; lnvtxs = nvtxs*lnparts/nparts; for (bestdim=0, i=1; i<3; i++) bestdim = (xyzcand[i][nvtxs-1].key - xyzcand[i][0].key > xyzcand[bestdim][nvtxs-1].key - xyzcand[bestdim][0].key ? i : bestdim); for (; lnvtxs DEPSILON) break; } lnvtxs++; rnvtxs = nvtxs - lnvtxs; } dtree[mynodeID].dim = bestdim; dtree[mynodeID].value = bestpoint = (xyzcand[bestdim][lnvtxs-1].key+xyzcand[bestdim][lnvtxs].key)/2; /* Print some Stats */ //mprintf("Dim: %3D, Point: %f [%5D %5D] [%3D %3D]\n", bestdim, bestpoint, lnvtxs, rnvtxs, lnparts, rnparts); /*----------------------------------------------------------------------- * Ok, now go and do the split *-----------------------------------------------------------------------*/ for (dim=0; dim<3; dim++) { lxyzcand[dim] = (DKeyValueType *)gk_malloc(sizeof(DKeyValueType)*lnvtxs, "InduceDecissionTree: lxyzcand[dim]"); rxyzcand[dim] = (DKeyValueType *)gk_malloc(sizeof(DKeyValueType)*rnvtxs, "InduceDecissionTree: rxyzcand[dim]"); } /* Mark the left vertices */ for (i=0; i /************************************************************************* * This function takes a graph and creates a sequence of coarser graphs **************************************************************************/ GraphType *Coarsen2Way(CtrlType *ctrl, GraphType *graph) { idxtype clevel; GraphType *cgraph; IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->CoarsenTmr)); cgraph = graph; /* The following is ahack to allow the multiple bisections to go through with correct coarsening */ if (ctrl->CType > 20) { clevel = 1; ctrl->CType -= 20; } else clevel = 0; do { IFSET(ctrl->dbglvl, DBG_COARSEN, mprintf("%6D %7D %7D [%D] [%D %D]\n", cgraph->nvtxs, cgraph->nedges/2, idxsum(cgraph->nvtxs, cgraph->adjwgtsum, 1)/2, ctrl->CoarsenTo, ctrl->maxvwgt, (cgraph->vwgt ? idxsum(cgraph->nvtxs, cgraph->vwgt, 1) : cgraph->nvtxs))); if (cgraph->adjwgt) { switch (ctrl->CType) { case MTYPE_RM: Match_RM(ctrl, cgraph); break; case MTYPE_HEM: if (clevel < 1 || cgraph->nedges == 0) Match_RM(ctrl, cgraph); else Match_HEM(ctrl, cgraph); break; case MTYPE_SHEM: if (clevel < 1 || cgraph->nedges == 0) Match_RM(ctrl, cgraph); else Match_SHEM(ctrl, cgraph); break; case MTYPE_SHEMKWAY: if (cgraph->nedges == 0) Match_RM(ctrl, cgraph); else Match_SHEM(ctrl, cgraph); break; default: errexit("Unknown CType: %d\n", ctrl->CType); } } else { Match_RM_NVW(ctrl, cgraph); } cgraph = cgraph->coarser; clevel++; } while (cgraph->nvtxs > ctrl->CoarsenTo && cgraph->nvtxs < COARSEN_FRACTION2*cgraph->finer->nvtxs && cgraph->nedges > cgraph->nvtxs/2); IFSET(ctrl->dbglvl, DBG_COARSEN, mprintf("%6D %7D %7D [%D] [%D %D]\n", cgraph->nvtxs, cgraph->nedges/2, idxsum(cgraph->nvtxs, cgraph->adjwgtsum, 1)/2, ctrl->CoarsenTo, ctrl->maxvwgt, (cgraph->vwgt ? idxsum(cgraph->nvtxs, cgraph->vwgt, 1) : cgraph->nvtxs))); IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->CoarsenTmr)); return cgraph; } PyMetis-0.90/src/metis/compress.c0000640000175000017500000001646410662171744016576 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * compress.c * * This file contains code for compressing nodes with identical adjacency * structure and for prunning dense columns * * Started 9/17/97 * George */ #include /************************************************************************* * This function compresses a graph by merging identical vertices * The compression should lead to at least 10% reduction. **************************************************************************/ void CompressGraph(CtrlType *ctrl, GraphType *graph, idxtype nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *cptr, idxtype *cind) { idxtype i, ii, iii, j, jj, k, l, cnvtxs, cnedges; idxtype *cxadj, *cadjncy, *cvwgt, *mark, *map; KeyValueType *keys; mark = idxsmalloc(nvtxs, -1, "CompressGraph: mark"); map = idxsmalloc(nvtxs, -1, "CompressGraph: map"); keys = (KeyValueType *)gk_malloc(nvtxs*sizeof(KeyValueType), "CompressGraph: keys"); /* Compute a key for each adjacency list */ for (i=0; i= COMPRESSION_FRACTION*nvtxs) { graph->nvtxs = nvtxs; graph->nedges = xadj[nvtxs]; graph->ncon = 1; graph->xadj = xadj; graph->free_xadj = 0; graph->adjncy = adjncy; graph->free_adjncy = 0; graph->vwgt = idxmalloc(nvtxs, "CompressGraph: vwgt"); graph->adjwgtsum = idxmalloc(nvtxs, "CompressGraph: adjwgtsum"); graph->cmap = idxmalloc(nvtxs, "CompressGraph: cmap"); graph->adjwgt = idxmalloc(graph->nedges, "CompressGraph: adjwgt"); idxset(nvtxs, 1, graph->vwgt); idxset(graph->nedges, 1, graph->adjwgt); for (i=0; iadjwgtsum[i] = xadj[i+1]-xadj[i]; graph->label = idxmalloc(nvtxs, "CompressGraph: label"); for (i=0; ilabel[i] = i; } else { /* Ok, form the compressed graph */ cnedges = 0; for (i=0; ixadj = idxmalloc(cnvtxs+1, "CompressGraph: xadj"); cvwgt = graph->vwgt = idxmalloc(cnvtxs, "CompressGraph: vwgt"); graph->adjwgtsum = idxmalloc(cnvtxs, "CompressGraph: adjwgtsum"); graph->cmap = idxmalloc(cnvtxs, "CompressGraph: cmap"); cadjncy = graph->adjncy = idxmalloc(cnedges, "CompressGraph: adjncy"); graph->adjwgt = idxmalloc(cnedges, "CompressGraph: adjwgt"); /* Now go and compress the graph */ idxset(nvtxs, -1, mark); l = cxadj[0] = 0; for (i=0; invtxs = cnvtxs; graph->nedges = l; graph->ncon = 1; idxset(graph->nedges, 1, graph->adjwgt); for (i=0; iadjwgtsum[i] = cxadj[i+1]-cxadj[i]; graph->label = idxmalloc(cnvtxs, "CompressGraph: label"); for (i=0; ilabel[i] = i; } gk_free((void **)&keys, &map, &mark, LTERM); } /************************************************************************* * This function prunes all the vertices in a graph with degree greater * than factor*average **************************************************************************/ void PruneGraph(CtrlType *ctrl, GraphType *graph, idxtype nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *iperm, float factor) { idxtype i, j, k, l, nlarge, pnvtxs, pnedges; idxtype *pxadj, *padjncy, *padjwgt; idxtype *perm; perm = idxmalloc(nvtxs, "PruneGraph: perm"); factor = factor*xadj[nvtxs]/nvtxs; pnvtxs = pnedges = nlarge = 0; for (i=0; invtxs = nvtxs; graph->nedges = xadj[nvtxs]; graph->ncon = 1; graph->xadj = xadj; graph->free_xadj = 0; graph->adjncy = adjncy; graph->free_adjncy = 0; graph->vwgt = idxmalloc(nvtxs, "PruneGraph: vwgt"); graph->adjwgtsum = idxmalloc(nvtxs, "PruneGraph: adjwgtsum"); graph->cmap = idxmalloc(nvtxs, "PruneGraph: cmap"); graph->adjwgt = idxmalloc(graph->nedges, "PruneGraph: adjwgt"); idxset(nvtxs, 1, graph->vwgt); idxset(graph->nedges, 1, graph->adjwgt); for (i=0; iadjwgtsum[i] = xadj[i+1]-xadj[i]; graph->label = idxmalloc(nvtxs, "CompressGraph: label"); for (i=0; ilabel[i] = i; } else { /* Prune the graph */ /* Allocate memory for the prunned graph*/ pxadj = graph->xadj = idxmalloc(pnvtxs+1, "PruneGraph: xadj"); graph->vwgt = idxmalloc(pnvtxs, "PruneGraph: vwgt"); graph->adjwgtsum = idxmalloc(pnvtxs, "PruneGraph: adjwgtsum"); graph->cmap = idxmalloc(pnvtxs, "PruneGraph: cmap"); padjncy = graph->adjncy = idxmalloc(pnedges, "PruneGraph: adjncy"); graph->adjwgt = idxmalloc(pnedges, "PruneGraph: adjwgt"); pxadj[0] = pnedges = l = 0; for (i=0; invtxs = pnvtxs; graph->nedges = pnedges; graph->ncon = 1; idxset(pnvtxs, 1, graph->vwgt); idxset(pnedges, 1, graph->adjwgt); for (i=0; iadjwgtsum[i] = pxadj[i+1]-pxadj[i]; graph->label = idxmalloc(pnvtxs, "CompressGraph: label"); for (i=0; ilabel[i] = i; } gk_free((void **)&perm, LTERM); } PyMetis-0.90/src/metis/debug.c0000640000175000017500000001660210662171744016023 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * debug.c * * This file contains code that performs self debuging * * Started 7/24/97 * George * */ #include /************************************************************************* * This function computes the cut given the graph and a where vector **************************************************************************/ idxtype ComputeCut(GraphType *graph, idxtype *where) { idxtype i, j, cut; if (graph->adjwgt == NULL) { for (cut=0, i=0; invtxs; i++) { for (j=graph->xadj[i]; jxadj[i+1]; j++) if (where[i] != where[graph->adjncy[j]]) cut++; } } else { for (cut=0, i=0; invtxs; i++) { for (j=graph->xadj[i]; jxadj[i+1]; j++) if (where[i] != where[graph->adjncy[j]]) cut += graph->adjwgt[j]; } } return cut/2; } /************************************************************************* * This function computes the cut given the graph and a where vector **************************************************************************/ idxtype ComputeMaxCut(GraphType *graph, idxtype nparts, idxtype *where) { idxtype i, j, maxcut; idxtype *cuts; cuts = idxsmalloc(nparts, 0, "ComputeMaxCut: cuts"); if (graph->adjwgt == NULL) { for (i=0; invtxs; i++) { for (j=graph->xadj[i]; jxadj[i+1]; j++) if (where[i] != where[graph->adjncy[j]]) cuts[where[i]]++; } } else { for (i=0; invtxs; i++) { for (j=graph->xadj[i]; jxadj[i+1]; j++) if (where[i] != where[graph->adjncy[j]]) cuts[where[i]] += graph->adjwgt[j]; } } maxcut = cuts[idxargmax(nparts, cuts)]; mprintf("%D => %D\n", idxargmax(nparts, cuts), maxcut); gk_free((void **)&cuts, LTERM); return maxcut; } /************************************************************************* * This function checks whether or not the boundary information is correct **************************************************************************/ idxtype CheckBnd(GraphType *graph) { idxtype i, j, nvtxs, nbnd; idxtype *xadj, *adjncy, *where, *bndptr, *bndind; nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; where = graph->where; bndptr = graph->bndptr; bndind = graph->bndind; for (nbnd=0, i=0; inbnd, ("%d %d\n", nbnd, graph->nbnd)); return 1; } /************************************************************************* * This function checks whether or not the boundary information is correct **************************************************************************/ idxtype CheckBnd2(GraphType *graph) { idxtype i, j, nvtxs, nbnd, id, ed; idxtype *xadj, *adjncy, *where, *bndptr, *bndind; nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; where = graph->where; bndptr = graph->bndptr; bndind = graph->bndind; for (nbnd=0, i=0; iadjwgt[j]; else id += graph->adjwgt[j]; } if (ed - id >= 0 && xadj[i] < xadj[i+1]) { nbnd++; ASSERTP(bndptr[i] != -1, ("%d %d %d\n", i, id, ed)); ASSERT(bndind[bndptr[i]] == i); } } ASSERTP(nbnd == graph->nbnd, ("%d %d\n", nbnd, graph->nbnd)); return 1; } /************************************************************************* * This function checks whether or not the boundary information is correct **************************************************************************/ idxtype CheckNodeBnd(GraphType *graph, idxtype onbnd) { idxtype i, j, nvtxs, nbnd; idxtype *xadj, *adjncy, *where, *bndptr, *bndind; nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; where = graph->where; bndptr = graph->bndptr; bndind = graph->bndind; for (nbnd=0, i=0; indegrees; i++) { for (j=i+1; jndegrees; j++) ASSERTP(rinfo->edegrees[i].pid != rinfo->edegrees[j].pid, ("%d %d %d %d\n", i, j, rinfo->edegrees[i].pid, rinfo->edegrees[j].pid)); } return 1; } /************************************************************************* * This function checks the correctness of the NodeFM data structures **************************************************************************/ idxtype CheckNodePartitionParams(GraphType *graph) { idxtype i, j, k, l, nvtxs, me, other; idxtype *xadj, *adjncy, *adjwgt, *vwgt, *where; idxtype edegrees[2], pwgts[3]; nvtxs = graph->nvtxs; xadj = graph->xadj; vwgt = graph->vwgt; adjncy = graph->adjncy; adjwgt = graph->adjwgt; where = graph->where; /*------------------------------------------------------------ / Compute now the separator external degrees /------------------------------------------------------------*/ pwgts[0] = pwgts[1] = pwgts[2] = 0; for (i=0; inrinfo[i].edegrees[0] || edegrees[1] != graph->nrinfo[i].edegrees[1]) { mprintf("Something wrong with edegrees: %D %D %D %D %D\n", i, edegrees[0], edegrees[1], graph->nrinfo[i].edegrees[0], graph->nrinfo[i].edegrees[1]); return 0; } } } if (pwgts[0] != graph->pwgts[0] || pwgts[1] != graph->pwgts[1] || pwgts[2] != graph->pwgts[2]) mprintf("Something wrong with part-weights: %D %D %D %D %D %D\n", pwgts[0], pwgts[1], pwgts[2], graph->pwgts[0], graph->pwgts[1], graph->pwgts[2]); return 1; } /************************************************************************* * This function checks if the separator is indeed a separator **************************************************************************/ idxtype IsSeparable(GraphType *graph) { idxtype i, j, nvtxs, other; idxtype *xadj, *adjncy, *where; nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; where = graph->where; for (i=0; i /************************************************************************* * This function computes how much memory will be required by the various * routines in METIS **************************************************************************/ void METIS_EstimateMemory(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *numflag, idxtype *optype, idxtype *nbytes) { idxtype i, j, k, nedges, nlevels; float vfraction, efraction, vmult, emult; idxtype coresize, gdata, rdata; if (*numflag == 1) Change2CNumbering(*nvtxs, xadj, adjncy); nedges = xadj[*nvtxs]; InitRandom(-1); EstimateCFraction(*nvtxs, xadj, adjncy, &vfraction, &efraction); /* Estimate the amount of memory for coresize */ if (*optype == 2) coresize = nedges; else coresize = 0; coresize += nedges + 11*(*nvtxs) + 4*1024 + 2*(NEG_GAINSPAN+PLUS_GAINSPAN+1)*(sizeof(ListNodeType *)/sizeof(idxtype)); coresize += 2*(*nvtxs); /* add some more fore other vectors */ gdata = nedges; /* Agk_fsume that the user does not pass weights */ nlevels = (int)(log(100.0/(*nvtxs))/log(vfraction) + .5); vmult = 0.5 + (1.0 - pow(vfraction, nlevels))/(1.0 - vfraction); emult = 1.0 + (1.0 - pow(efraction, nlevels+1))/(1.0 - efraction); gdata += vmult*4*(*nvtxs) + emult*2*nedges; if ((vmult-1.0)*4*(*nvtxs) + (emult-1.0)*2*nedges < 5*(*nvtxs)) rdata = 0; else rdata = 5*(*nvtxs); *nbytes = sizeof(idxtype)*(coresize+gdata+rdata+(*nvtxs)); if (*numflag == 1) Change2FNumbering2(*nvtxs, xadj, adjncy); } /************************************************************************* * This function finds a matching using the HEM heuristic **************************************************************************/ void EstimateCFraction(idxtype nvtxs, idxtype *xadj, idxtype *adjncy, float *vfraction, float *efraction) { idxtype i, ii, j, cnvtxs, cnedges, maxidx; idxtype *match, *cmap, *perm; cmap = idxmalloc(nvtxs, "cmap"); match = idxsmalloc(nvtxs, UNMATCHED, "match"); perm = idxmalloc(nvtxs, "perm"); RandomPermute(nvtxs, perm, 1); cnvtxs = 0; for (ii=0; ii /************************************************************************* * This function performs an edge-based FM refinement **************************************************************************/ void FM_2WayEdgeRefine(CtrlType *ctrl, GraphType *graph, idxtype *tpwgts, idxtype npasses) { idxtype i, ii, j, k, kwgt, nvtxs, nbnd, nswaps, from, to, pass, me, limit, tmp; idxtype *xadj, *vwgt, *adjncy, *adjwgt, *where, *id, *ed, *bndptr, *bndind, *pwgts; idxtype *moved, *swaps, *perm; PQueueType parts[2]; idxtype higain, oldgain, mincut, mindiff, origdiff, initcut, newcut, mincutorder, avgvwgt; nvtxs = graph->nvtxs; xadj = graph->xadj; vwgt = graph->vwgt; adjncy = graph->adjncy; adjwgt = graph->adjwgt; where = graph->where; id = graph->id; ed = graph->ed; pwgts = graph->pwgts; bndptr = graph->bndptr; bndind = graph->bndind; moved = idxwspacemalloc(ctrl, nvtxs); swaps = idxwspacemalloc(ctrl, nvtxs); perm = idxwspacemalloc(ctrl, nvtxs); limit = amin(amax(0.01*nvtxs, 15), 100); avgvwgt = amin((pwgts[0]+pwgts[1])/20, 2*(pwgts[0]+pwgts[1])/nvtxs); tmp = graph->adjwgtsum[idxargmax(nvtxs, graph->adjwgtsum)]; PQueueInit(ctrl, &parts[0], nvtxs, tmp); PQueueInit(ctrl, &parts[1], nvtxs, tmp); IFSET(ctrl->dbglvl, DBG_REFINE, mprintf("Partitions: [%6D %6D] T[%6D %6D], Nv-Nb[%6D %6D]. ICut: %6D\n", pwgts[0], pwgts[1], tpwgts[0], tpwgts[1], graph->nvtxs, graph->nbnd, graph->mincut)); origdiff = idxtype_abs(tpwgts[0]-pwgts[0]); idxset(nvtxs, -1, moved); for (pass=0; passmincut; mindiff = idxtype_abs(tpwgts[0]-pwgts[0]); ASSERT(ComputeCut(graph, where) == graph->mincut); ASSERT(CheckBnd(graph)); /* Insert boundary nodes in the priority queues */ nbnd = graph->nbnd; RandomPermute(nbnd, perm, 1); for (ii=0; ii 0 || id[bndind[i]] == 0); ASSERT(bndptr[bndind[i]] != -1); PQueueInsert(&parts[where[bndind[i]]], bndind[i], ed[bndind[i]]-id[bndind[i]]); } for (nswaps=0; nswaps limit) { /* We hit the limit, undo last move */ newcut += (ed[higain]-id[higain]); INC_DEC(pwgts[from], pwgts[to], vwgt[higain]); break; } where[higain] = to; moved[higain] = nswaps; swaps[nswaps] = higain; IFSET(ctrl->dbglvl, DBG_MOVEINFO, mprintf("Moved %6D from %D. [%3D %3D] %5D [%4D %4D]\n", higain, from, ed[higain]-id[higain], vwgt[higain], newcut, pwgts[0], pwgts[1])); /************************************************************** * Update the id[i]/ed[i] values of the affected nodes ***************************************************************/ SWAP(id[higain], ed[higain], tmp); if (ed[higain] == 0 && xadj[higain] < xadj[higain+1]) BNDDelete(nbnd, bndind, bndptr, higain); for (j=xadj[higain]; j 0) { /* It will now become a boundary vertex */ BNDInsert(nbnd, bndind, bndptr, k); if (moved[k] == -1) PQueueInsert(&parts[where[k]], k, ed[k]-id[k]); } } } } /**************************************************************** * Roll back computations *****************************************************************/ for (i=0; imincutorder; nswaps--) { higain = swaps[nswaps]; to = where[higain] = (where[higain]+1)%2; SWAP(id[higain], ed[higain], tmp); if (ed[higain] == 0 && bndptr[higain] != -1 && xadj[higain] < xadj[higain+1]) BNDDelete(nbnd, bndind, bndptr, higain); else if (ed[higain] > 0 && bndptr[higain] == -1) BNDInsert(nbnd, bndind, bndptr, higain); INC_DEC(pwgts[to], pwgts[(to+1)%2], vwgt[higain]); for (j=xadj[higain]; j 0) BNDInsert(nbnd, bndind, bndptr, k); } } IFSET(ctrl->dbglvl, DBG_REFINE, mprintf("\tMinimum cut: %6D at %5D, PWGTS: [%6D %6D], NBND: %6D\n", mincut, mincutorder, pwgts[0], pwgts[1], nbnd)); graph->mincut = mincut; graph->nbnd = nbnd; if (mincutorder == -1 || mincut == initcut) break; } PQueueFree(ctrl, &parts[0]); PQueueFree(ctrl, &parts[1]); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); } PyMetis-0.90/src/metis/fortran.c0000640000175000017500000000715110662171744016407 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * fortran.c * * This file contains code for the fortran to C interface * * Started 8/19/97 * George * */ #include /************************************************************************* * This function changes the numbering to start from 0 instead of 1 **************************************************************************/ void Change2CNumbering(idxtype nvtxs, idxtype *xadj, idxtype *adjncy) { idxtype i, nedges; for (i=0; i<=nvtxs; i++) xadj[i]--; nedges = xadj[nvtxs]; for (i=0; i void METIS_PARTGRAPHRECURSIVE(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, idxtype *options, idxtype *edgecut, idxtype *part) { METIS_PartGraphRecursive(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, options, edgecut, part); } void metis_partgraphrecursive(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, idxtype *options, idxtype *edgecut, idxtype *part) { METIS_PartGraphRecursive(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, options, edgecut, part); } void metis_partgraphrecursive_(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, idxtype *options, idxtype *edgecut, idxtype *part) { METIS_PartGraphRecursive(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, options, edgecut, part); } void metis_partgraphrecursive__(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, idxtype *options, idxtype *edgecut, idxtype *part) { METIS_PartGraphRecursive(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, options, edgecut, part); } void METIS_WPARTGRAPHRECURSIVE(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *tpwgts, idxtype *options, idxtype *edgecut, idxtype *part) { METIS_WPartGraphRecursive(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, tpwgts, options, edgecut, part); } void metis_wpartgraphrecursive(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *tpwgts, idxtype *options, idxtype *edgecut, idxtype *part) { METIS_WPartGraphRecursive(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, tpwgts, options, edgecut, part); } void metis_wpartgraphrecursive_(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *tpwgts, idxtype *options, idxtype *edgecut, idxtype *part) { METIS_WPartGraphRecursive(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, tpwgts, options, edgecut, part); } void metis_wpartgraphrecursive__(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *tpwgts, idxtype *options, idxtype *edgecut, idxtype *part) { METIS_WPartGraphRecursive(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, tpwgts, options, edgecut, part); } void METIS_PARTGRAPHKWAY(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, idxtype *options, idxtype *edgecut, idxtype *part) { METIS_PartGraphKway(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, options, edgecut, part); } void metis_partgraphkway(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, idxtype *options, idxtype *edgecut, idxtype *part) { METIS_PartGraphKway(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, options, edgecut, part); } void metis_partgraphkway_(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, idxtype *options, idxtype *edgecut, idxtype *part) { METIS_PartGraphKway(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, options, edgecut, part); } void metis_partgraphkway__(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, idxtype *options, idxtype *edgecut, idxtype *part) { METIS_PartGraphKway(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, options, edgecut, part); } void METIS_WPARTGRAPHKWAY(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *tpwgts, idxtype *options, idxtype *edgecut, idxtype *part) { METIS_WPartGraphKway(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, tpwgts, options, edgecut, part); } void metis_wpartgraphkway(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *tpwgts, idxtype *options, idxtype *edgecut, idxtype *part) { METIS_WPartGraphKway(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, tpwgts, options, edgecut, part); } void metis_wpartgraphkway_(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *tpwgts, idxtype *options, idxtype *edgecut, idxtype *part) { METIS_WPartGraphKway(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, tpwgts, options, edgecut, part); } void metis_wpartgraphkway__(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *tpwgts, idxtype *options, idxtype *edgecut, idxtype *part) { METIS_WPartGraphKway(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, tpwgts, options, edgecut, part); } void METIS_EDGEND(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *numflag, idxtype *options, idxtype *perm, idxtype *iperm) { METIS_EdgeND(nvtxs, xadj, adjncy, numflag, options, perm, iperm); } void metis_edgend(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *numflag, idxtype *options, idxtype *perm, idxtype *iperm) { METIS_EdgeND(nvtxs, xadj, adjncy, numflag, options, perm, iperm); } void metis_edgend_(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *numflag, idxtype *options, idxtype *perm, idxtype *iperm) { METIS_EdgeND(nvtxs, xadj, adjncy, numflag, options, perm, iperm); } void metis_edgend__(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *numflag, idxtype *options, idxtype *perm, idxtype *iperm) { METIS_EdgeND(nvtxs, xadj, adjncy, numflag, options, perm, iperm); } void METIS_NODEND(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *numflag, idxtype *options, idxtype *perm, idxtype *iperm) { METIS_NodeND(nvtxs, xadj, adjncy, numflag, options, perm, iperm); } void metis_nodend(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *numflag, idxtype *options, idxtype *perm, idxtype *iperm) { METIS_NodeND(nvtxs, xadj, adjncy, numflag, options, perm, iperm); } void metis_nodend_(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *numflag, idxtype *options, idxtype *perm, idxtype *iperm) { METIS_NodeND(nvtxs, xadj, adjncy, numflag, options, perm, iperm); } void metis_nodend__(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *numflag, idxtype *options, idxtype *perm, idxtype *iperm) { METIS_NodeND(nvtxs, xadj, adjncy, numflag, options, perm, iperm); } void METIS_NODEWND(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *numflag, idxtype *options, idxtype *perm, idxtype *iperm) { METIS_NodeWND(nvtxs, xadj, adjncy, vwgt, numflag, options, perm, iperm); } void metis_nodewnd(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *numflag, idxtype *options, idxtype *perm, idxtype *iperm) { METIS_NodeWND(nvtxs, xadj, adjncy, vwgt, numflag, options, perm, iperm); } void metis_nodewnd_(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *numflag, idxtype *options, idxtype *perm, idxtype *iperm) { METIS_NodeWND(nvtxs, xadj, adjncy, vwgt, numflag, options, perm, iperm); } void metis_nodewnd__(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *numflag, idxtype *options, idxtype *perm, idxtype *iperm) { METIS_NodeWND(nvtxs, xadj, adjncy, vwgt, numflag, options, perm, iperm); } #ifdef XXXX void METIS_PARTMESHNODAL(idxtype *ne, idxtype *nn, idxtype *elmnts, idxtype *etype, idxtype *numflag, idxtype *nparts, idxtype *edgecut, idxtype *epart, idxtype *npart) { METIS_PartMeshNodal(ne, nn, elmnts, etype, numflag, nparts, edgecut, epart, npart); } void metis_partmeshnodal(idxtype *ne, idxtype *nn, idxtype *elmnts, idxtype *etype, idxtype *numflag, idxtype *nparts, idxtype *edgecut, idxtype *epart, idxtype *npart) { METIS_PartMeshNodal(ne, nn, elmnts, etype, numflag, nparts, edgecut, epart, npart); } void metis_partmeshnodal_(idxtype *ne, idxtype *nn, idxtype *elmnts, idxtype *etype, idxtype *numflag, idxtype *nparts, idxtype *edgecut, idxtype *epart, idxtype *npart) { METIS_PartMeshNodal(ne, nn, elmnts, etype, numflag, nparts, edgecut, epart, npart); } void metis_partmeshnodal__(idxtype *ne, idxtype *nn, idxtype *elmnts, idxtype *etype, idxtype *numflag, idxtype *nparts, idxtype *edgecut, idxtype *epart, idxtype *npart) { METIS_PartMeshNodal(ne, nn, elmnts, etype, numflag, nparts, edgecut, epart, npart); } void METIS_PARTMESHDUAL(idxtype *ne, idxtype *nn, idxtype *elmnts, idxtype *etype, idxtype *numflag, idxtype *nparts, idxtype *edgecut, idxtype *epart, idxtype *npart) { METIS_PartMeshDual(ne, nn, elmnts, etype, numflag, nparts, edgecut, epart, npart, 0, NULL); } void metis_partmeshdual(idxtype *ne, idxtype *nn, idxtype *elmnts, idxtype *etype, idxtype *numflag, idxtype *nparts, idxtype *edgecut, idxtype *epart, idxtype *npart) { METIS_PartMeshDual(ne, nn, elmnts, etype, numflag, nparts, edgecut, epart, npart, 0, NULL); } void metis_partmeshdual_(idxtype *ne, idxtype *nn, idxtype *elmnts, idxtype *etype, idxtype *numflag, idxtype *nparts, idxtype *edgecut, idxtype *epart, idxtype *npart) { METIS_PartMeshDual(ne, nn, elmnts, etype, numflag, nparts, edgecut, epart, npart, 0, NULL); } void metis_partmeshdual__(idxtype *ne, idxtype *nn, idxtype *elmnts, idxtype *etype, idxtype *numflag, idxtype *nparts, idxtype *edgecut, idxtype *epart, idxtype *npart) { METIS_PartMeshDual(ne, nn, elmnts, etype, numflag, nparts, edgecut, epart, npart, 0, NULL); } void METIS_MESHTONODAL(idxtype *ne, idxtype *nn, idxtype *elmnts, idxtype *etype, idxtype *numflag, idxtype *dxadj, idxtype *dadjncy) { METIS_MeshToNodal(ne, nn, elmnts, etype, numflag, dxadj, dadjncy); } void metis_meshtonodal(idxtype *ne, idxtype *nn, idxtype *elmnts, idxtype *etype, idxtype *numflag, idxtype *dxadj, idxtype *dadjncy) { METIS_MeshToNodal(ne, nn, elmnts, etype, numflag, dxadj, dadjncy); } void metis_meshtonodal_(idxtype *ne, idxtype *nn, idxtype *elmnts, idxtype *etype, idxtype *numflag, idxtype *dxadj, idxtype *dadjncy) { METIS_MeshToNodal(ne, nn, elmnts, etype, numflag, dxadj, dadjncy); } void metis_meshtonodal__(idxtype *ne, idxtype *nn, idxtype *elmnts, idxtype *etype, idxtype *numflag, idxtype *dxadj, idxtype *dadjncy) { METIS_MeshToNodal(ne, nn, elmnts, etype, numflag, dxadj, dadjncy); } void METIS_MESHTODUAL(idxtype *ne, idxtype *nn, idxtype *elmnts, idxtype *etype, idxtype *numflag, idxtype *dxadj, idxtype *dadjncy) { METIS_MeshToDual(ne, nn, elmnts, etype, numflag, dxadj, dadjncy); } void metis_meshtodual(idxtype *ne, idxtype *nn, idxtype *elmnts, idxtype *etype, idxtype *numflag, idxtype *dxadj, idxtype *dadjncy) { METIS_MeshToDual(ne, nn, elmnts, etype, numflag, dxadj, dadjncy); } void metis_meshtodual_(idxtype *ne, idxtype *nn, idxtype *elmnts, idxtype *etype, idxtype *numflag, idxtype *dxadj, idxtype *dadjncy) { METIS_MeshToDual(ne, nn, elmnts, etype, numflag, dxadj, dadjncy); } void metis_meshtodual__(idxtype *ne, idxtype *nn, idxtype *elmnts, idxtype *etype, idxtype *numflag, idxtype *dxadj, idxtype *dadjncy) { METIS_MeshToDual(ne, nn, elmnts, etype, numflag, dxadj, dadjncy); } #endif void METIS_ESTIMATEMEMORY(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *numflag, idxtype *optype, idxtype *nbytes) { METIS_EstimateMemory(nvtxs, xadj, adjncy, numflag, optype, nbytes); } void metis_estimatememory(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *numflag, idxtype *optype, idxtype *nbytes) { METIS_EstimateMemory(nvtxs, xadj, adjncy, numflag, optype, nbytes); } void metis_estimatememory_(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *numflag, idxtype *optype, idxtype *nbytes) { METIS_EstimateMemory(nvtxs, xadj, adjncy, numflag, optype, nbytes); } void metis_estimatememory__(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *numflag, idxtype *optype, idxtype *nbytes) { METIS_EstimateMemory(nvtxs, xadj, adjncy, numflag, optype, nbytes); } void METIS_MCPARTGRAPHRECURSIVE(idxtype *nvtxs, idxtype *ncon, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, idxtype *options, idxtype *edgecut, idxtype *part) { METIS_mCPartGraphRecursive(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, options, edgecut, part); } void metis_mcpartgraphrecursive(idxtype *nvtxs, idxtype *ncon, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, idxtype *options, idxtype *edgecut, idxtype *part) { METIS_mCPartGraphRecursive(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, options, edgecut, part); } void metis_mcpartgraphrecursive_(idxtype *nvtxs, idxtype *ncon, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, idxtype *options, idxtype *edgecut, idxtype *part) { METIS_mCPartGraphRecursive(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, options, edgecut, part); } void metis_mcpartgraphrecursive__(idxtype *nvtxs, idxtype *ncon, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, idxtype *options, idxtype *edgecut, idxtype *part) { METIS_mCPartGraphRecursive(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, options, edgecut, part); } void METIS_MCPARTGRAPHKWAY(idxtype *nvtxs, idxtype *ncon, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *rubvec, idxtype *options, idxtype *edgecut, idxtype *part) { METIS_mCPartGraphKway(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, rubvec, options, edgecut, part); } void metis_mcpartgraphkway(idxtype *nvtxs, idxtype *ncon, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *rubvec, idxtype *options, idxtype *edgecut, idxtype *part) { METIS_mCPartGraphKway(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, rubvec, options, edgecut, part); } void metis_mcpartgraphkway_(idxtype *nvtxs, idxtype *ncon, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *rubvec, idxtype *options, idxtype *edgecut, idxtype *part) { METIS_mCPartGraphKway(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, rubvec, options, edgecut, part); } void metis_mcpartgraphkway__(idxtype *nvtxs, idxtype *ncon, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *rubvec, idxtype *options, idxtype *edgecut, idxtype *part) { METIS_mCPartGraphKway(nvtxs, ncon, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, rubvec, options, edgecut, part); } void METIS_PARTGRAPHVKWAY(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *vsize, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, idxtype *options, idxtype *volume, idxtype *part) { METIS_PartGraphVKway(nvtxs, xadj, adjncy, vwgt, vsize, wgtflag, numflag, nparts, options, volume, part); } void metis_partgraphvkaway(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *vsize, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, idxtype *options, idxtype *volume, idxtype *part) { METIS_PartGraphVKway(nvtxs, xadj, adjncy, vwgt, vsize, wgtflag, numflag, nparts, options, volume, part); } void metis_partgraphvkaway_(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *vsize, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, idxtype *options, idxtype *volume, idxtype *part) { METIS_PartGraphVKway(nvtxs, xadj, adjncy, vwgt, vsize, wgtflag, numflag, nparts, options, volume, part); } void metis_partgraphvkaway__(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *vsize, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, idxtype *options, idxtype *volume, idxtype *part) { METIS_PartGraphVKway(nvtxs, xadj, adjncy, vwgt, vsize, wgtflag, numflag, nparts, options, volume, part); } void METIS_WPARTGRAPHVKWAY(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *vsize, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *tpwgts, idxtype *options, idxtype *volume, idxtype *part) { METIS_WPartGraphVKway(nvtxs, xadj, adjncy, vwgt, vsize, wgtflag, numflag, nparts, tpwgts, options, volume, part); } void metis_wpartgraphvkaway(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *vsize, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *tpwgts, idxtype *options, idxtype *volume, idxtype *part) { METIS_WPartGraphVKway(nvtxs, xadj, adjncy, vwgt, vsize, wgtflag, numflag, nparts, tpwgts, options, volume, part); } void metis_wpartgraphvkaway_(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *vsize, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *tpwgts, idxtype *options, idxtype *volume, idxtype *part) { METIS_WPartGraphVKway(nvtxs, xadj, adjncy, vwgt, vsize, wgtflag, numflag, nparts, tpwgts, options, volume, part); } void metis_wpartgraphvkaway__(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *vsize, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *tpwgts, idxtype *options, idxtype *volume, idxtype *part) { METIS_WPartGraphVKway(nvtxs, xadj, adjncy, vwgt, vsize, wgtflag, numflag, nparts, tpwgts, options, volume, part); } PyMetis-0.90/src/metis/graph.c0000640000175000017500000003034410662171744016035 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * graph.c * * This file contains functions that deal with setting up the graphs * for METIS. * * Started 7/25/97 * George * */ #include /************************************************************************* * This function sets up the graph from the user input **************************************************************************/ void SetUpGraph(GraphType *graph, idxtype OpType, idxtype nvtxs, idxtype ncon, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype wgtflag) { idxtype i, j, k, sum; float *nvwgt; idxtype tvwgt[MAXNCON]; InitGraph(graph); graph->nvtxs = nvtxs; graph->nedges = xadj[nvtxs]; graph->ncon = ncon; graph->xadj = xadj; graph->free_xadj = 0; graph->adjncy = adjncy; graph->free_adjncy = 0; /* setup the vertex weights */ if (ncon == 1) { /* We are in the non mC mode */ if ((wgtflag&2) == 0) { vwgt = graph->vwgt = idxsmalloc(nvtxs, 1, "SetUpGraph: vwgt"); } else { graph->vwgt = vwgt; graph->free_vwgt = 0; } } else { /* Set up the graph in MOC mode */ for (i=0; invwgt = gk_fmalloc(ncon*nvtxs, "SetUpGraph: nvwgt"); for (i=0; iadjwgt = idxsmalloc(graph->nedges, 1, "SetUpGraph: adjwgt"); } else { graph->adjwgt = adjwgt; graph->free_adjwgt = 0; } /* Compute the initial values of the adjwgtsum */ graph->adjwgtsum = idxmalloc(nvtxs, "SetUpGraph: adjwgtsum"); for (i=0; iadjwgtsum[i] = sum; } graph->cmap = idxmalloc(nvtxs, "SetUpGraph: cmap"); if (OpType != OP_KMETIS && OpType != OP_KVMETIS) { graph->label = idxmalloc(nvtxs, "SetUpGraph: label"); for (i=0; ilabel[i] = i; } } /************************************************************************* * This function sets up the graph from the user input. The difference * from the previous routine is that the vertex weights came already in * a normalized fashion. **************************************************************************/ void SetUpGraph2(GraphType *graph, idxtype nvtxs, idxtype ncon, idxtype *xadj, idxtype *adjncy, float *nvwgt, idxtype *adjwgt) { idxtype i, j, sum; InitGraph(graph); graph->nvtxs = nvtxs; graph->nedges = xadj[nvtxs]; graph->ncon = ncon; graph->xadj = xadj; graph->free_xadj = 0; graph->adjncy = adjncy; graph->free_adjncy = 0; graph->adjwgt = adjwgt; graph->free_adjwgt = 0; graph->nvwgt = gk_fmalloc(nvtxs*ncon, "SetUpGraph2: graph->nvwgt"); gk_fcopy(nvtxs*ncon, nvwgt, graph->nvwgt); /* Compute the initial values of the adjwgtsum */ graph->adjwgtsum = idxmalloc(nvtxs, "SetUpGraph2: adjwgtsum"); for (i=0; iadjwgtsum[i] = sum; } graph->cmap = idxmalloc(nvtxs, "SetUpGraph2: cmap"); graph->label = idxmalloc(nvtxs, "SetUpGraph: label"); for (i=0; ilabel[i] = i; } /************************************************************************* * This function sets up the graph from the user input **************************************************************************/ void VolSetUpGraph(GraphType *graph, idxtype OpType, idxtype nvtxs, idxtype ncon, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *vsize, idxtype wgtflag) { idxtype i, j, k, sum; idxtype *adjwgt; float *nvwgt; idxtype tvwgt[MAXNCON]; InitGraph(graph); graph->nvtxs = nvtxs; graph->nedges = xadj[nvtxs]; graph->ncon = ncon; graph->xadj = xadj; graph->free_xadj = 0; graph->adjncy = adjncy; graph->free_adjncy = 0; /* Setup the vwgt/vwgt */ if (ncon == 1) { /* We are in the non mC mode */ if ((wgtflag&2) == 0) { vwgt = graph->vwgt = idxsmalloc(nvtxs, 1, "VolSetUpGraph: vwgt"); } else { graph->vwgt = vwgt; graph->free_vwgt = 0; } } else { /* Set up the graph in MOC mode */ /* Create the normalized vertex weights along each constraint */ for (i=0; invwgt = gk_fmalloc(ncon*nvtxs, "SetUpGraph: nvwgt"); for (i=0; ivsize = idxsmalloc(nvtxs, 1, "VolSetUpGraph: vsize"); } else { graph->vsize = vsize; graph->free_vsize = 0; } /* Allocate memory for edge weights and initialize them to the sum of the vsize */ adjwgt = graph->adjwgt = idxmalloc(graph->nedges, "VolSetUpGraph: adjwgt"); for (i=0; iadjwgtsum = idxmalloc(nvtxs, "VolSetUpGraph: adjwgtsum"); for (i=0; iadjwgtsum[i] = sum; } graph->cmap = idxmalloc(nvtxs, "VolSetUpGraph: cmap"); if (OpType != OP_KVMETIS) { graph->label = idxmalloc(nvtxs, "SetUpGraph: label"); for (i=0; ilabel[i] = i; } } /************************************************************************* * This function randomly permutes the adjacency lists of a graph **************************************************************************/ void RandomizeGraph(GraphType *graph) { idxtype i, j, k, l, tmp, nvtxs; idxtype *xadj, *adjncy, *adjwgt; nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; adjwgt = graph->adjwgt; for (i=0; invtxs; xadj = graph->xadj; adjncy = graph->adjncy; where = graph->where; touched = idxsmalloc(nvtxs, 0, "IsConnected: touched"); queue = idxmalloc(nvtxs, "IsConnected: queue"); cptr = idxmalloc(nvtxs+1, "IsConnected: cptr"); nleft = 0; for (i=0; i 1 && report) { mprintf("The graph has %D connected components in partition %D:\t", ncmps, pid); for (i=0; ivwgt[queue[j]]; mprintf("[%5D %5D] ", cptr[i+1]-cptr[i], wgt); /* if (cptr[i+1]-cptr[i] == 1) mprintf("[%D %D] ", queue[cptr[i]], xadj[queue[cptr[i]]+1]-xadj[queue[cptr[i]]]); */ } mprintf("\n"); } gk_free((void **)&touched, &queue, &cptr, LTERM); return (ncmps == 1 ? 1 : 0); } /************************************************************************* * This function checks whether a graph is contigous or not **************************************************************************/ idxtype IsConnected(CtrlType *ctrl, GraphType *graph, idxtype report) { idxtype i, j, k, nvtxs, first, last; idxtype *xadj, *adjncy, *touched, *queue; nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; touched = idxsmalloc(nvtxs, 0, "IsConnected: touched"); queue = idxmalloc(nvtxs, "IsConnected: queue"); touched[0] = 1; queue[0] = 0; first = 0; last = 1; while (first < last) { i = queue[first++]; for (j=xadj[i]; jnvtxs; xadj = graph->xadj; adjncy = graph->adjncy; where = graph->where; touched = idxsmalloc(nvtxs, 0, "IsConnected: touched"); queue = idxmalloc(nvtxs, "IsConnected: queue"); cptr = idxmalloc(nvtxs+1, "IsConnected: cptr"); nleft = nvtxs; touched[0] = 1; queue[0] = 0; first = 0; last = 1; cptr[0] = 0; /* This actually points to queue */ ncmps = 0; while (first != nleft) { if (first == last) { /* Find another starting vertex */ cptr[++ncmps] = first; for (i=0; i 1 && report) { mprintf("%D connected components:\t", ncmps); for (i=0; i 200) mprintf("[%5D] ", cptr[i+1]-cptr[i]); } mprintf("\n"); } gk_free((void **)&touched, &queue, &cptr, LTERM); return (ncmps == 1 ? 1 : 0); } /************************************************************************* * This function returns the number of connected components in cptr,cind * The separator of the graph is used to split it and then find its components. **************************************************************************/ idxtype FindComponents(CtrlType *ctrl, GraphType *graph, idxtype *cptr, idxtype *cind) { idxtype i, j, k, nvtxs, first, last, nleft, ncmps, wgt; idxtype *xadj, *adjncy, *where, *touched, *queue; nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; where = graph->where; touched = idxsmalloc(nvtxs, 0, "IsConnected: queue"); for (i=0; inbnd; i++) touched[graph->bndind[i]] = 1; queue = cind; nleft = 0; for (i=0; i /************************************************************************* * This function computes the initial bisection of the coarsest graph **************************************************************************/ void Init2WayPartition(CtrlType *ctrl, GraphType *graph, idxtype *tpwgts, float ubfactor) { idxtype dbglvl; dbglvl = ctrl->dbglvl; IFSET(ctrl->dbglvl, DBG_REFINE, ctrl->dbglvl -= DBG_REFINE); IFSET(ctrl->dbglvl, DBG_MOVEINFO, ctrl->dbglvl -= DBG_MOVEINFO); IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->InitPartTmr)); switch (ctrl->IType) { case ITYPE_GGPKL: if (graph->nedges == 0) RandomBisection(ctrl, graph, tpwgts, ubfactor); else GrowBisection(ctrl, graph, tpwgts, ubfactor); break; case ITYPE_RANDOM: RandomBisection(ctrl, graph, tpwgts, ubfactor); break; default: errexit("Unknown initial partition type: %d\n", ctrl->IType); } IFSET(ctrl->dbglvl, DBG_IPART, mprintf("Initial Cut: %D\n", graph->mincut)); IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->InitPartTmr)); ctrl->dbglvl = dbglvl; /* IsConnectedSubdomain(ctrl, graph, 0); IsConnectedSubdomain(ctrl, graph, 1); */ } /************************************************************************* * This function computes the initial bisection of the coarsest graph **************************************************************************/ void InitSeparator(CtrlType *ctrl, GraphType *graph, float ubfactor) { idxtype dbglvl; dbglvl = ctrl->dbglvl; IFSET(ctrl->dbglvl, DBG_REFINE, ctrl->dbglvl -= DBG_REFINE); IFSET(ctrl->dbglvl, DBG_MOVEINFO, ctrl->dbglvl -= DBG_MOVEINFO); IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->InitPartTmr)); GrowBisectionNode(ctrl, graph, ubfactor); Compute2WayNodePartitionParams(ctrl, graph); IFSET(ctrl->dbglvl, DBG_IPART, mprintf("Initial Sep: %D\n", graph->mincut)); IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->InitPartTmr)); ctrl->dbglvl = dbglvl; } /************************************************************************* * This function takes a graph and produces a bisection by using a region * growing algorithm. The resulting partition is returned in * graph->where **************************************************************************/ void GrowBisection(CtrlType *ctrl, GraphType *graph, idxtype *tpwgts, float ubfactor) { idxtype i, j, k, nvtxs, drain, nleft, first, last, pwgts[2], minpwgt[2], maxpwgt[2], from, bestcut, icut, mincut, me, pass, nbfs, inbfs; idxtype *xadj, *vwgt, *adjncy, *adjwgt, *where; idxtype *queue, *touched, *gain, *bestwhere; nvtxs = graph->nvtxs; xadj = graph->xadj; vwgt = graph->vwgt; adjncy = graph->adjncy; adjwgt = graph->adjwgt; Allocate2WayPartitionMemory(ctrl, graph); where = graph->where; bestwhere = idxmalloc(nvtxs, "BisectGraph: bestwhere"); queue = idxmalloc(nvtxs, "BisectGraph: queue"); touched = idxmalloc(nvtxs, "BisectGraph: touched"); ASSERTP(tpwgts[0]+tpwgts[1] == idxsum(nvtxs, vwgt, 1), ("%d %d\n", tpwgts[0]+tpwgts[1], idxsum(nvtxs, vwgt, 1))); maxpwgt[0] = ubfactor*tpwgts[0]; maxpwgt[1] = ubfactor*tpwgts[1]; minpwgt[0] = (1.0/ubfactor)*tpwgts[0]; minpwgt[1] = (1.0/ubfactor)*tpwgts[1]; nbfs = (nvtxs <= ctrl->CoarsenTo ? SMALLNIPARTS : LARGENIPARTS); for (inbfs=0; inbfs 0 && pwgts[1]-vwgt[i] < minpwgt[1]) { drain = 1; continue; } where[i] = 0; INC_DEC(pwgts[0], pwgts[1], vwgt[i]); if (pwgts[1] <= maxpwgt[1]) break; drain = 0; for (j=xadj[i]; jnvtxs, pwgts[0], pwgts[1], graph->pwgts[0], graph->pwgts[1], graph->mincut); */ Balance2Way(ctrl, graph, tpwgts, ubfactor); /*mprintf("BPART: [%5D %5D] %5D\n", graph->pwgts[0], graph->pwgts[1], graph->mincut);*/ FM_2WayEdgeRefine(ctrl, graph, tpwgts, 4); /*mprintf("RPART: [%5D %5D] %5D\n", graph->pwgts[0], graph->pwgts[1], graph->mincut);*/ if (inbfs == 0 || bestcut > graph->mincut) { bestcut = graph->mincut; idxcopy(nvtxs, where, bestwhere); if (bestcut == 0) break; } } graph->mincut = bestcut; idxcopy(nvtxs, bestwhere, where); gk_free((void **)&bestwhere, &queue, &touched, LTERM); } /************************************************************************* * This function takes a graph and produces a bisection by using a region * growing algorithm. The resulting partition is returned in * graph->where **************************************************************************/ void GrowBisectionNode(CtrlType *ctrl, GraphType *graph, float ubfactor) { idxtype i, j, k, nvtxs, drain, nleft, first, last, pwgts[2], tpwgts[2], minpwgt[2], maxpwgt[2], from, bestcut, icut, mincut, me, pass, nbfs, inbfs; idxtype *xadj, *vwgt, *adjncy, *adjwgt, *where, *bndind; idxtype *queue, *touched, *gain, *bestwhere; nvtxs = graph->nvtxs; xadj = graph->xadj; vwgt = graph->vwgt; adjncy = graph->adjncy; adjwgt = graph->adjwgt; bestwhere = idxmalloc(nvtxs, "BisectGraph: bestwhere"); queue = idxmalloc(nvtxs, "BisectGraph: queue"); touched = idxmalloc(nvtxs, "BisectGraph: touched"); tpwgts[0] = idxsum(nvtxs, vwgt, 1); tpwgts[1] = tpwgts[0]/2; tpwgts[0] -= tpwgts[1]; maxpwgt[0] = ubfactor*tpwgts[0]; maxpwgt[1] = ubfactor*tpwgts[1]; minpwgt[0] = (1.0/ubfactor)*tpwgts[0]; minpwgt[1] = (1.0/ubfactor)*tpwgts[1]; /* Allocate refinement memory. Allocate sufficient memory for both edge and node */ graph->pwgts = idxmalloc(3, "GrowBisectionNode: pwgts"); graph->where = idxmalloc(nvtxs, "GrowBisectionNode: where"); graph->bndptr = idxmalloc(nvtxs, "GrowBisectionNode: bndptr"); graph->bndind = idxmalloc(nvtxs, "GrowBisectionNode: bndind"); graph->id = idxmalloc(nvtxs, "GrowBisectionNode: id"); graph->ed = idxmalloc(nvtxs, "GrowBisectionNode: ed"); graph->nrinfo = (NRInfoType *)gk_malloc(nvtxs*sizeof(NRInfoType), "GrowBisectionNode: nrinfo"); where = graph->where; bndind = graph->bndind; nbfs = (nvtxs <= ctrl->CoarsenTo ? SMALLNIPARTS : LARGENIPARTS) + 1; for (inbfs=0; inbfs= 1) { for (;;) { if (first == last) { /* Empty. Disconnected graph! */ if (nleft == 0 || drain) break; k = RandomInRange(nleft); for (i=0; inbnd; i++) where[bndind[i]] = 2; Compute2WayNodePartitionParams(ctrl, graph); FM_2WayNodeRefine(ctrl, graph, ubfactor, 6); /* mprintf("ISep: [%D %D %D] %D\n", graph->pwgts[0], graph->pwgts[1], graph->pwgts[2], bestcut); */ if (inbfs == 0 || bestcut > graph->mincut) { bestcut = graph->mincut; idxcopy(nvtxs, where, bestwhere); } } graph->mincut = bestcut; idxcopy(nvtxs, bestwhere, where); Compute2WayNodePartitionParams(ctrl, graph); gk_free((void **)&bestwhere, &queue, &touched, LTERM); } /************************************************************************* * This function takes a graph and produces a bisection by using a region * growing algorithm. The resulting partition is returned in * graph->where **************************************************************************/ void RandomBisection(CtrlType *ctrl, GraphType *graph, idxtype *tpwgts, float ubfactor) { idxtype i, ii, j, k, nvtxs, pwgts[2], minpwgt[2], maxpwgt[2], from, bestcut, icut, mincut, me, pass, nbfs, inbfs; idxtype *xadj, *vwgt, *adjncy, *adjwgt, *where; idxtype *perm, *bestwhere; nvtxs = graph->nvtxs; xadj = graph->xadj; vwgt = graph->vwgt; adjncy = graph->adjncy; adjwgt = graph->adjwgt; Allocate2WayPartitionMemory(ctrl, graph); where = graph->where; bestwhere = idxmalloc(nvtxs, "BisectGraph: bestwhere"); perm = idxmalloc(nvtxs, "BisectGraph: queue"); ASSERTP(tpwgts[0]+tpwgts[1] == idxsum(nvtxs, vwgt, 1), ("%d %d\n", tpwgts[0]+tpwgts[1], idxsum(nvtxs, vwgt, 1))); maxpwgt[0] = ubfactor*tpwgts[0]; maxpwgt[1] = ubfactor*tpwgts[1]; minpwgt[0] = (1.0/ubfactor)*tpwgts[0]; minpwgt[1] = (1.0/ubfactor)*tpwgts[1]; nbfs = (nvtxs <= ctrl->CoarsenTo ? SMALLNIPARTS : LARGENIPARTS); for (inbfs=0; inbfs minpwgt[0]) break; } } } /************************************************************* * Do some partition refinement **************************************************************/ Compute2WayPartitionParams(ctrl, graph); /* mprintf("IPART: %3D [%5D %5D] [%5D %5D] %5D\n", graph->nvtxs, pwgts[0], pwgts[1], graph->pwgts[0], graph->pwgts[1], graph->mincut); */ Balance2Way(ctrl, graph, tpwgts, ubfactor); /* mprintf("BPART: [%5D %5D] %5D\n", graph->pwgts[0], graph->pwgts[1], graph->mincut); */ FM_2WayEdgeRefine(ctrl, graph, tpwgts, 4); /* mprintf("RPART: [%5D %5D] %5D\n", graph->pwgts[0], graph->pwgts[1], graph->mincut); */ if (inbfs==0 || bestcut > graph->mincut) { bestcut = graph->mincut; idxcopy(nvtxs, where, bestwhere); if (bestcut == 0) break; } } graph->mincut = bestcut; idxcopy(nvtxs, bestwhere, where); gk_free((void **)&bestwhere, &perm, LTERM); } PyMetis-0.90/src/metis/kmetis.c0000640000175000017500000001016510662171744016227 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * kmetis.c * * This file contains the top level routines for the multilevel k-way partitioning * algorithm KMETIS. * * Started 7/28/97 * George * */ #include /************************************************************************* * This function is the entry point for KMETIS **************************************************************************/ void METIS_PartGraphKway(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, idxtype *options, idxtype *edgecut, idxtype *part) { idxtype i; float *tpwgts; tpwgts = gk_fmalloc(*nparts, "KMETIS: tpwgts"); for (i=0; i<*nparts; i++) tpwgts[i] = 1.0/(1.0*(*nparts)); METIS_WPartGraphKway(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, tpwgts, options, edgecut, part); gk_free((void **)&tpwgts, LTERM); } /************************************************************************* * This function is the entry point for KWMETIS **************************************************************************/ void METIS_WPartGraphKway(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *tpwgts, idxtype *options, idxtype *edgecut, idxtype *part) { idxtype i, j; GraphType graph; CtrlType ctrl; if (*numflag == 1) Change2CNumbering(*nvtxs, xadj, adjncy); SetUpGraph(&graph, OP_KMETIS, *nvtxs, 1, xadj, adjncy, vwgt, adjwgt, *wgtflag); if (options[0] == 0) { /* Use the default parameters */ ctrl.CType = KMETIS_CTYPE; ctrl.IType = KMETIS_ITYPE; ctrl.RType = KMETIS_RTYPE; ctrl.dbglvl = KMETIS_DBGLVL; } else { ctrl.CType = options[OPTION_CTYPE]; ctrl.IType = options[OPTION_ITYPE]; ctrl.RType = options[OPTION_RTYPE]; ctrl.dbglvl = options[OPTION_DBGLVL]; } ctrl.optype = OP_KMETIS; ctrl.CoarsenTo = amax((*nvtxs)/(40*gk_log2(*nparts)), 20*(*nparts)); ctrl.maxvwgt = 1.5*((graph.vwgt ? idxsum(*nvtxs, graph.vwgt, 1) : (*nvtxs))/ctrl.CoarsenTo); InitRandom(-1); AllocateWorkSpace(&ctrl, &graph, *nparts); IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl)); IFSET(ctrl.dbglvl, DBG_TIME, gk_startcputimer(ctrl.TotalTmr)); *edgecut = MlevelKWayPartitioning(&ctrl, &graph, *nparts, part, tpwgts, 1.03); IFSET(ctrl.dbglvl, DBG_TIME, gk_stopcputimer(ctrl.TotalTmr)); IFSET(ctrl.dbglvl, DBG_TIME, PrintTimers(&ctrl)); FreeWorkSpace(&ctrl, &graph); if (*numflag == 1) Change2FNumbering(*nvtxs, xadj, adjncy, part); } /************************************************************************* * This function takes a graph and produces a bisection of it **************************************************************************/ idxtype MlevelKWayPartitioning(CtrlType *ctrl, GraphType *graph, idxtype nparts, idxtype *part, float *tpwgts, float ubfactor) { idxtype i, j, nvtxs, tvwgt, tpwgts2[2]; GraphType *cgraph; idxtype wgtflag=3, numflag=0, options[10], edgecut; cgraph = Coarsen2Way(ctrl, graph); IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->InitPartTmr)); AllocateKWayPartitionMemory(ctrl, cgraph, nparts); options[0] = 1; options[OPTION_CTYPE] = MTYPE_SHEMKWAY; options[OPTION_ITYPE] = ITYPE_GGPKL; options[OPTION_RTYPE] = RTYPE_FM; options[OPTION_DBGLVL] = 0; METIS_WPartGraphRecursive(&cgraph->nvtxs, cgraph->xadj, cgraph->adjncy, cgraph->vwgt, cgraph->adjwgt, &wgtflag, &numflag, &nparts, tpwgts, options, &edgecut, cgraph->where); IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->InitPartTmr)); IFSET(ctrl->dbglvl, DBG_IPART, mprintf("Initial %D-way partitioning cut: %D\n", nparts, edgecut)); IFSET(ctrl->dbglvl, DBG_KWAYPINFO, ComputePartitionInfo(cgraph, nparts, cgraph->where)); RefineKWay(ctrl, graph, cgraph, nparts, tpwgts, ubfactor); idxcopy(graph->nvtxs, graph->where, part); FreeGraph(graph, 0); return graph->mincut; } PyMetis-0.90/src/metis/kvmetis.c0000640000175000017500000001034210662171744016412 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * kvmetis.c * * This file contains the top level routines for the multilevel k-way partitioning * algorithm KMETIS. * * Started 7/28/97 * George * * $Id: kvmetis.c,v 1.3 2002/08/10 06:57:50 karypis Exp $ * */ #include /************************************************************************* * This function is the entry point for KMETIS **************************************************************************/ void METIS_PartGraphVKway(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *vsize, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, idxtype *options, idxtype *volume, idxtype *part) { idxtype i; float *tpwgts; tpwgts = gk_fmalloc(*nparts, "KMETIS: tpwgts"); for (i=0; i<*nparts; i++) tpwgts[i] = 1.0/(1.0*(*nparts)); METIS_WPartGraphVKway(nvtxs, xadj, adjncy, vwgt, vsize, wgtflag, numflag, nparts, tpwgts, options, volume, part); gk_free((void **)&tpwgts, LTERM); } /************************************************************************* * This function is the entry point for KWMETIS **************************************************************************/ void METIS_WPartGraphVKway(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *vsize, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *tpwgts, idxtype *options, idxtype *volume, idxtype *part) { idxtype i, j; GraphType graph; CtrlType ctrl; if (*numflag == 1) Change2CNumbering(*nvtxs, xadj, adjncy); VolSetUpGraph(&graph, OP_KVMETIS, *nvtxs, 1, xadj, adjncy, vwgt, vsize, *wgtflag); if (options[0] == 0) { /* Use the default parameters */ ctrl.CType = KVMETIS_CTYPE; ctrl.IType = KVMETIS_ITYPE; ctrl.RType = KVMETIS_RTYPE; ctrl.dbglvl = KVMETIS_DBGLVL; } else { ctrl.CType = options[OPTION_CTYPE]; ctrl.IType = options[OPTION_ITYPE]; ctrl.RType = options[OPTION_RTYPE]; ctrl.dbglvl = options[OPTION_DBGLVL]; } ctrl.optype = OP_KVMETIS; ctrl.CoarsenTo = amax((*nvtxs)/(40*gk_log2(*nparts)), 20*(*nparts)); ctrl.maxvwgt = 1.5*((graph.vwgt ? idxsum(*nvtxs, graph.vwgt, 1) : (*nvtxs))/ctrl.CoarsenTo); InitRandom(-1); AllocateWorkSpace(&ctrl, &graph, *nparts); IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl)); IFSET(ctrl.dbglvl, DBG_TIME, gk_startcputimer(ctrl.TotalTmr)); *volume = MlevelVolKWayPartitioning(&ctrl, &graph, *nparts, part, tpwgts, 1.03); IFSET(ctrl.dbglvl, DBG_TIME, gk_stopcputimer(ctrl.TotalTmr)); IFSET(ctrl.dbglvl, DBG_TIME, PrintTimers(&ctrl)); FreeWorkSpace(&ctrl, &graph); if (*numflag == 1) Change2FNumbering(*nvtxs, xadj, adjncy, part); } /************************************************************************* * This function takes a graph and produces a bisection of it **************************************************************************/ idxtype MlevelVolKWayPartitioning(CtrlType *ctrl, GraphType *graph, idxtype nparts, idxtype *part, float *tpwgts, float ubfactor) { idxtype i, j, nvtxs, tvwgt, tpwgts2[2]; GraphType *cgraph; idxtype wgtflag=3, numflag=0, options[10], edgecut; cgraph = Coarsen2Way(ctrl, graph); IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->InitPartTmr)); AllocateVolKWayPartitionMemory(ctrl, cgraph, nparts); options[0] = 1; options[OPTION_CTYPE] = MTYPE_SHEMKWAY; options[OPTION_ITYPE] = ITYPE_GGPKL; options[OPTION_RTYPE] = RTYPE_FM; options[OPTION_DBGLVL] = 0; METIS_WPartGraphRecursive(&cgraph->nvtxs, cgraph->xadj, cgraph->adjncy, cgraph->vwgt, cgraph->adjwgt, &wgtflag, &numflag, &nparts, tpwgts, options, &edgecut, cgraph->where); IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->InitPartTmr)); IFSET(ctrl->dbglvl, DBG_IPART, mprintf("Initial %D-way partitioning cut: %D\n", nparts, edgecut)); IFSET(ctrl->dbglvl, DBG_KWAYPINFO, ComputePartitionInfo(cgraph, nparts, cgraph->where)); RefineVolKWay(ctrl, graph, cgraph, nparts, tpwgts, ubfactor); idxcopy(graph->nvtxs, graph->where, part); FreeGraph(graph, 0); return graph->minvol; } PyMetis-0.90/src/metis/kwayfm.c0000640000175000017500000005215310662171744016234 0ustar andreasandreas/* * kwayfm.c * * This file contains code that implements the multilevel k-way refinement * * Started 7/28/97 * George * * $Id: kwayfm.c,v 1.2 2002/08/10 06:29:31 karypis Exp $ * */ #include /************************************************************************* * This function performs k-way refinement **************************************************************************/ void Random_KWayEdgeRefine(CtrlType *ctrl, GraphType *graph, idxtype nparts, float *tpwgts, float ubfactor, idxtype npasses, idxtype ffactor) { idxtype i, ii, iii, j, jj, k, l, pass, nvtxs, nmoves, nbnd, tvwgt, myndegrees; idxtype from, me, to, oldcut, vwgt, gain; idxtype *xadj, *adjncy, *adjwgt; idxtype *where, *pwgts, *perm, *bndptr, *bndind, *minwgt, *maxwgt, *itpwgts; EDegreeType *myedegrees; RInfoType *myrinfo; nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; adjwgt = graph->adjwgt; bndptr = graph->bndptr; bndind = graph->bndind; where = graph->where; pwgts = graph->pwgts; /* Setup the weight intervals of the various subdomains */ minwgt = idxwspacemalloc(ctrl, nparts); maxwgt = idxwspacemalloc(ctrl, nparts); itpwgts = idxwspacemalloc(ctrl, nparts); tvwgt = idxsum(nparts, pwgts, 1); ASSERT(tvwgt == idxsum(nvtxs, graph->vwgt, 1)); for (i=0; idbglvl, DBG_REFINE, mprintf("Partitions: [%6D %6D]-[%6D %6D], Balance: %5.3f, Nv-Nb[%6D %6D]. Cut: %6D\n", pwgts[idxargmin(nparts, pwgts)], pwgts[idxargmax(nparts, pwgts)], minwgt[0], maxwgt[0], 1.0*nparts*pwgts[idxargmax(nparts, pwgts)]/tvwgt, graph->nvtxs, graph->nbnd, graph->mincut)); for (pass=0; passmincut); oldcut = graph->mincut; nbnd = graph->nbnd; RandomPermute(nbnd, perm, 1); for (nmoves=iii=0; iiinbnd; iii++) { ii = perm[iii]; if (ii >= nbnd) continue; i = bndind[ii]; myrinfo = graph->rinfo+i; if (myrinfo->ed >= myrinfo->id) { /* Total ED is too high */ from = where[i]; vwgt = graph->vwgt[i]; if (myrinfo->id > 0 && pwgts[from]-vwgt < minwgt[from]) continue; /* This cannot be moved! */ myedegrees = myrinfo->edegrees; myndegrees = myrinfo->ndegrees; j = myrinfo->id; for (k=0; kid. Allow good nodes to move */ if (pwgts[to]+vwgt <= maxwgt[to]+ffactor*gain && gain >= 0) break; } if (k == myndegrees) continue; /* break out if you did not find a candidate */ for (j=k+1; j myedegrees[k].ed && pwgts[to]+vwgt <= maxwgt[to]) || (myedegrees[j].ed == myedegrees[k].ed && itpwgts[myedegrees[k].pid]*pwgts[to] < itpwgts[to]*pwgts[myedegrees[k].pid])) k = j; } to = myedegrees[k].pid; j = 0; if (myedegrees[k].ed-myrinfo->id > 0) j = 1; else if (myedegrees[k].ed-myrinfo->id == 0) { if ((iii&7) == 0 || pwgts[from] >= maxwgt[from] || itpwgts[from]*(pwgts[to]+vwgt) < itpwgts[to]*pwgts[from]) j = 1; } if (j == 0) continue; /*===================================================================== * If we got here, we can now move the vertex from 'from' to 'to' *======================================================================*/ graph->mincut -= myedegrees[k].ed-myrinfo->id; IFSET(ctrl->dbglvl, DBG_MOVEINFO, mprintf("\t\tMoving %6D to %3D. Gain: %4D. Cut: %6D\n", i, to, myedegrees[k].ed-myrinfo->id, graph->mincut)); /* Update where, weight, and ID/ED information of the vertex you moved */ where[i] = to; INC_DEC(pwgts[to], pwgts[from], vwgt); myrinfo->ed += myrinfo->id-myedegrees[k].ed; SWAP(myrinfo->id, myedegrees[k].ed, j); if (myedegrees[k].ed == 0) myedegrees[k] = myedegrees[--myrinfo->ndegrees]; else myedegrees[k].pid = from; if (myrinfo->ed-myrinfo->id < 0) BNDDelete(nbnd, bndind, bndptr, i); /* Update the degrees of adjacent vertices */ for (j=xadj[i]; jrinfo+ii; if (myrinfo->edegrees == NULL) { myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree; ctrl->wspace.cdegree += xadj[ii+1]-xadj[ii]; } myedegrees = myrinfo->edegrees; ASSERT(CheckRInfo(myrinfo)); if (me == from) { INC_DEC(myrinfo->ed, myrinfo->id, adjwgt[j]); if (myrinfo->ed-myrinfo->id >= 0 && bndptr[ii] == -1) BNDInsert(nbnd, bndind, bndptr, ii); } else if (me == to) { INC_DEC(myrinfo->id, myrinfo->ed, adjwgt[j]); if (myrinfo->ed-myrinfo->id < 0 && bndptr[ii] != -1) BNDDelete(nbnd, bndind, bndptr, ii); } /* Remove contribution from the .ed of 'from' */ if (me != from) { for (k=0; kndegrees; k++) { if (myedegrees[k].pid == from) { if (myedegrees[k].ed == adjwgt[j]) myedegrees[k] = myedegrees[--myrinfo->ndegrees]; else myedegrees[k].ed -= adjwgt[j]; break; } } } /* Add contribution to the .ed of 'to' */ if (me != to) { for (k=0; kndegrees; k++) { if (myedegrees[k].pid == to) { myedegrees[k].ed += adjwgt[j]; break; } } if (k == myrinfo->ndegrees) { myedegrees[myrinfo->ndegrees].pid = to; myedegrees[myrinfo->ndegrees++].ed = adjwgt[j]; } } ASSERT(myrinfo->ndegrees <= xadj[ii+1]-xadj[ii]); ASSERT(CheckRInfo(myrinfo)); } nmoves++; } } graph->nbnd = nbnd; IFSET(ctrl->dbglvl, DBG_REFINE, mprintf("\t[%6D %6D], Balance: %5.3f, Nb: %6D. Nmoves: %5D, Cut: %6D, Vol: %6D\n", pwgts[idxargmin(nparts, pwgts)], pwgts[idxargmax(nparts, pwgts)], 1.0*nparts*pwgts[idxargmax(nparts, pwgts)]/tvwgt, graph->nbnd, nmoves, graph->mincut, ComputeVolume(graph, where))); if (graph->mincut == oldcut) break; } idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nvtxs); } /************************************************************************* * This function performs k-way refinement **************************************************************************/ void Greedy_KWayEdgeRefine(CtrlType *ctrl, GraphType *graph, idxtype nparts, float *tpwgts, float ubfactor, idxtype npasses) { idxtype i, ii, iii, j, jj, k, l, pass, nvtxs, nbnd, tvwgt, myndegrees, oldgain, gain; idxtype from, me, to, oldcut, vwgt; idxtype *xadj, *adjncy, *adjwgt; idxtype *where, *pwgts, *perm, *bndptr, *bndind, *minwgt, *maxwgt, *moved, *itpwgts; EDegreeType *myedegrees; RInfoType *myrinfo; PQueueType queue; nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; adjwgt = graph->adjwgt; bndind = graph->bndind; bndptr = graph->bndptr; where = graph->where; pwgts = graph->pwgts; /* Setup the weight intervals of the various subdomains */ minwgt = idxwspacemalloc(ctrl, nparts); maxwgt = idxwspacemalloc(ctrl, nparts); itpwgts = idxwspacemalloc(ctrl, nparts); tvwgt = idxsum(nparts, pwgts, 1); ASSERT(tvwgt == idxsum(nvtxs, graph->vwgt, 1)); for (i=0; iadjwgtsum[idxargmax(nvtxs, graph->adjwgtsum)]); IFSET(ctrl->dbglvl, DBG_REFINE, mprintf("Partitions: [%6D %6D]-[%6D %6D], Balance: %5.3f, Nv-Nb[%6D %6D]. Cut: %6D\n", pwgts[idxargmin(nparts, pwgts)], pwgts[idxargmax(nparts, pwgts)], minwgt[0], maxwgt[0], 1.0*nparts*pwgts[idxargmax(nparts, pwgts)]/tvwgt, graph->nvtxs, graph->nbnd, graph->mincut)); for (pass=0; passmincut); PQueueReset(&queue); idxset(nvtxs, -1, moved); oldcut = graph->mincut; nbnd = graph->nbnd; RandomPermute(nbnd, perm, 1); for (ii=0; iirinfo[i].ed - graph->rinfo[i].id); moved[i] = 2; } for (iii=0;;iii++) { if ((i = PQueueGetMax(&queue)) == -1) break; moved[i] = 1; myrinfo = graph->rinfo+i; from = where[i]; vwgt = graph->vwgt[i]; if (pwgts[from]-vwgt < minwgt[from]) continue; /* This cannot be moved! */ myedegrees = myrinfo->edegrees; myndegrees = myrinfo->ndegrees; j = myrinfo->id; for (k=0; kid. Allow good nodes to move */ if (pwgts[to]+vwgt <= maxwgt[to]+gain && gain >= 0) break; } if (k == myndegrees) continue; /* break out if you did not find a candidate */ for (j=k+1; j myedegrees[k].ed && pwgts[to]+vwgt <= maxwgt[to]) || (myedegrees[j].ed == myedegrees[k].ed && itpwgts[myedegrees[k].pid]*pwgts[to] < itpwgts[to]*pwgts[myedegrees[k].pid])) k = j; } to = myedegrees[k].pid; j = 0; if (myedegrees[k].ed-myrinfo->id > 0) j = 1; else if (myedegrees[k].ed-myrinfo->id == 0) { if ((iii&7) == 0 || pwgts[from] >= maxwgt[from] || itpwgts[from]*(pwgts[to]+vwgt) < itpwgts[to]*pwgts[from]) j = 1; } if (j == 0) continue; /*===================================================================== * If we got here, we can now move the vertex from 'from' to 'to' *======================================================================*/ graph->mincut -= myedegrees[k].ed-myrinfo->id; IFSET(ctrl->dbglvl, DBG_MOVEINFO, mprintf("\t\tMoving %6D to %3D. Gain: %4D. Cut: %6D\n", i, to, myedegrees[k].ed-myrinfo->id, graph->mincut)); /* Update where, weight, and ID/ED information of the vertex you moved */ where[i] = to; INC_DEC(pwgts[to], pwgts[from], vwgt); myrinfo->ed += myrinfo->id-myedegrees[k].ed; SWAP(myrinfo->id, myedegrees[k].ed, j); if (myedegrees[k].ed == 0) myedegrees[k] = myedegrees[--myrinfo->ndegrees]; else myedegrees[k].pid = from; if (myrinfo->ed < myrinfo->id) BNDDelete(nbnd, bndind, bndptr, i); /* Update the degrees of adjacent vertices */ for (j=xadj[i]; jrinfo+ii; if (myrinfo->edegrees == NULL) { myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree; ctrl->wspace.cdegree += xadj[ii+1]-xadj[ii]; } myedegrees = myrinfo->edegrees; ASSERT(CheckRInfo(myrinfo)); oldgain = (myrinfo->ed-myrinfo->id); if (me == from) { INC_DEC(myrinfo->ed, myrinfo->id, adjwgt[j]); if (myrinfo->ed-myrinfo->id >= 0 && bndptr[ii] == -1) BNDInsert(nbnd, bndind, bndptr, ii); } else if (me == to) { INC_DEC(myrinfo->id, myrinfo->ed, adjwgt[j]); if (myrinfo->ed-myrinfo->id < 0 && bndptr[ii] != -1) BNDDelete(nbnd, bndind, bndptr, ii); } /* Remove contribution from the .ed of 'from' */ if (me != from) { for (k=0; kndegrees; k++) { if (myedegrees[k].pid == from) { if (myedegrees[k].ed == adjwgt[j]) myedegrees[k] = myedegrees[--myrinfo->ndegrees]; else myedegrees[k].ed -= adjwgt[j]; break; } } } /* Add contribution to the .ed of 'to' */ if (me != to) { for (k=0; kndegrees; k++) { if (myedegrees[k].pid == to) { myedegrees[k].ed += adjwgt[j]; break; } } if (k == myrinfo->ndegrees) { myedegrees[myrinfo->ndegrees].pid = to; myedegrees[myrinfo->ndegrees++].ed = adjwgt[j]; } } /* Update the queue */ if (me == to || me == from) { gain = myrinfo->ed-myrinfo->id; if (moved[ii] == 2) { if (gain >= 0) PQueueUpdate(&queue, ii, oldgain, gain); else { PQueueDelete(&queue, ii, oldgain); moved[ii] = -1; } } else if (moved[ii] == -1 && gain >= 0) { PQueueInsert(&queue, ii, gain); moved[ii] = 2; } } ASSERT(myrinfo->ndegrees <= xadj[ii+1]-xadj[ii]); ASSERT(CheckRInfo(myrinfo)); } } graph->nbnd = nbnd; IFSET(ctrl->dbglvl, DBG_REFINE, mprintf("\t[%6D %6D], Balance: %5.3f, Nb: %6D. Cut: %6D\n", pwgts[idxargmin(nparts, pwgts)], pwgts[idxargmax(nparts, pwgts)], 1.0*nparts*pwgts[idxargmax(nparts, pwgts)]/tvwgt, graph->nbnd, graph->mincut)); if (graph->mincut == oldcut) break; } PQueueFree(ctrl, &queue); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); } /************************************************************************* * This function performs k-way refinement **************************************************************************/ void Greedy_KWayEdgeBalance(CtrlType *ctrl, GraphType *graph, idxtype nparts, float *tpwgts, float ubfactor, idxtype npasses) { idxtype i, ii, iii, j, jj, k, l, pass, nvtxs, nbnd, tvwgt, myndegrees, oldgain, gain, nmoves; idxtype from, me, to, oldcut, vwgt; idxtype *xadj, *adjncy, *adjwgt; idxtype *where, *pwgts, *perm, *bndptr, *bndind, *minwgt, *maxwgt, *moved, *itpwgts; EDegreeType *myedegrees; RInfoType *myrinfo; PQueueType queue; nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; adjwgt = graph->adjwgt; bndind = graph->bndind; bndptr = graph->bndptr; where = graph->where; pwgts = graph->pwgts; /* Setup the weight intervals of the various subdomains */ minwgt = idxwspacemalloc(ctrl, nparts); maxwgt = idxwspacemalloc(ctrl, nparts); itpwgts = idxwspacemalloc(ctrl, nparts); tvwgt = idxsum(nparts, pwgts, 1); ASSERT(tvwgt == idxsum(nvtxs, graph->vwgt, 1)); for (i=0; iadjwgtsum[idxargmax(nvtxs, graph->adjwgtsum)]); IFSET(ctrl->dbglvl, DBG_REFINE, mprintf("Partitions: [%6D %6D]-[%6D %6D], Balance: %5.3f, Nv-Nb[%6D %6D]. Cut: %6D [B]\n", pwgts[idxargmin(nparts, pwgts)], pwgts[idxargmax(nparts, pwgts)], minwgt[0], maxwgt[0], 1.0*nparts*pwgts[idxargmax(nparts, pwgts)]/tvwgt, graph->nvtxs, graph->nbnd, graph->mincut)); for (pass=0; passmincut); /* Check to see if things are out of balance, given the tolerance */ for (i=0; i maxwgt[i]) break; } if (i == nparts) /* Things are balanced. Return right away */ break; PQueueReset(&queue); idxset(nvtxs, -1, moved); oldcut = graph->mincut; nbnd = graph->nbnd; RandomPermute(nbnd, perm, 1); for (ii=0; iirinfo[i].ed - graph->rinfo[i].id); moved[i] = 2; } nmoves = 0; for (;;) { if ((i = PQueueGetMax(&queue)) == -1) break; moved[i] = 1; myrinfo = graph->rinfo+i; from = where[i]; vwgt = graph->vwgt[i]; if (pwgts[from]-vwgt < minwgt[from]) continue; /* This cannot be moved! */ myedegrees = myrinfo->edegrees; myndegrees = myrinfo->ndegrees; for (k=0; k minwgt[to] && myedegrees[k].ed-myrinfo->id < 0) continue; /*===================================================================== * If we got here, we can now move the vertex from 'from' to 'to' *======================================================================*/ graph->mincut -= myedegrees[k].ed-myrinfo->id; IFSET(ctrl->dbglvl, DBG_MOVEINFO, mprintf("\t\tMoving %6D to %3D. Gain: %4D. Cut: %6D\n", i, to, myedegrees[k].ed-myrinfo->id, graph->mincut)); /* Update where, weight, and ID/ED information of the vertex you moved */ where[i] = to; INC_DEC(pwgts[to], pwgts[from], vwgt); myrinfo->ed += myrinfo->id-myedegrees[k].ed; SWAP(myrinfo->id, myedegrees[k].ed, j); if (myedegrees[k].ed == 0) myedegrees[k] = myedegrees[--myrinfo->ndegrees]; else myedegrees[k].pid = from; if (myrinfo->ed == 0) BNDDelete(nbnd, bndind, bndptr, i); /* Update the degrees of adjacent vertices */ for (j=xadj[i]; jrinfo+ii; if (myrinfo->edegrees == NULL) { myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree; ctrl->wspace.cdegree += xadj[ii+1]-xadj[ii]; } myedegrees = myrinfo->edegrees; ASSERT(CheckRInfo(myrinfo)); oldgain = (myrinfo->ed-myrinfo->id); if (me == from) { INC_DEC(myrinfo->ed, myrinfo->id, adjwgt[j]); if (myrinfo->ed > 0 && bndptr[ii] == -1) BNDInsert(nbnd, bndind, bndptr, ii); } else if (me == to) { INC_DEC(myrinfo->id, myrinfo->ed, adjwgt[j]); if (myrinfo->ed == 0 && bndptr[ii] != -1) BNDDelete(nbnd, bndind, bndptr, ii); } /* Remove contribution from the .ed of 'from' */ if (me != from) { for (k=0; kndegrees; k++) { if (myedegrees[k].pid == from) { if (myedegrees[k].ed == adjwgt[j]) myedegrees[k] = myedegrees[--myrinfo->ndegrees]; else myedegrees[k].ed -= adjwgt[j]; break; } } } /* Add contribution to the .ed of 'to' */ if (me != to) { for (k=0; kndegrees; k++) { if (myedegrees[k].pid == to) { myedegrees[k].ed += adjwgt[j]; break; } } if (k == myrinfo->ndegrees) { myedegrees[myrinfo->ndegrees].pid = to; myedegrees[myrinfo->ndegrees++].ed = adjwgt[j]; } } /* Update the queue */ if (me == to || me == from) { gain = myrinfo->ed-myrinfo->id; if (moved[ii] == 2) { if (myrinfo->ed > 0) PQueueUpdate(&queue, ii, oldgain, gain); else { PQueueDelete(&queue, ii, oldgain); moved[ii] = -1; } } else if (moved[ii] == -1 && myrinfo->ed > 0) { PQueueInsert(&queue, ii, gain); moved[ii] = 2; } } ASSERT(myrinfo->ndegrees <= xadj[ii+1]-xadj[ii]); ASSERT(CheckRInfo(myrinfo)); } nmoves++; } graph->nbnd = nbnd; IFSET(ctrl->dbglvl, DBG_REFINE, mprintf("\t[%6D %6D], Balance: %5.3f, Nb: %6D. Nmoves: %5D, Cut: %6D\n", pwgts[idxargmin(nparts, pwgts)], pwgts[idxargmax(nparts, pwgts)], 1.0*nparts*pwgts[idxargmax(nparts, pwgts)]/tvwgt, graph->nbnd, nmoves, graph->mincut)); } PQueueFree(ctrl, &queue); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); } PyMetis-0.90/src/metis/kwayrefine.c0000640000175000017500000003616310662171744017105 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * kwayrefine.c * * This file contains the driving routines for multilevel k-way refinement * * Started 7/28/97 * George * * $Id: kwayrefine.c,v 1.5 2003/04/01 05:09:37 karypis Exp $ */ #include /************************************************************************* * This function is the entry point of refinement **************************************************************************/ void RefineKWay(CtrlType *ctrl, GraphType *orggraph, GraphType *graph, idxtype nparts, float *tpwgts, float ubfactor) { idxtype i, nlevels, mustfree=0; GraphType *ptr; IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->UncoarsenTmr)); /* Compute the parameters of the coarsest graph */ ComputeKWayPartitionParams(ctrl, graph, nparts); /* Take care any non-contiguity */ IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->AuxTmr1)); if (ctrl->RType == RTYPE_KWAYRANDOM_MCONN) { EliminateComponents(ctrl, graph, nparts, tpwgts, 1.25); EliminateSubDomainEdges(ctrl, graph, nparts, tpwgts); EliminateComponents(ctrl, graph, nparts, tpwgts, 1.25); } IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->AuxTmr1)); /* Determine how many levels are there */ for (ptr=graph, nlevels=0; ptr!=orggraph; ptr=ptr->finer, nlevels++); for (i=0; ;i++) { /* PrintSubDomainGraph(graph, nparts, graph->where); */ if (ctrl->RType == RTYPE_KWAYRANDOM_MCONN && (i == nlevels/2 || i == nlevels/2+1)) EliminateSubDomainEdges(ctrl, graph, nparts, tpwgts); IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->RefTmr)); if (2*i >= nlevels && !IsBalanced(graph->pwgts, nparts, tpwgts, 1.04*ubfactor)) { ComputeKWayBalanceBoundary(ctrl, graph, nparts); if (ctrl->RType == RTYPE_KWAYRANDOM_MCONN) Greedy_KWayEdgeBalanceMConn(ctrl, graph, nparts, tpwgts, ubfactor, 1); else Greedy_KWayEdgeBalance(ctrl, graph, nparts, tpwgts, ubfactor, 1); ComputeKWayBoundary(ctrl, graph, nparts); } switch (ctrl->RType) { case RTYPE_KWAYRANDOM: Random_KWayEdgeRefine(ctrl, graph, nparts, tpwgts, ubfactor, 10, 1); break; case RTYPE_KWAYGREEDY: Greedy_KWayEdgeRefine(ctrl, graph, nparts, tpwgts, ubfactor, 10); break; case RTYPE_KWAYRANDOM_MCONN: Random_KWayEdgeRefineMConn(ctrl, graph, nparts, tpwgts, ubfactor, 10, 1); break; } IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->RefTmr)); if (graph == orggraph) break; graph = graph->finer; IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->ProjectTmr)); if (graph->vwgt == NULL) { graph->vwgt = idxsmalloc(graph->nvtxs, 1, "RefineKWay: graph->vwgt"); graph->adjwgt = idxsmalloc(graph->nedges, 1, "RefineKWay: graph->adjwgt"); mustfree = 1; } ProjectKWayPartition(ctrl, graph, nparts); IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->ProjectTmr)); } if (!IsBalanced(graph->pwgts, nparts, tpwgts, ubfactor)) { ComputeKWayBalanceBoundary(ctrl, graph, nparts); if (ctrl->RType == RTYPE_KWAYRANDOM_MCONN) { Greedy_KWayEdgeBalanceMConn(ctrl, graph, nparts, tpwgts, ubfactor, 8); Random_KWayEdgeRefineMConn(ctrl, graph, nparts, tpwgts, ubfactor, 10, 0); } else { Greedy_KWayEdgeBalance(ctrl, graph, nparts, tpwgts, ubfactor, 8); Random_KWayEdgeRefine(ctrl, graph, nparts, tpwgts, ubfactor, 10, 0); } } /* Take care any trivial non-contiguity */ IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->AuxTmr2)); EliminateComponents(ctrl, graph, nparts, tpwgts, ubfactor); IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->AuxTmr2)); if (mustfree) gk_free((void **)&graph->vwgt, &graph->adjwgt, LTERM); IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->UncoarsenTmr)); } /************************************************************************* * This function is the entry point of refinement **************************************************************************/ void RefineKWayRefinement(CtrlType *ctrl, GraphType *orggraph, GraphType *graph, idxtype nparts, float *tpwgts, float ubfactor) { idxtype i, nlevels, mustfree=0; GraphType *ptr; IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->UncoarsenTmr)); /* Compute the parameters of the coarsest graph */ ComputeKWayPartitionParams(ctrl, graph, nparts); #ifdef XXXX /* Take care any non-contiguity */ IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->AuxTmr1)); if (ctrl->RType == RTYPE_KWAYRANDOM_MCONN) { EliminateComponents(ctrl, graph, nparts, tpwgts, 1.25); EliminateSubDomainEdges(ctrl, graph, nparts, tpwgts); EliminateComponents(ctrl, graph, nparts, tpwgts, 1.25); } IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->AuxTmr1)); #endif /* Determine how many levels are there */ for (ptr=graph, nlevels=0; ptr!=orggraph; ptr=ptr->finer, nlevels++); for (i=0; ;i++) { #ifdef XXXX /* PrintSubDomainGraph(graph, nparts, graph->where); */ if (ctrl->RType == RTYPE_KWAYRANDOM_MCONN && (i == nlevels/2 || i == nlevels/2+1)) EliminateSubDomainEdges(ctrl, graph, nparts, tpwgts); IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->RefTmr)); #endif if (2*i >= nlevels && !IsBalanced(graph->pwgts, nparts, tpwgts, 1.04*ubfactor)) { ComputeKWayBalanceBoundary(ctrl, graph, nparts); if (ctrl->RType == RTYPE_KWAYRANDOM_MCONN) Greedy_KWayEdgeBalanceMConn(ctrl, graph, nparts, tpwgts, ubfactor, 1); else Greedy_KWayEdgeBalance(ctrl, graph, nparts, tpwgts, ubfactor, 1); ComputeKWayBoundary(ctrl, graph, nparts); } switch (ctrl->RType) { case RTYPE_KWAYRANDOM: Random_KWayEdgeRefine(ctrl, graph, nparts, tpwgts, ubfactor, 10, 1); break; case RTYPE_KWAYGREEDY: Greedy_KWayEdgeRefine(ctrl, graph, nparts, tpwgts, ubfactor, 10); break; case RTYPE_KWAYRANDOM_MCONN: Random_KWayEdgeRefineMConn(ctrl, graph, nparts, tpwgts, ubfactor, 10, 1); break; } IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->RefTmr)); if (graph == orggraph) break; graph = graph->finer; IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->ProjectTmr)); if (graph->vwgt == NULL) { graph->vwgt = idxsmalloc(graph->nvtxs, 1, "RefineKWay: graph->vwgt"); graph->adjwgt = idxsmalloc(graph->nedges, 1, "RefineKWay: graph->adjwgt"); mustfree = 1; } ProjectKWayPartition(ctrl, graph, nparts); IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->ProjectTmr)); } if (!IsBalanced(graph->pwgts, nparts, tpwgts, ubfactor)) { ComputeKWayBalanceBoundary(ctrl, graph, nparts); if (ctrl->RType == RTYPE_KWAYRANDOM_MCONN) { Greedy_KWayEdgeBalanceMConn(ctrl, graph, nparts, tpwgts, ubfactor, 8); Random_KWayEdgeRefineMConn(ctrl, graph, nparts, tpwgts, ubfactor, 10, 0); } else { Greedy_KWayEdgeBalance(ctrl, graph, nparts, tpwgts, ubfactor, 8); Random_KWayEdgeRefine(ctrl, graph, nparts, tpwgts, ubfactor, 10, 0); } } /* Take care any trivial non-contiguity */ IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->AuxTmr2)); EliminateComponents(ctrl, graph, nparts, tpwgts, ubfactor); IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->AuxTmr2)); if (mustfree) gk_free((void **)&graph->vwgt, &graph->adjwgt, LTERM); IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->UncoarsenTmr)); } /************************************************************************* * This function allocates memory for k-way edge refinement **************************************************************************/ void AllocateKWayPartitionMemory(CtrlType *ctrl, GraphType *graph, idxtype nparts) { idxtype nvtxs; nvtxs = graph->nvtxs; graph->pwgts = idxmalloc(nparts, "AllocateKWayPartitionMemory: pwgts"); graph->where = idxmalloc(nvtxs, "AllocateKWayPartitionMemory: pwgts"); graph->bndptr = idxmalloc(nvtxs, "AllocateKWayPartitionMemory: pwgts"); graph->bndind = idxmalloc(nvtxs, "AllocateKWayPartitionMemory: pwgts"); graph->rinfo = (RInfoType *)gk_malloc(nvtxs*sizeof(RInfoType), "AllocateKWayPartitionMemory: rinfo"); } /************************************************************************* * This function computes the initial id/ed **************************************************************************/ void ComputeKWayPartitionParams(CtrlType *ctrl, GraphType *graph, idxtype nparts) { idxtype i, j, k, l, nvtxs, nbnd, mincut, me, other; idxtype *xadj, *vwgt, *adjncy, *adjwgt, *pwgts, *where, *bndind, *bndptr; RInfoType *rinfo, *myrinfo; EDegreeType *myedegrees; nvtxs = graph->nvtxs; xadj = graph->xadj; vwgt = graph->vwgt; adjncy = graph->adjncy; adjwgt = graph->adjwgt; where = graph->where; pwgts = idxset(nparts, 0, graph->pwgts); bndind = graph->bndind; bndptr = idxset(nvtxs, -1, graph->bndptr); rinfo = graph->rinfo; /*------------------------------------------------------------ / Compute now the id/ed degrees /------------------------------------------------------------*/ ctrl->wspace.cdegree = 0; nbnd = mincut = 0; for (i=0; iid = myrinfo->ed = myrinfo->ndegrees = 0; myrinfo->edegrees = NULL; for (j=xadj[i]; jed += adjwgt[j]; } myrinfo->id = graph->adjwgtsum[i] - myrinfo->ed; if (myrinfo->ed > 0) mincut += myrinfo->ed; if (myrinfo->ed-myrinfo->id >= 0) BNDInsert(nbnd, bndind, bndptr, i); /* Time to compute the particular external degrees */ if (myrinfo->ed > 0) { myedegrees = myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree; ctrl->wspace.cdegree += xadj[i+1]-xadj[i]; for (j=xadj[i]; jndegrees; k++) { if (myedegrees[k].pid == other) { myedegrees[k].ed += adjwgt[j]; break; } } if (k == myrinfo->ndegrees) { myedegrees[myrinfo->ndegrees].pid = other; myedegrees[myrinfo->ndegrees++].ed = adjwgt[j]; } } } ASSERT(myrinfo->ndegrees <= xadj[i+1]-xadj[i]); } } graph->mincut = mincut/2; graph->nbnd = nbnd; } /************************************************************************* * This function projects a partition, and at the same time computes the * parameters for refinement. **************************************************************************/ void ProjectKWayPartition(CtrlType *ctrl, GraphType *graph, idxtype nparts) { idxtype i, j, k, nvtxs, nbnd, me, other, istart, iend, ndegrees; idxtype *xadj, *adjncy, *adjwgt, *adjwgtsum; idxtype *cmap, *where, *bndptr, *bndind; idxtype *cwhere; GraphType *cgraph; RInfoType *crinfo, *rinfo, *myrinfo; EDegreeType *myedegrees; idxtype *htable; cgraph = graph->coarser; cwhere = cgraph->where; crinfo = cgraph->rinfo; nvtxs = graph->nvtxs; cmap = graph->cmap; xadj = graph->xadj; adjncy = graph->adjncy; adjwgt = graph->adjwgt; adjwgtsum = graph->adjwgtsum; AllocateKWayPartitionMemory(ctrl, graph, nparts); where = graph->where; rinfo = graph->rinfo; bndind = graph->bndind; bndptr = idxset(nvtxs, -1, graph->bndptr); /* Go through and project partition and compute id/ed for the nodes */ for (i=0; iwspace.cdegree = 0; for (nbnd=0, i=0; iid = myrinfo->ed = myrinfo->ndegrees = 0; myrinfo->edegrees = NULL; myrinfo->id = adjwgtsum[i]; if (cmap[i] > 0) { /* If it is an interface node. Note cmap[i] = crinfo[cmap[i]].ed */ istart = xadj[i]; iend = xadj[i+1]; myedegrees = myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree; ctrl->wspace.cdegree += iend-istart; ndegrees = 0; for (j=istart; jed += adjwgt[j]; if ((k = htable[other]) == -1) { htable[other] = ndegrees; myedegrees[ndegrees].pid = other; myedegrees[ndegrees++].ed = adjwgt[j]; } else { myedegrees[k].ed += adjwgt[j]; } } } myrinfo->id -= myrinfo->ed; /* Remove space for edegrees if it was interior */ if (myrinfo->ed == 0) { myrinfo->edegrees = NULL; ctrl->wspace.cdegree -= iend-istart; } else { if (myrinfo->ed-myrinfo->id >= 0) BNDInsert(nbnd, bndind, bndptr, i); myrinfo->ndegrees = ndegrees; for (j=0; jpwgts, graph->pwgts); graph->mincut = cgraph->mincut; graph->nbnd = nbnd; FreeGraph(graph->coarser, 1); graph->coarser = NULL; idxwspacefree(ctrl, nparts); ASSERT(CheckBnd2(graph)); } /************************************************************************* * This function checks if the partition weights are within the balance * contraints **************************************************************************/ idxtype IsBalanced(idxtype *pwgts, idxtype nparts, float *tpwgts, float ubfactor) { idxtype i, j, tvwgt; tvwgt = idxsum(nparts, pwgts, 1); for (i=0; i tpwgts[i]*tvwgt*(ubfactor+0.005)) return 0; } return 1; } /************************************************************************* * This function computes the boundary definition for balancing **************************************************************************/ void ComputeKWayBoundary(CtrlType *ctrl, GraphType *graph, idxtype nparts) { idxtype i, nvtxs, nbnd; idxtype *bndind, *bndptr; nvtxs = graph->nvtxs; bndind = graph->bndind; bndptr = idxset(nvtxs, -1, graph->bndptr); /*------------------------------------------------------------ / Compute the new boundary /------------------------------------------------------------*/ nbnd = 0; for (i=0; irinfo[i].ed-graph->rinfo[i].id >= 0) BNDInsert(nbnd, bndind, bndptr, i); } graph->nbnd = nbnd; } /************************************************************************* * This function computes the boundary definition for balancing **************************************************************************/ void ComputeKWayBalanceBoundary(CtrlType *ctrl, GraphType *graph, idxtype nparts) { idxtype i, nvtxs, nbnd; idxtype *bndind, *bndptr; nvtxs = graph->nvtxs; bndind = graph->bndind; bndptr = idxset(nvtxs, -1, graph->bndptr); /*------------------------------------------------------------ / Compute the new boundary /------------------------------------------------------------*/ nbnd = 0; for (i=0; irinfo[i].ed > 0) BNDInsert(nbnd, bndind, bndptr, i); } graph->nbnd = nbnd; } PyMetis-0.90/src/metis/kwayvolfm.c0000640000175000017500000015564010662171744016762 0ustar andreasandreas/* * kwayvolfm.c * * This file contains code that implements the multilevel k-way refinement * * Started 7/8/98 * George * * $Id: kwayvolfm.c,v 1.3 2003/07/31 06:04:52 karypis Exp $ * */ #include /************************************************************************* * This function performs k-way refinement **************************************************************************/ void Random_KWayVolRefine(CtrlType *ctrl, GraphType *graph, idxtype nparts, float *tpwgts, float ubfactor, idxtype npasses, idxtype ffactor) { idxtype i, ii, iii, j, jj, k, kk, l, u, pass, nvtxs, nmoves, tvwgt, myndegrees, xgain; idxtype from, me, to, oldcut, oldvol, vwgt; idxtype *xadj, *adjncy, *adjwgt; idxtype *where, *pwgts, *perm, *bndptr, *bndind, *minwgt, *maxwgt, *itpwgts, *updind, *marker, *phtable; VEDegreeType *myedegrees; VRInfoType *myrinfo; nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; adjwgt = graph->adjwgt; bndptr = graph->bndptr; bndind = graph->bndind; where = graph->where; pwgts = graph->pwgts; /* Setup the weight intervals of the various subdomains */ minwgt = idxwspacemalloc(ctrl, nparts); maxwgt = idxwspacemalloc(ctrl, nparts); itpwgts = idxwspacemalloc(ctrl, nparts); tvwgt = idxsum(nparts, pwgts, 1); ASSERT(tvwgt == idxsum(nvtxs, graph->vwgt, 1)); updind = idxmalloc(nvtxs, "Random_KWayVolRefine: updind"); marker = idxsmalloc(nvtxs, 0, "Random_KWayVolRefine: marker"); phtable = idxsmalloc(nparts, -1, "Random_KWayVolRefine: phtable"); for (i=0; idbglvl, DBG_REFINE, mprintf("VolPart: [%5D %5D]-[%5D %5D], Balance: %3.2f, Nv-Nb[%5D %5D]. Cut: %5D, Vol: %5D\n", pwgts[idxargmin(nparts, pwgts)], pwgts[idxargmax(nparts, pwgts)], minwgt[0], maxwgt[0], 1.0*nparts*pwgts[idxargmax(nparts, pwgts)]/tvwgt, graph->nvtxs, graph->nbnd, graph->mincut, graph->minvol)); for (pass=0; passmincut); oldcut = graph->mincut; oldvol = graph->minvol; RandomPermute(graph->nbnd, perm, 1); for (nmoves=iii=0; iiinbnd; iii++) { ii = perm[iii]; if (ii >= graph->nbnd) continue; i = bndind[ii]; myrinfo = graph->vrinfo+i; if (myrinfo->gv >= 0) { /* Total volume gain is too high */ from = where[i]; vwgt = graph->vwgt[i]; if (myrinfo->id > 0 && pwgts[from]-vwgt < minwgt[from]) continue; /* This cannot be moved! */ xgain = (myrinfo->id == 0 && myrinfo->ed > 0 ? graph->vsize[i] : 0); myedegrees = myrinfo->edegrees; myndegrees = myrinfo->ndegrees; for (k=0; k= 0) break; } if (k == myndegrees) continue; /* break out if you did not find a candidate */ for (j=k+1; j maxwgt[to]) continue; if (myedegrees[j].gv > myedegrees[k].gv || (myedegrees[j].gv == myedegrees[k].gv && myedegrees[j].ed > myedegrees[k].ed) || (myedegrees[j].gv == myedegrees[k].gv && myedegrees[j].ed == myedegrees[k].ed && itpwgts[myedegrees[k].pid]*pwgts[to] < itpwgts[to]*pwgts[myedegrees[k].pid])) k = j; } to = myedegrees[k].pid; j = 0; if (xgain+myedegrees[k].gv > 0 || myedegrees[k].ed-myrinfo->id > 0) j = 1; else if (myedegrees[k].ed-myrinfo->id == 0) { if ((iii&5) == 0 || pwgts[from] >= maxwgt[from] || itpwgts[from]*(pwgts[to]+vwgt) < itpwgts[to]*pwgts[from]) j = 1; } if (j == 0) continue; /*===================================================================== * If we got here, we can now move the vertex from 'from' to 'to' *======================================================================*/ INC_DEC(pwgts[to], pwgts[from], vwgt); graph->mincut -= myedegrees[k].ed-myrinfo->id; graph->minvol -= (xgain+myedegrees[k].gv); where[i] = to; IFSET(ctrl->dbglvl, DBG_MOVEINFO, mprintf("\t\tMoving %6D from %3D to %3D. Gain: [%4D %4D]. Cut: %6D, Vol: %6D\n", i, from, to, xgain+myedegrees[k].gv, myedegrees[k].ed-myrinfo->id, graph->mincut, graph->minvol)); KWayVolUpdate(ctrl, graph, i, from, to, marker, phtable, updind); nmoves++; /* CheckVolKWayPartitionParams(ctrl, graph, nparts); */ } } IFSET(ctrl->dbglvl, DBG_REFINE, mprintf("\t[%6D %6D], Balance: %5.3f, Nb: %6D. Nmoves: %5D, Cut: %6D, Vol: %6D\n", pwgts[idxargmin(nparts, pwgts)], pwgts[idxargmax(nparts, pwgts)], 1.0*nparts*pwgts[idxargmax(nparts, pwgts)]/tvwgt, graph->nbnd, nmoves, graph->mincut, graph->minvol)); if (graph->minvol == oldvol && graph->mincut == oldcut) break; } gk_free((void **)&marker, &updind, &phtable, LTERM); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nvtxs); } /************************************************************************* * This function performs k-way refinement **************************************************************************/ void Random_KWayVolRefineMConn(CtrlType *ctrl, GraphType *graph, idxtype nparts, float *tpwgts, float ubfactor, idxtype npasses, idxtype ffactor) { idxtype i, ii, iii, j, jj, k, kk, l, u, pass, nvtxs, nmoves, tvwgt, myndegrees, xgain; idxtype from, me, to, oldcut, oldvol, vwgt, nadd, maxndoms; idxtype *xadj, *adjncy, *adjwgt; idxtype *where, *pwgts, *perm, *bndptr, *bndind, *minwgt, *maxwgt, *itpwgts, *updind, *marker, *phtable; idxtype *pmat, *pmatptr, *ndoms; VEDegreeType *myedegrees; VRInfoType *myrinfo; nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; adjwgt = graph->adjwgt; bndptr = graph->bndptr; bndind = graph->bndind; where = graph->where; pwgts = graph->pwgts; /* Setup the weight intervals of the various subdomains */ minwgt = idxwspacemalloc(ctrl, nparts); maxwgt = idxwspacemalloc(ctrl, nparts); itpwgts = idxwspacemalloc(ctrl, nparts); tvwgt = idxsum(nparts, pwgts, 1); ASSERT(tvwgt == idxsum(nvtxs, graph->vwgt, 1)); updind = idxmalloc(nvtxs, "Random_KWayVolRefine: updind"); marker = idxsmalloc(nvtxs, 0, "Random_KWayVolRefine: marker"); phtable = idxsmalloc(nparts, -1, "Random_KWayVolRefine: phtable"); pmat = ctrl->wspace.pmat; ndoms = idxwspacemalloc(ctrl, nparts); ComputeVolSubDomainGraph(graph, nparts, pmat, ndoms); for (i=0; idbglvl, DBG_REFINE, mprintf("VolPart: [%5D %5D]-[%5D %5D], Balance: %3.2f, Nv-Nb[%5D %5D]. Cut: %5D, Vol: %5D\n", pwgts[idxargmin(nparts, pwgts)], pwgts[idxargmax(nparts, pwgts)], minwgt[0], maxwgt[0], 1.0*nparts*pwgts[idxargmax(nparts, pwgts)]/tvwgt, graph->nvtxs, graph->nbnd, graph->mincut, graph->minvol)); for (pass=0; passmincut); maxndoms = ndoms[idxargmax(nparts, ndoms)]; oldcut = graph->mincut; oldvol = graph->minvol; RandomPermute(graph->nbnd, perm, 1); for (nmoves=iii=0; iiinbnd; iii++) { ii = perm[iii]; if (ii >= graph->nbnd) continue; i = bndind[ii]; myrinfo = graph->vrinfo+i; if (myrinfo->gv >= 0) { /* Total volume gain is too high */ from = where[i]; vwgt = graph->vwgt[i]; if (myrinfo->id > 0 && pwgts[from]-vwgt < minwgt[from]) continue; /* This cannot be moved! */ xgain = (myrinfo->id == 0 && myrinfo->ed > 0 ? graph->vsize[i] : 0); myedegrees = myrinfo->edegrees; myndegrees = myrinfo->ndegrees; /* Determine the valid domains */ for (j=0; j maxndoms-1) { phtable[to] = 0; nadd = maxndoms; break; } nadd++; } } if (ndoms[to]+nadd > maxndoms) phtable[to] = 0; if (nadd == 0) phtable[to] = 2; } for (k=0; k= 0) break; } if (k == myndegrees) continue; /* break out if you did not find a candidate */ for (j=k+1; j maxwgt[to]) continue; if (myedegrees[j].gv > myedegrees[k].gv || (myedegrees[j].gv == myedegrees[k].gv && myedegrees[j].ed > myedegrees[k].ed) || (myedegrees[j].gv == myedegrees[k].gv && myedegrees[j].ed == myedegrees[k].ed && itpwgts[myedegrees[k].pid]*pwgts[to] < itpwgts[to]*pwgts[myedegrees[k].pid])) k = j; } to = myedegrees[k].pid; j = 0; if (xgain+myedegrees[k].gv > 0 || myedegrees[k].ed-myrinfo->id > 0) j = 1; else if (myedegrees[k].ed-myrinfo->id == 0) { if ((iii&5) == 0 || phtable[myedegrees[k].pid] == 2 || pwgts[from] >= maxwgt[from] || itpwgts[from]*(pwgts[to]+vwgt) < itpwgts[to]*pwgts[from]) j = 1; } if (j == 0) continue; for (j=0; jmincut -= myedegrees[k].ed-myrinfo->id; graph->minvol -= (xgain+myedegrees[k].gv); where[i] = to; IFSET(ctrl->dbglvl, DBG_MOVEINFO, mprintf("\t\tMoving %6D from %3D to %3D. Gain: [%4D %4D]. Cut: %6D, Vol: %6D\n", i, from, to, xgain+myedegrees[k].gv, myedegrees[k].ed-myrinfo->id, graph->mincut, graph->minvol)); /* Update pmat to reflect the move of 'i' */ pmat[from*nparts+to] += (myrinfo->id-myedegrees[k].ed); pmat[to*nparts+from] += (myrinfo->id-myedegrees[k].ed); if (pmat[from*nparts+to] == 0) { ndoms[from]--; if (ndoms[from]+1 == maxndoms) maxndoms = ndoms[idxargmax(nparts, ndoms)]; } if (pmat[to*nparts+from] == 0) { ndoms[to]--; if (ndoms[to]+1 == maxndoms) maxndoms = ndoms[idxargmax(nparts, ndoms)]; } for (j=xadj[i]; j maxndoms) { mprintf("You just increased the maxndoms: %D %D\n", ndoms[me], maxndoms); maxndoms = ndoms[me]; } } if (pmat[to*nparts+me] == 0) { ndoms[to]++; if (ndoms[to] > maxndoms) { mprintf("You just increased the maxndoms: %D %D\n", ndoms[to], maxndoms); maxndoms = ndoms[to]; } } pmat[me*nparts+to] += adjwgt[j]; pmat[to*nparts+me] += adjwgt[j]; } } KWayVolUpdate(ctrl, graph, i, from, to, marker, phtable, updind); nmoves++; /* CheckVolKWayPartitionParams(ctrl, graph, nparts); */ } } IFSET(ctrl->dbglvl, DBG_REFINE, mprintf("\t[%6D %6D], Balance: %5.3f, Nb: %6D. Nmoves: %5D, Cut: %6D, Vol: %6D\n", pwgts[idxargmin(nparts, pwgts)], pwgts[idxargmax(nparts, pwgts)], 1.0*nparts*pwgts[idxargmax(nparts, pwgts)]/tvwgt, graph->nbnd, nmoves, graph->mincut, graph->minvol)); if (graph->minvol == oldvol && graph->mincut == oldcut) break; } gk_free((void **)&marker, &updind, &phtable, LTERM); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nvtxs); } /************************************************************************* * This function performs k-way refinement **************************************************************************/ void Greedy_KWayVolBalance(CtrlType *ctrl, GraphType *graph, idxtype nparts, float *tpwgts, float ubfactor, idxtype npasses) { idxtype i, ii, iii, j, jj, k, kk, l, u, pass, nvtxs, nmoves, tvwgt, myndegrees, xgain; idxtype from, me, to, vwgt, gain; idxtype *xadj, *adjncy, *adjwgt; idxtype *where, *pwgts, *perm, *moved, *bndptr, *bndind, *minwgt, *maxwgt, *itpwgts, *updind, *marker, *phtable; VEDegreeType *myedegrees; VRInfoType *myrinfo; PQueueType queue; nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; adjwgt = graph->adjwgt; bndptr = graph->bndptr; bndind = graph->bndind; where = graph->where; pwgts = graph->pwgts; /* Setup the weight intervals of the various subdomains */ minwgt = idxwspacemalloc(ctrl, nparts); maxwgt = idxwspacemalloc(ctrl, nparts); itpwgts = idxwspacemalloc(ctrl, nparts); tvwgt = idxsum(nparts, pwgts, 1); ASSERT(tvwgt == idxsum(nvtxs, graph->vwgt, 1)); updind = idxmalloc(nvtxs, "Random_KWayVolRefine: updind"); marker = idxsmalloc(nvtxs, 0, "Random_KWayVolRefine: marker"); phtable = idxsmalloc(nparts, -1, "Random_KWayVolRefine: phtable"); for (i=0; iadjwgtsum[idxargmax(nvtxs, graph->adjwgtsum)]); IFSET(ctrl->dbglvl, DBG_REFINE, mprintf("VolPart: [%5D %5D]-[%5D %5D], Balance: %3.2f, Nv-Nb[%5D %5D]. Cut: %5D, Vol: %5D [B]\n", pwgts[idxargmin(nparts, pwgts)], pwgts[idxargmax(nparts, pwgts)], minwgt[0], maxwgt[0], 1.0*nparts*pwgts[idxargmax(nparts, pwgts)]/tvwgt, graph->nvtxs, graph->nbnd, graph->mincut, graph->minvol)); for (pass=0; passmincut); /* Check to see if things are out of balance, given the tolerance */ for (i=0; i maxwgt[i]) break; } if (i == nparts) /* Things are balanced. Return right away */ break; PQueueReset(&queue); idxset(nvtxs, -1, moved); RandomPermute(graph->nbnd, perm, 1); for (ii=0; iinbnd; ii++) { i = bndind[perm[ii]]; PQueueInsert(&queue, i, graph->vrinfo[i].gv); moved[i] = 2; } for (nmoves=0;;) { if ((i = PQueueGetMax(&queue)) == -1) break; moved[i] = 1; myrinfo = graph->vrinfo+i; from = where[i]; vwgt = graph->vwgt[i]; if (pwgts[from]-vwgt < minwgt[from]) continue; /* This cannot be moved! */ xgain = (myrinfo->id == 0 && myrinfo->ed > 0 ? graph->vsize[i] : 0); myedegrees = myrinfo->edegrees; myndegrees = myrinfo->ndegrees; for (k=0; k minwgt[to] && (xgain+myedegrees[k].gv < 0 || (xgain+myedegrees[k].gv == 0 && myedegrees[k].ed-myrinfo->id < 0)) ) continue; /*===================================================================== * If we got here, we can now move the vertex from 'from' to 'to' *======================================================================*/ INC_DEC(pwgts[to], pwgts[from], vwgt); graph->mincut -= myedegrees[k].ed-myrinfo->id; graph->minvol -= (xgain+myedegrees[k].gv); where[i] = to; IFSET(ctrl->dbglvl, DBG_MOVEINFO, mprintf("\t\tMoving %6D from %3D to %3D. Gain: [%4D %4D]. Cut: %6D, Vol: %6D\n", i, from, to, xgain+myedegrees[k].gv, myedegrees[k].ed-myrinfo->id, graph->mincut, graph->minvol)); KWayVolUpdate(ctrl, graph, i, from, to, marker, phtable, updind); nmoves++; /*CheckVolKWayPartitionParams(ctrl, graph, nparts); */ } IFSET(ctrl->dbglvl, DBG_REFINE, mprintf("\t[%6D %6D], Balance: %5.3f, Nb: %6D. Nmoves: %5D, Cut: %6D, Vol: %6D\n", pwgts[idxargmin(nparts, pwgts)], pwgts[idxargmax(nparts, pwgts)], 1.0*nparts*pwgts[idxargmax(nparts, pwgts)]/tvwgt, graph->nbnd, nmoves, graph->mincut, graph->minvol)); } gk_free((void **)&marker, &updind, &phtable, LTERM); PQueueFree(ctrl, &queue); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); } /************************************************************************* * This function performs k-way refinement **************************************************************************/ void Greedy_KWayVolBalanceMConn(CtrlType *ctrl, GraphType *graph, idxtype nparts, float *tpwgts, float ubfactor, idxtype npasses) { idxtype i, ii, iii, j, jj, k, kk, l, u, pass, nvtxs, nmoves, tvwgt, myndegrees, xgain; idxtype from, me, to, vwgt, gain, maxndoms, nadd; idxtype *xadj, *adjncy, *adjwgt; idxtype *where, *pwgts, *perm, *moved, *bndptr, *bndind, *minwgt, *maxwgt, *itpwgts, *updind, *marker, *phtable; idxtype *pmat, *pmatptr, *ndoms; VEDegreeType *myedegrees; VRInfoType *myrinfo; PQueueType queue; nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; adjwgt = graph->adjwgt; bndptr = graph->bndptr; bndind = graph->bndind; where = graph->where; pwgts = graph->pwgts; /* Setup the weight intervals of the various subdomains */ minwgt = idxwspacemalloc(ctrl, nparts); maxwgt = idxwspacemalloc(ctrl, nparts); itpwgts = idxwspacemalloc(ctrl, nparts); tvwgt = idxsum(nparts, pwgts, 1); ASSERT(tvwgt == idxsum(nvtxs, graph->vwgt, 1)); updind = idxmalloc(nvtxs, "Random_KWayVolRefine: updind"); marker = idxsmalloc(nvtxs, 0, "Random_KWayVolRefine: marker"); phtable = idxsmalloc(nparts, -1, "Random_KWayVolRefine: phtable"); pmat = ctrl->wspace.pmat; ndoms = idxwspacemalloc(ctrl, nparts); ComputeVolSubDomainGraph(graph, nparts, pmat, ndoms); for (i=0; iadjwgtsum[idxargmax(nvtxs, graph->adjwgtsum)]); IFSET(ctrl->dbglvl, DBG_REFINE, mprintf("VolPart: [%5D %5D]-[%5D %5D], Balance: %3.2f, Nv-Nb[%5D %5D]. Cut: %5D, Vol: %5D [B]\n", pwgts[idxargmin(nparts, pwgts)], pwgts[idxargmax(nparts, pwgts)], minwgt[0], maxwgt[0], 1.0*nparts*pwgts[idxargmax(nparts, pwgts)]/tvwgt, graph->nvtxs, graph->nbnd, graph->mincut, graph->minvol)); for (pass=0; passmincut); /* Check to see if things are out of balance, given the tolerance */ for (i=0; i maxwgt[i]) break; } if (i == nparts) /* Things are balanced. Return right away */ break; PQueueReset(&queue); idxset(nvtxs, -1, moved); RandomPermute(graph->nbnd, perm, 1); for (ii=0; iinbnd; ii++) { i = bndind[perm[ii]]; PQueueInsert(&queue, i, graph->vrinfo[i].gv); moved[i] = 2; } maxndoms = ndoms[idxargmax(nparts, ndoms)]; for (nmoves=0;;) { if ((i = PQueueGetMax(&queue)) == -1) break; moved[i] = 1; myrinfo = graph->vrinfo+i; from = where[i]; vwgt = graph->vwgt[i]; if (pwgts[from]-vwgt < minwgt[from]) continue; /* This cannot be moved! */ xgain = (myrinfo->id == 0 && myrinfo->ed > 0 ? graph->vsize[i] : 0); myedegrees = myrinfo->edegrees; myndegrees = myrinfo->ndegrees; /* Determine the valid domains */ for (j=0; j maxndoms-1) { phtable[to] = 0; nadd = maxndoms; break; } nadd++; } } if (ndoms[to]+nadd > maxndoms) phtable[to] = 0; } for (k=0; k minwgt[to] && (xgain+myedegrees[k].gv < 0 || (xgain+myedegrees[k].gv == 0 && myedegrees[k].ed-myrinfo->id < 0)) ) continue; /*===================================================================== * If we got here, we can now move the vertex from 'from' to 'to' *======================================================================*/ INC_DEC(pwgts[to], pwgts[from], vwgt); graph->mincut -= myedegrees[k].ed-myrinfo->id; graph->minvol -= (xgain+myedegrees[k].gv); where[i] = to; IFSET(ctrl->dbglvl, DBG_MOVEINFO, mprintf("\t\tMoving %6D from %3D to %3D. Gain: [%4D %4D]. Cut: %6D, Vol: %6D\n", i, from, to, xgain+myedegrees[k].gv, myedegrees[k].ed-myrinfo->id, graph->mincut, graph->minvol)); /* Update pmat to reflect the move of 'i' */ pmat[from*nparts+to] += (myrinfo->id-myedegrees[k].ed); pmat[to*nparts+from] += (myrinfo->id-myedegrees[k].ed); if (pmat[from*nparts+to] == 0) { ndoms[from]--; if (ndoms[from]+1 == maxndoms) maxndoms = ndoms[idxargmax(nparts, ndoms)]; } if (pmat[to*nparts+from] == 0) { ndoms[to]--; if (ndoms[to]+1 == maxndoms) maxndoms = ndoms[idxargmax(nparts, ndoms)]; } for (j=xadj[i]; j maxndoms) { mprintf("You just increased the maxndoms: %D %D\n", ndoms[me], maxndoms); maxndoms = ndoms[me]; } } if (pmat[to*nparts+me] == 0) { ndoms[to]++; if (ndoms[to] > maxndoms) { mprintf("You just increased the maxndoms: %D %D\n", ndoms[to], maxndoms); maxndoms = ndoms[to]; } } pmat[me*nparts+to] += adjwgt[j]; pmat[to*nparts+me] += adjwgt[j]; } } KWayVolUpdate(ctrl, graph, i, from, to, marker, phtable, updind); nmoves++; /*CheckVolKWayPartitionParams(ctrl, graph, nparts); */ } IFSET(ctrl->dbglvl, DBG_REFINE, mprintf("\t[%6D %6D], Balance: %5.3f, Nb: %6D. Nmoves: %5D, Cut: %6D, Vol: %6D\n", pwgts[idxargmin(nparts, pwgts)], pwgts[idxargmax(nparts, pwgts)], 1.0*nparts*pwgts[idxargmax(nparts, pwgts)]/tvwgt, graph->nbnd, nmoves, graph->mincut, graph->minvol)); } gk_free((void **)&marker, &updind, &phtable, LTERM); PQueueFree(ctrl, &queue); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); } /************************************************************************* * This function updates the edge and volume gains as a result of moving * v from 'from' to 'to'. * The working arrays marker and phtable are agk_fsumed to be initialized to * -1, and they left to -1 upon return **************************************************************************/ void KWayVolUpdate(CtrlType *ctrl, GraphType *graph, idxtype v, idxtype from, idxtype to, idxtype *marker, idxtype *phtable, idxtype *updind) { idxtype ii, iii, j, jj, k, kk, l, u, nupd, other, me, myidx; idxtype *xadj, *vsize, *adjncy, *adjwgt, *where; VEDegreeType *myedegrees, *oedegrees; VRInfoType *myrinfo, *orinfo; xadj = graph->xadj; adjncy = graph->adjncy; adjwgt = graph->adjwgt; vsize = graph->vsize; where = graph->where; myrinfo = graph->vrinfo+v; myedegrees = myrinfo->edegrees; /*====================================================================== * Remove the contributions on the gain made by 'v'. *=====================================================================*/ for (k=0; kndegrees; k++) phtable[myedegrees[k].pid] = k; phtable[from] = k; myidx = phtable[to]; /* Keep track of the index in myedegrees of the 'to' domain */ for (j=xadj[v]; jvrinfo+ii; oedegrees = orinfo->edegrees; if (other == from) { for (k=0; kndegrees; k++) { if (phtable[oedegrees[k].pid] == -1) oedegrees[k].gv += vsize[v]; } } else { ASSERT(phtable[other] != -1); if (myedegrees[phtable[other]].ned > 1) { for (k=0; kndegrees; k++) { if (phtable[oedegrees[k].pid] == -1) oedegrees[k].gv += vsize[v]; } } else { /* There is only one connection */ for (k=0; kndegrees; k++) { if (phtable[oedegrees[k].pid] != -1) oedegrees[k].gv -= vsize[v]; } } } } for (k=0; kndegrees; k++) phtable[myedegrees[k].pid] = -1; phtable[from] = -1; /*====================================================================== * Update the id/ed of vertex 'v' *=====================================================================*/ myrinfo->ed += myrinfo->id-myedegrees[myidx].ed; SWAP(myrinfo->id, myedegrees[myidx].ed, j); SWAP(myrinfo->nid, myedegrees[myidx].ned, j); if (myedegrees[myidx].ed == 0) myedegrees[myidx] = myedegrees[--myrinfo->ndegrees]; else myedegrees[myidx].pid = from; /*====================================================================== * Update the degrees of adjacent vertices and their volume gains *=====================================================================*/ marker[v] = 1; updind[0] = v; nupd = 1; for (j=xadj[v]; jvrinfo+ii; if (myrinfo->edegrees == NULL) { myrinfo->edegrees = ctrl->wspace.vedegrees+ctrl->wspace.cdegree; ctrl->wspace.cdegree += xadj[ii+1]-xadj[ii]; } myedegrees = myrinfo->edegrees; if (me == from) { INC_DEC(myrinfo->ed, myrinfo->id, adjwgt[j]); myrinfo->nid--; } else if (me == to) { INC_DEC(myrinfo->id, myrinfo->ed, adjwgt[j]); myrinfo->nid++; } /* Remove the edgeweight from the 'pid == from' entry of the vertex */ if (me != from) { for (k=0; kndegrees; k++) { if (myedegrees[k].pid == from) { if (myedegrees[k].ned == 1) { myedegrees[k] = myedegrees[--myrinfo->ndegrees]; marker[ii] = 1; /* You do a complete .gv calculation */ /* All vertices adjacent to 'ii' need to be updated */ for (jj=xadj[ii]; jjvrinfo+u; oedegrees = orinfo->edegrees; for (kk=0; kkndegrees; kk++) { if (oedegrees[kk].pid == from) { oedegrees[kk].gv -= vsize[ii]; break; } } } } else { myedegrees[k].ed -= adjwgt[j]; myedegrees[k].ned--; /* Update the gv due to single 'ii' connection to 'from' */ if (myedegrees[k].ned == 1) { /* find the vertex 'u' that 'ii' was connected into 'from' */ for (jj=xadj[ii]; jjvrinfo+u; oedegrees = orinfo->edegrees; if (other == from) { for (kk=0; kkndegrees; kk++) oedegrees[kk].gv += vsize[ii]; break; } } } } break; } } } /* Add the edgeweight to the 'pid == to' entry of the vertex */ if (me != to) { for (k=0; kndegrees; k++) { if (myedegrees[k].pid == to) { myedegrees[k].ed += adjwgt[j]; myedegrees[k].ned++; /* Update the gv due to non-single 'ii' connection to 'to' */ if (myedegrees[k].ned == 2) { /* find the vertex 'u' that 'ii' was connected into 'to' */ for (jj=xadj[ii]; jjvrinfo+u; oedegrees = orinfo->edegrees; if (u != v && other == to) { for (kk=0; kkndegrees; kk++) oedegrees[kk].gv -= vsize[ii]; break; } } } break; } } if (k == myrinfo->ndegrees) { myedegrees[myrinfo->ndegrees].pid = to; myedegrees[myrinfo->ndegrees].ed = adjwgt[j]; myedegrees[myrinfo->ndegrees++].ned = 1; marker[ii] = 1; /* You do a complete .gv calculation */ /* All vertices adjacent to 'ii' need to be updated */ for (jj=xadj[ii]; jjvrinfo+u; oedegrees = orinfo->edegrees; for (kk=0; kkndegrees; kk++) { if (oedegrees[kk].pid == to) { oedegrees[kk].gv += vsize[ii]; if (!marker[u]) { /* Need to update boundary etc */ marker[u] = 2; updind[nupd++] = u; } break; } } } } } ASSERT(myrinfo->ndegrees <= xadj[ii+1]-xadj[ii]); } /*====================================================================== * Add the contributions on the volume gain due to 'v' *=====================================================================*/ myrinfo = graph->vrinfo+v; myedegrees = myrinfo->edegrees; for (k=0; kndegrees; k++) phtable[myedegrees[k].pid] = k; phtable[to] = k; for (j=xadj[v]; jvrinfo+ii; oedegrees = orinfo->edegrees; if (other == to) { for (k=0; kndegrees; k++) { if (phtable[oedegrees[k].pid] == -1) oedegrees[k].gv -= vsize[v]; } } else { ASSERT(phtable[other] != -1); if (myedegrees[phtable[other]].ned > 1) { for (k=0; kndegrees; k++) { if (phtable[oedegrees[k].pid] == -1) oedegrees[k].gv -= vsize[v]; } } else { /* There is only one connection */ for (k=0; kndegrees; k++) { if (phtable[oedegrees[k].pid] != -1) oedegrees[k].gv += vsize[v]; } } } } for (k=0; kndegrees; k++) phtable[myedegrees[k].pid] = -1; phtable[to] = -1; /*====================================================================== * Recompute the volume information of the 'hard' nodes, and update the * max volume gain for all the update vertices *=====================================================================*/ ComputeKWayVolume(graph, nupd, updind, marker, phtable); /*====================================================================== * Maintain a consistent boundary *=====================================================================*/ for (j=0; jvrinfo+k; if ((myrinfo->gv >= 0 || myrinfo->ed-myrinfo->id >= 0) && graph->bndptr[k] == -1) BNDInsert(graph->nbnd, graph->bndind, graph->bndptr, k); if (myrinfo->gv < 0 && myrinfo->ed-myrinfo->id < 0 && graph->bndptr[k] != -1) BNDDelete(graph->nbnd, graph->bndind, graph->bndptr, k); } } /************************************************************************* * This function computes the initial id/ed **************************************************************************/ void ComputeKWayVolume(GraphType *graph, idxtype nupd, idxtype *updind, idxtype *marker, idxtype *phtable) { idxtype ii, iii, i, j, k, kk, l, nvtxs, me, other, pid; idxtype *xadj, *vsize, *adjncy, *adjwgt, *where; VRInfoType *rinfo, *myrinfo, *orinfo; VEDegreeType *myedegrees, *oedegrees; nvtxs = graph->nvtxs; xadj = graph->xadj; vsize = graph->vsize; adjncy = graph->adjncy; adjwgt = graph->adjwgt; where = graph->where; rinfo = graph->vrinfo; /*------------------------------------------------------------ / Compute now the iv/ev degrees /------------------------------------------------------------*/ for (iii=0; iiiedegrees; if (marker[i] == 1) { /* Only complete gain updates go through */ for (k=0; kndegrees; k++) myedegrees[k].gv = 0; for (j=xadj[i]; jedegrees; for (kk=0; kkndegrees; kk++) phtable[oedegrees[kk].pid] = kk; phtable[other] = 1; if (me == other) { /* Find which domains 'i' is connected and 'ii' is not and update their gain */ for (k=0; kndegrees; k++) { if (phtable[myedegrees[k].pid] == -1) myedegrees[k].gv -= vsize[ii]; } } else { ASSERT(phtable[me] != -1); /* I'm the only connection of 'ii' in 'me' */ if (oedegrees[phtable[me]].ned == 1) { /* Increase the gains for all the common domains between 'i' and 'ii' */ for (k=0; kndegrees; k++) { if (phtable[myedegrees[k].pid] != -1) myedegrees[k].gv += vsize[ii]; } } else { /* Find which domains 'i' is connected and 'ii' is not and update their gain */ for (k=0; kndegrees; k++) { if (phtable[myedegrees[k].pid] == -1) myedegrees[k].gv -= vsize[ii]; } } } for (kk=0; kkndegrees; kk++) phtable[oedegrees[kk].pid] = -1; phtable[other] = -1; } } myrinfo->gv = -MAXIDX; for (k=0; kndegrees; k++) { if (myedegrees[k].gv > myrinfo->gv) myrinfo->gv = myedegrees[k].gv; } if (myrinfo->ed > 0 && myrinfo->id == 0) myrinfo->gv += vsize[i]; } } /************************************************************************* * This function computes the total volume **************************************************************************/ idxtype ComputeVolume(GraphType *graph, idxtype *where) { idxtype i, j, k, me, nvtxs, nparts, totalv; idxtype *xadj, *adjncy, *vsize, *marker; nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; vsize = (graph->vsize == NULL ? graph->vwgt : graph->vsize); nparts = where[idxargmax(nvtxs, where)]+1; marker = idxsmalloc(nparts, -1, "ComputeVolume: marker"); totalv = 0; for (i=0; invtxs; xadj = graph->xadj; vsize = graph->vsize; adjncy = graph->adjncy; adjwgt = graph->adjwgt; where = graph->where; rinfo = graph->vrinfo; tmpdegrees = (VEDegreeType *)gk_malloc(nparts*sizeof(VEDegreeType), "CheckVolKWayPartitionParams: tmpdegrees"); /*------------------------------------------------------------ / Compute now the iv/ev degrees /------------------------------------------------------------*/ for (i=0; iedegrees; for (k=0; kndegrees; k++) tmpdegrees[k] = myedegrees[k]; tmprinfo.ndegrees = myrinfo->ndegrees; tmprinfo.id = myrinfo->id; tmprinfo.ed = myrinfo->ed; myrinfo = &tmprinfo; myedegrees = tmpdegrees; for (k=0; kndegrees; k++) myedegrees[k].gv = 0; for (j=xadj[i]; jedegrees; if (me == other) { /* Find which domains 'i' is connected and 'ii' is not and update their gain */ for (k=0; kndegrees; k++) { pid = myedegrees[k].pid; for (kk=0; kkndegrees; kk++) { if (oedegrees[kk].pid == pid) break; } if (kk == orinfo->ndegrees) myedegrees[k].gv -= vsize[ii]; } } else { /* Find the orinfo[me].ed and see if I'm the only connection */ for (k=0; kndegrees; k++) { if (oedegrees[k].pid == me) break; } if (oedegrees[k].ned == 1) { /* I'm the only connection of 'ii' in 'me' */ for (k=0; kndegrees; k++) { if (myedegrees[k].pid == other) { myedegrees[k].gv += vsize[ii]; break; } } /* Increase the gains for all the common domains between 'i' and 'ii' */ for (k=0; kndegrees; k++) { if ((pid = myedegrees[k].pid) == other) continue; for (kk=0; kkndegrees; kk++) { if (oedegrees[kk].pid == pid) { myedegrees[k].gv += vsize[ii]; break; } } } } else { /* Find which domains 'i' is connected and 'ii' is not and update their gain */ for (k=0; kndegrees; k++) { if ((pid = myedegrees[k].pid) == other) continue; for (kk=0; kkndegrees; kk++) { if (oedegrees[kk].pid == pid) break; } if (kk == orinfo->ndegrees) myedegrees[k].gv -= vsize[ii]; } } } } myrinfo = rinfo+i; myedegrees = myrinfo->edegrees; for (k=0; kndegrees; k++) { pid = myedegrees[k].pid; for (kk=0; kknvtxs; xadj = graph->xadj; adjncy = graph->adjncy; adjwgt = graph->adjwgt; where = graph->where; rinfo = graph->vrinfo; idxset(nparts*nparts, 0, pmat); for (i=0; i 0) { me = where[i]; ndegrees = rinfo[i].ndegrees; edegrees = rinfo[i].edegrees; k = me*nparts; for (j=0; j 0) ndoms[i]++; } } } /************************************************************************* * This function computes the subdomain graph **************************************************************************/ void EliminateVolSubDomainEdges(CtrlType *ctrl, GraphType *graph, idxtype nparts, float *tpwgts) { idxtype i, ii, j, k, me, other, nvtxs, total, max, avg, totalout, nind, ncand, ncand2, target, target2, nadd; idxtype min, move, cpwgt, tvwgt; idxtype *xadj, *adjncy, *vwgt, *adjwgt, *pwgts, *where, *maxpwgt, *pmat, *ndoms, *mypmat, *otherpmat, *ind; KeyValueType *cand, *cand2; nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; vwgt = graph->vwgt; adjwgt = graph->adjwgt; where = graph->where; pwgts = idxset(nparts, 0, graph->pwgts); maxpwgt = idxwspacemalloc(ctrl, nparts); ndoms = idxwspacemalloc(ctrl, nparts); otherpmat = idxwspacemalloc(ctrl, nparts); ind = idxwspacemalloc(ctrl, nvtxs); pmat = idxset(nparts*nparts, 0, ctrl->wspace.pmat); cand = (KeyValueType *)gk_malloc(nparts*sizeof(KeyValueType), "EliminateSubDomainEdges: cand"); cand2 = (KeyValueType *)gk_malloc(nparts*sizeof(KeyValueType), "EliminateSubDomainEdges: cand"); /* Compute the pmat matrix */ for (i=0; i 0) k++; } ndoms[i] = k; } /* Get into the loop eliminating subdomain connections */ for (;;) { total = idxsum(nparts, ndoms, 1); avg = total/nparts; max = ndoms[idxargmax(nparts, ndoms)]; /* mprintf("Adjacent Subdomain Stats: Total: %3D, Max: %3D, Avg: %3D\n", total, max, avg); */ if (max < 1.5*avg) break; me = idxargmax(nparts, ndoms); mypmat = pmat + me*nparts; totalout = idxsum(nparts, mypmat, 1); /*mprintf("Me: %D, TotalOut: %D,\n", me, totalout);*/ /* Sort the connections according to their cut */ for (ncand2=0, i=0; i 0) { cand2[ncand2].key = mypmat[i]; cand2[ncand2++].val = i; } } ikeysort(ncand2, cand2); move = 0; for (min=0; min totalout/(2*ndoms[me])) break; other = cand2[min].val; /*mprintf("\tMinOut: %D to %D\n", mypmat[other], other);*/ idxset(nparts, 0, otherpmat); /* Go and find the vertices in 'other' that are connected in 'me' */ for (nind=0, i=0; i 0) { cand[ncand].key = -otherpmat[i]; cand[ncand++].val = i; } } ikeysort(ncand, cand); /* * Go through and the select the first domain that is common with 'me', and * does not increase the ndoms[target] higher than my ndoms, subject to the * maxpwgt constraint. Traversal is done from the mostly connected to the least. */ target = target2 = -1; for (i=0; i 0) { if (pwgts[k] + cpwgt > maxpwgt[k]) /* Check if balance will go off */ continue; for (j=0; j 0 && ndoms[j] >= ndoms[me]-1 && pmat[nparts*j+k] == 0) break; } if (j == nparts) { /* No bad second level effects */ for (nadd=0, j=0; j 0 && pmat[nparts*k+j] == 0) nadd++; } /*mprintf("\t\tto=%D, nadd=%D, %D\n", k, nadd, ndoms[k]);*/ if (target2 == -1 && ndoms[k]+nadd < ndoms[me]) { target2 = k; } if (nadd == 0) { target = k; break; } } } } if (target == -1 && target2 != -1) target = target2; if (target == -1) { /* mprintf("\t\tCould not make the move\n");*/ continue; } /*mprintf("\t\tMoving to %D\n", target);*/ /* Update the partition weights */ INC_DEC(pwgts[target], pwgts[other], cpwgt); /* Set all nind vertices to belong to 'target' */ for (ii=0; iiwhere and tries to push them around to * remove some of them **************************************************************************/ void EliminateVolComponents(CtrlType *ctrl, GraphType *graph, idxtype nparts, float *tpwgts, float ubfactor) { idxtype i, ii, j, jj, k, me, nvtxs, tvwgt, first, last, nleft, ncmps, cwgt, ncand, other, target, deltawgt; idxtype *xadj, *adjncy, *vwgt, *adjwgt, *where, *pwgts, *maxpwgt; idxtype *cpvec, *touched, *perm, *todo, *cind, *cptr, *npcmps; KeyValueType *cand; idxtype recompute=0; nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; vwgt = graph->vwgt; adjwgt = graph->adjwgt; where = graph->where; pwgts = idxset(nparts, 0, graph->pwgts); touched = idxset(nvtxs, 0, idxwspacemalloc(ctrl, nvtxs)); cptr = idxwspacemalloc(ctrl, nvtxs+1); cind = idxwspacemalloc(ctrl, nvtxs); perm = idxwspacemalloc(ctrl, nvtxs); todo = idxwspacemalloc(ctrl, nvtxs); maxpwgt = idxwspacemalloc(ctrl, nparts); cpvec = idxwspacemalloc(ctrl, nparts); npcmps = idxset(nparts, 0, idxwspacemalloc(ctrl, nparts)); for (i=0; i 0) { if (first == last) { /* Find another starting vertex */ cptr[++ncmps] = first; ASSERT(touched[todo[0]] == 0); i = todo[0]; cind[last++] = i; touched[i] = 1; me = where[i]; npcmps[me]++; } i = cind[first++]; k = perm[i]; j = todo[k] = todo[--nleft]; perm[j] = k; for (j=xadj[i]; j nparts) { /* There are more components than processors */ cand = (KeyValueType *)gk_malloc(nparts*sizeof(KeyValueType), "EliminateSubDomainEdges: cand"); /* First determine the partition sizes and max allowed load imbalance */ for (i=0; i .30*pwgts[me]) continue; /* Skip the component if it is over 30% of the weight */ for (ncand=0, j=0; j 0) { cand[ncand].key = -cpvec[j]; cand[ncand++].val = j; } } if (ncand == 0) continue; ikeysort(ncand, cand); target = -1; for (j=0; jmincut -= cpvec[target]; recompute = 1; } } gk_free((void **)&cand, LTERM); } if (recompute) { idxtype ttlv; idxtype *marker; marker = idxset(nparts, -1, cpvec); for (ttlv=0, i=0; ivsize[i]; marker[where[adjncy[j]]] = i; } } } graph->minvol = ttlv; } idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs+1); } PyMetis-0.90/src/metis/kwayvolrefine.c0000640000175000017500000003316310662171744017623 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * kwayvolrefine.c * * This file contains the driving routines for multilevel k-way refinement * * Started 7/28/97 * George * * $Id: kwayvolrefine.c,v 1.2 2002/08/10 06:29:31 karypis Exp $ */ #include /************************************************************************* * This function is the entry point of refinement **************************************************************************/ void RefineVolKWay(CtrlType *ctrl, GraphType *orggraph, GraphType *graph, idxtype nparts, float *tpwgts, float ubfactor) { idxtype i, nlevels; GraphType *ptr; IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->UncoarsenTmr)); /* Take care any non-contiguity */ if (ctrl->RType == RTYPE_KWAYRANDOM_MCONN) { ComputeVolKWayPartitionParams(ctrl, graph, nparts); EliminateVolComponents(ctrl, graph, nparts, tpwgts, 1.25); EliminateVolSubDomainEdges(ctrl, graph, nparts, tpwgts); EliminateVolComponents(ctrl, graph, nparts, tpwgts, 1.25); } /* Determine how many levels are there */ for (ptr=graph, nlevels=0; ptr!=orggraph; ptr=ptr->finer, nlevels++); /* Compute the parameters of the coarsest graph */ ComputeVolKWayPartitionParams(ctrl, graph, nparts); for (i=0; ;i++) { /*PrintSubDomainGraph(graph, nparts, graph->where);*/ MALLOC_CHECK(NULL); IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->RefTmr)); if (2*i >= nlevels && !IsBalanced(graph->pwgts, nparts, tpwgts, 1.04*ubfactor)) { ComputeVolKWayBalanceBoundary(ctrl, graph, nparts); switch (ctrl->RType) { case RTYPE_KWAYRANDOM: Greedy_KWayVolBalance(ctrl, graph, nparts, tpwgts, ubfactor, 1); break; case RTYPE_KWAYRANDOM_MCONN: Greedy_KWayVolBalanceMConn(ctrl, graph, nparts, tpwgts, ubfactor, 1); break; } ComputeVolKWayBoundary(ctrl, graph, nparts); } switch (ctrl->RType) { case RTYPE_KWAYRANDOM: Random_KWayVolRefine(ctrl, graph, nparts, tpwgts, ubfactor, 10, 0); break; case RTYPE_KWAYRANDOM_MCONN: Random_KWayVolRefineMConn(ctrl, graph, nparts, tpwgts, ubfactor, 10, 0); break; } IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->RefTmr)); if (graph == orggraph) break; graph = graph->finer; IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->ProjectTmr)); ProjectVolKWayPartition(ctrl, graph, nparts); IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->ProjectTmr)); } if (!IsBalanced(graph->pwgts, nparts, tpwgts, ubfactor)) { ComputeVolKWayBalanceBoundary(ctrl, graph, nparts); switch (ctrl->RType) { case RTYPE_KWAYRANDOM: Greedy_KWayVolBalance(ctrl, graph, nparts, tpwgts, ubfactor, 8); Random_KWayVolRefine(ctrl, graph, nparts, tpwgts, ubfactor, 10, 0); break; case RTYPE_KWAYRANDOM_MCONN: Greedy_KWayVolBalanceMConn(ctrl, graph, nparts, tpwgts, ubfactor, 8); Random_KWayVolRefineMConn(ctrl, graph, nparts, tpwgts, ubfactor, 10, 0); break; } } EliminateVolComponents(ctrl, graph, nparts, tpwgts, ubfactor); IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->UncoarsenTmr)); } /************************************************************************* * This function allocates memory for k-way edge refinement **************************************************************************/ void AllocateVolKWayPartitionMemory(CtrlType *ctrl, GraphType *graph, idxtype nparts) { idxtype nvtxs; nvtxs = graph->nvtxs; graph->pwgts = idxmalloc(nparts, "AllocateVolKWayPartitionMemory: pwgts"); graph->where = idxmalloc(nvtxs, "AllocateVolKWayPartitionMemory: pwgts"); graph->bndptr = idxmalloc(nvtxs, "AllocateVolKWayPartitionMemory: pwgts"); graph->bndind = idxmalloc(nvtxs, "AllocateVolKWayPartitionMemory: pwgts"); graph->vrinfo = (VRInfoType *)gk_malloc(nvtxs*sizeof(VRInfoType), "AllocateVolKWayPartitionMemory: vrinfo"); } /************************************************************************* * This function computes the initial id/ed **************************************************************************/ void ComputeVolKWayPartitionParams(CtrlType *ctrl, GraphType *graph, idxtype nparts) { idxtype i, ii, j, k, kk, l, nvtxs, nbnd, mincut, minvol, me, other, pid; idxtype *xadj, *vwgt, *adjncy, *adjwgt, *pwgts, *where; VRInfoType *rinfo, *myrinfo, *orinfo; VEDegreeType *myedegrees, *oedegrees; nvtxs = graph->nvtxs; xadj = graph->xadj; vwgt = graph->vwgt; adjncy = graph->adjncy; adjwgt = graph->adjwgt; where = graph->where; pwgts = idxset(nparts, 0, graph->pwgts); rinfo = graph->vrinfo; /*------------------------------------------------------------ / Compute now the id/ed degrees /------------------------------------------------------------*/ ctrl->wspace.cdegree = 0; mincut = 0; for (i=0; iid = myrinfo->ed = myrinfo->nid = myrinfo->ndegrees = 0; myrinfo->edegrees = NULL; for (j=xadj[i]; jid += adjwgt[j]; myrinfo->nid++; } } myrinfo->ed = graph->adjwgtsum[i] - myrinfo->id; mincut += myrinfo->ed; /* Time to compute the particular external degrees */ if (myrinfo->ed > 0) { myedegrees = myrinfo->edegrees = ctrl->wspace.vedegrees+ctrl->wspace.cdegree; ctrl->wspace.cdegree += xadj[i+1]-xadj[i]; for (j=xadj[i]; jndegrees; k++) { if (myedegrees[k].pid == other) { myedegrees[k].ed += adjwgt[j]; myedegrees[k].ned++; break; } } if (k == myrinfo->ndegrees) { myedegrees[myrinfo->ndegrees].gv = 0; myedegrees[myrinfo->ndegrees].pid = other; myedegrees[myrinfo->ndegrees].ed = adjwgt[j]; myedegrees[myrinfo->ndegrees++].ned = 1; } } } ASSERT(myrinfo->ndegrees <= xadj[i+1]-xadj[i]); } } graph->mincut = mincut/2; ComputeKWayVolGains(ctrl, graph, nparts); } /************************************************************************* * This function computes the initial id/ed **************************************************************************/ void ComputeKWayVolGains(CtrlType *ctrl, GraphType *graph, idxtype nparts) { idxtype i, ii, j, k, kk, l, nvtxs, me, other, pid, myndegrees; idxtype *xadj, *vsize, *adjncy, *adjwgt, *where, *bndind, *bndptr, *ophtable; VRInfoType *rinfo, *myrinfo, *orinfo; VEDegreeType *myedegrees, *oedegrees; nvtxs = graph->nvtxs; xadj = graph->xadj; vsize = graph->vsize; adjncy = graph->adjncy; adjwgt = graph->adjwgt; where = graph->where; bndind = graph->bndind; bndptr = idxset(nvtxs, -1, graph->bndptr); rinfo = graph->vrinfo; ophtable = idxset(nparts, -1, idxwspacemalloc(ctrl, nparts)); /*------------------------------------------------------------ / Compute now the iv/ev degrees /------------------------------------------------------------*/ graph->minvol = graph->nbnd = 0; for (i=0; igv = -MAXIDX; if (myrinfo->ndegrees > 0) { me = where[i]; myedegrees = myrinfo->edegrees; myndegrees = myrinfo->ndegrees; graph->minvol += myndegrees*vsize[i]; for (j=xadj[i]; jedegrees; for (k=0; kndegrees; k++) ophtable[oedegrees[k].pid] = k; ophtable[other] = 1; /* this is to simplify coding */ if (me == other) { /* Find which domains 'i' is connected and 'ii' is not and update their gain */ for (k=0; kndegrees; kk++) ophtable[oedegrees[kk].pid] = -1; ophtable[other] = -1; } /* Compute the max vgain */ for (k=0; k myrinfo->gv) myrinfo->gv = myedegrees[k].gv; } } if (myrinfo->ed > 0 && myrinfo->id == 0) myrinfo->gv += vsize[i]; if (myrinfo->gv >= 0 || myrinfo->ed-myrinfo->id >= 0) BNDInsert(graph->nbnd, bndind, bndptr, i); } idxwspacefree(ctrl, nparts); } /************************************************************************* * This function projects a partition, and at the same time computes the * parameters for refinement. **************************************************************************/ void ProjectVolKWayPartition(CtrlType *ctrl, GraphType *graph, idxtype nparts) { idxtype i, j, k, nvtxs, me, other, istart, iend, ndegrees; idxtype *xadj, *adjncy, *adjwgt, *adjwgtsum; idxtype *cmap, *where; idxtype *cwhere; GraphType *cgraph; VRInfoType *crinfo, *rinfo, *myrinfo; VEDegreeType *myedegrees; idxtype *htable; cgraph = graph->coarser; cwhere = cgraph->where; crinfo = cgraph->vrinfo; nvtxs = graph->nvtxs; cmap = graph->cmap; xadj = graph->xadj; adjncy = graph->adjncy; adjwgt = graph->adjwgt; adjwgtsum = graph->adjwgtsum; AllocateVolKWayPartitionMemory(ctrl, graph, nparts); where = graph->where; rinfo = graph->vrinfo; /* Go through and project partition and compute id/ed for the nodes */ for (i=0; iwspace.cdegree = 0; for (i=0; iid = myrinfo->ed = myrinfo->nid = myrinfo->ndegrees = 0; myrinfo->edegrees = NULL; myrinfo->id = adjwgtsum[i]; myrinfo->nid = xadj[i+1]-xadj[i]; if (cmap[i] > 0) { /* If it is an interface node. Note cmap[i] = crinfo[cmap[i]].ed */ istart = xadj[i]; iend = xadj[i+1]; myedegrees = myrinfo->edegrees = ctrl->wspace.vedegrees+ctrl->wspace.cdegree; ctrl->wspace.cdegree += iend-istart; ndegrees = 0; for (j=istart; jed += adjwgt[j]; myrinfo->nid--; if ((k = htable[other]) == -1) { htable[other] = ndegrees; myedegrees[ndegrees].gv = 0; myedegrees[ndegrees].pid = other; myedegrees[ndegrees].ed = adjwgt[j]; myedegrees[ndegrees++].ned = 1; } else { myedegrees[k].ed += adjwgt[j]; myedegrees[k].ned++; } } } myrinfo->id -= myrinfo->ed; /* Remove space for edegrees if it was interior */ if (myrinfo->ed == 0) { myrinfo->edegrees = NULL; ctrl->wspace.cdegree -= iend-istart; } else { myrinfo->ndegrees = ndegrees; for (j=0; jpwgts, graph->pwgts); graph->mincut = cgraph->mincut; FreeGraph(graph->coarser, 1); graph->coarser = NULL; idxwspacefree(ctrl, nparts); } /************************************************************************* * This function computes the boundary definition for balancing **************************************************************************/ void ComputeVolKWayBoundary(CtrlType *ctrl, GraphType *graph, idxtype nparts) { idxtype i, nvtxs, nbnd; idxtype *bndind, *bndptr; nvtxs = graph->nvtxs; bndind = graph->bndind; bndptr = idxset(nvtxs, -1, graph->bndptr); /*------------------------------------------------------------ / Compute the new boundary /------------------------------------------------------------*/ nbnd = 0; for (i=0; ivrinfo[i].gv >=0 || graph->vrinfo[i].ed-graph->vrinfo[i].id >= 0) BNDInsert(nbnd, bndind, bndptr, i); } graph->nbnd = nbnd; } /************************************************************************* * This function computes the boundary definition for balancing **************************************************************************/ void ComputeVolKWayBalanceBoundary(CtrlType *ctrl, GraphType *graph, idxtype nparts) { idxtype i, nvtxs, nbnd; idxtype *bndind, *bndptr; nvtxs = graph->nvtxs; bndind = graph->bndind; bndptr = idxset(nvtxs, -1, graph->bndptr); /*------------------------------------------------------------ / Compute the new boundary /------------------------------------------------------------*/ nbnd = 0; for (i=0; ivrinfo[i].ed > 0) BNDInsert(nbnd, bndind, bndptr, i); } graph->nbnd = nbnd; } PyMetis-0.90/src/metis/macros.h0000640000175000017500000000304710662171744016225 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * macros.h * * This file contains macros used in multilevel * * Started 9/25/94 * George * * $Id: macros.h,v 1.6 2003/04/30 12:42:05 karypis Exp $ * */ /************************************************************************* * The following macro returns a random number in the specified range **************************************************************************/ #define AND(a, b) ((a) < 0 ? ((-(a))&(b)) : ((a)&(b))) #define OR(a, b) ((a) < 0 ? -((-(a))|(b)) : ((a)|(b))) #define XOR(a, b) ((a) < 0 ? -((-(a))^(b)) : ((a)^(b))) #define idxcopy(n, a, b) (idxtype *)memcpy((void *)(b), (void *)(a), sizeof(idxtype)*(n)) #define HASHFCT(key, size) ((key)%(size)) /************************************************************************* * Datatype related macros **************************************************************************/ #define idxtype_abs(x) ((x) > 0 ? (x) : -(x)) /************************************************************************* * These macros insert and remove nodes from the boundary list **************************************************************************/ #define BNDInsert(nbnd, bndind, bndptr, vtx) \ do { \ ASSERT(bndptr[vtx] == -1); \ bndind[nbnd] = vtx; \ bndptr[vtx] = nbnd++;\ } while(0) #define BNDDelete(nbnd, bndind, bndptr, vtx) \ do { \ ASSERT(bndptr[vtx] != -1); \ bndind[bndptr[vtx]] = bndind[--nbnd]; \ bndptr[bndind[nbnd]] = bndptr[vtx]; \ bndptr[vtx] = -1; \ } while(0) PyMetis-0.90/src/metis/match.c0000640000175000017500000001547510662171744016040 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * match.c * * This file contains the code that computes matchings and creates the next * level coarse graph. * * Started 7/23/97 * George * * $Id: match.c,v 1.3 2003/07/31 15:49:43 karypis Exp $ * */ #include /************************************************************************* * This function finds a matching using the HEM heuristic **************************************************************************/ void Match_RM(CtrlType *ctrl, GraphType *graph) { idxtype i, ii, j, nvtxs, cnvtxs, maxidx; idxtype *xadj, *vwgt, *adjncy, *adjwgt; idxtype *match, *cmap, *perm; IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->MatchTmr)); nvtxs = graph->nvtxs; xadj = graph->xadj; vwgt = graph->vwgt; adjncy = graph->adjncy; adjwgt = graph->adjwgt; cmap = graph->cmap; match = idxset(nvtxs, UNMATCHED, idxwspacemalloc(ctrl, nvtxs)); perm = idxwspacemalloc(ctrl, nvtxs); RandomPermute(nvtxs, perm, 1); cnvtxs = 0; for (ii=0; iimaxvwgt) { maxidx = adjncy[j]; break; } } cmap[i] = cmap[maxidx] = cnvtxs++; match[i] = maxidx; match[maxidx] = i; } } IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->MatchTmr)); CreateCoarseGraph(ctrl, graph, cnvtxs, match, perm); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); } /************************************************************************* * This function finds a matching using the HEM heuristic **************************************************************************/ void Match_RM_NVW(CtrlType *ctrl, GraphType *graph) { idxtype i, ii, j, nvtxs, cnvtxs, maxidx; idxtype *xadj, *adjncy; idxtype *match, *cmap, *perm; IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->MatchTmr)); nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; cmap = graph->cmap; match = idxset(nvtxs, UNMATCHED, idxwspacemalloc(ctrl, nvtxs)); perm = idxwspacemalloc(ctrl, nvtxs); RandomPermute(nvtxs, perm, 1); cnvtxs = 0; for (ii=0; iidbglvl, DBG_TIME, gk_stopcputimer(ctrl->MatchTmr)); CreateCoarseGraph_NVW(ctrl, graph, cnvtxs, match, perm); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); } /************************************************************************* * This function finds a matching using the HEM heuristic **************************************************************************/ void Match_HEM(CtrlType *ctrl, GraphType *graph) { idxtype i, ii, j, k, nvtxs, cnvtxs, maxidx, maxwgt; idxtype *xadj, *vwgt, *adjncy, *adjwgt; idxtype *match, *cmap, *perm; IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->MatchTmr)); nvtxs = graph->nvtxs; xadj = graph->xadj; vwgt = graph->vwgt; adjncy = graph->adjncy; adjwgt = graph->adjwgt; cmap = graph->cmap; match = idxset(nvtxs, UNMATCHED, idxwspacemalloc(ctrl, nvtxs)); perm = idxwspacemalloc(ctrl, nvtxs); RandomPermute(nvtxs, perm, 1); cnvtxs = 0; for (ii=0; iimaxvwgt) { maxwgt = adjwgt[j]; maxidx = adjncy[j]; } } cmap[i] = cmap[maxidx] = cnvtxs++; match[i] = maxidx; match[maxidx] = i; } } IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->MatchTmr)); CreateCoarseGraph(ctrl, graph, cnvtxs, match, perm); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); } /************************************************************************* * This function finds a matching using the HEM heuristic **************************************************************************/ void Match_SHEM(CtrlType *ctrl, GraphType *graph) { idxtype i, ii, j, k, nvtxs, cnvtxs, maxidx, maxwgt, avgdegree; idxtype *xadj, *vwgt, *adjncy, *adjwgt; idxtype *match, *cmap, *degrees, *perm, *tperm; IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->MatchTmr)); nvtxs = graph->nvtxs; xadj = graph->xadj; vwgt = graph->vwgt; adjncy = graph->adjncy; adjwgt = graph->adjwgt; cmap = graph->cmap; match = idxset(nvtxs, UNMATCHED, idxwspacemalloc(ctrl, nvtxs)); perm = idxwspacemalloc(ctrl, nvtxs); tperm = idxwspacemalloc(ctrl, nvtxs); degrees = idxwspacemalloc(ctrl, nvtxs); RandomPermute(nvtxs, tperm, 1); avgdegree = 0.7*(xadj[nvtxs]/nvtxs); for (i=0; i avgdegree ? avgdegree : xadj[i+1]-xadj[i]); BucketSortKeysInc(nvtxs, avgdegree, degrees, tperm, perm); cnvtxs = 0; /* Take care any islands. Islands are matched with non-islands due to coarsening */ for (ii=0; iiii; j--) { k = perm[j]; if (match[k] == UNMATCHED && xadj[k] < xadj[k+1]) { maxidx = k; break; } } cmap[i] = cmap[maxidx] = cnvtxs++; match[i] = maxidx; match[maxidx] = i; } } /* Continue with normal matching */ for (; iimaxvwgt) { maxwgt = adjwgt[j]; maxidx = adjncy[j]; } } cmap[i] = cmap[maxidx] = cnvtxs++; match[i] = maxidx; match[maxidx] = i; } } IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->MatchTmr)); idxwspacefree(ctrl, nvtxs); /* degrees */ idxwspacefree(ctrl, nvtxs); /* tperm */ CreateCoarseGraph(ctrl, graph, cnvtxs, match, perm); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); } PyMetis-0.90/src/metis/mbalance.c0000640000175000017500000001745610662171744016507 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * mbalance.c * * This file contains code that is used to forcefully balance either * bisections or k-sections * * Started 7/29/97 * George * * $Id: mbalance.c,v 1.2 2002/08/10 06:29:31 karypis Exp $ * */ #include /************************************************************************* * This function is the entry point of the bisection balancing algorithms. **************************************************************************/ void MocBalance2Way(CtrlType *ctrl, GraphType *graph, float *tpwgts, float lbfactor) { if (Compute2WayHLoadImbalance(graph->ncon, graph->npwgts, tpwgts) < lbfactor) return; MocGeneral2WayBalance(ctrl, graph, tpwgts, lbfactor); } /************************************************************************* * This function performs an edge-based FM refinement **************************************************************************/ void MocGeneral2WayBalance(CtrlType *ctrl, GraphType *graph, float *tpwgts, float lbfactor) { idxtype i, ii, j, k, l, kwgt, nvtxs, ncon, nbnd, nswaps, from, to, pass, me, limit, tmp, cnum; idxtype *xadj, *adjncy, *adjwgt, *where, *id, *ed, *bndptr, *bndind; idxtype *moved, *swaps, *perm, *qnum; float *nvwgt, *npwgts, mindiff[MAXNCON], origbal, minbal, newbal; PQueueType parts[MAXNCON][2]; idxtype higain, oldgain, mincut, newcut, mincutorder; idxtype qsizes[MAXNCON][2]; nvtxs = graph->nvtxs; ncon = graph->ncon; xadj = graph->xadj; nvwgt = graph->nvwgt; adjncy = graph->adjncy; adjwgt = graph->adjwgt; where = graph->where; id = graph->id; ed = graph->ed; npwgts = graph->npwgts; bndptr = graph->bndptr; bndind = graph->bndind; moved = idxwspacemalloc(ctrl, nvtxs); swaps = idxwspacemalloc(ctrl, nvtxs); perm = idxwspacemalloc(ctrl, nvtxs); qnum = idxwspacemalloc(ctrl, nvtxs); limit = amin(amax(0.01*nvtxs, 15), 100); /* Initialize the queues */ for (i=0; i qsizes[j][from] && nvwgt[i*ncon+qnum[i]] < 1.3*nvwgt[i*ncon+j]) { qsizes[qnum[i]][from]--; qsizes[j][from]++; qnum[i] = j; } } } } } /* mprintf("Weight Distribution (after):\t "); for (i=0; imincut; mincutorder = -1; if (ctrl->dbglvl&DBG_REFINE) { mprintf("Parts: ["); for (l=0; lnvtxs, graph->nbnd, graph->mincut, origbal); } idxset(nvtxs, -1, moved); ASSERT(ComputeCut(graph, where) == graph->mincut); ASSERT(CheckBnd(graph)); /* Insert all nodes in the priority queues */ nbnd = graph->nbnd; RandomPermute(nvtxs, perm, 1); for (ii=0; ii limit) { /* We hit the limit, undo last move */ newcut += (ed[higain]-id[higain]); gk_faxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+from*ncon, 1); gk_faxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1); break; } where[higain] = to; moved[higain] = nswaps; swaps[nswaps] = higain; if (ctrl->dbglvl&DBG_MOVEINFO) { mprintf("Moved %6D from %D(%D). Gain: %5D, Cut: %5D, NPwgts: ", higain, from, cnum, ed[higain]-id[higain], newcut); for (l=0; l 0 && bndptr[higain] == -1) BNDInsert(nbnd, bndind, bndptr, higain); for (j=xadj[higain]; j 0 && bndptr[k] == -1) BNDInsert(nbnd, bndind, bndptr, k); } } /**************************************************************** * Roll back computations *****************************************************************/ for (nswaps--; nswaps>mincutorder; nswaps--) { higain = swaps[nswaps]; to = where[higain] = (where[higain]+1)%2; SWAP(id[higain], ed[higain], tmp); if (ed[higain] == 0 && bndptr[higain] != -1 && xadj[higain] < xadj[higain+1]) BNDDelete(nbnd, bndind, bndptr, higain); else if (ed[higain] > 0 && bndptr[higain] == -1) BNDInsert(nbnd, bndind, bndptr, higain); gk_faxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1); gk_faxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+((to+1)%2)*ncon, 1); for (j=xadj[higain]; j 0) BNDInsert(nbnd, bndind, bndptr, k); } } if (ctrl->dbglvl&DBG_REFINE) { mprintf("\tMincut: %6D at %5D, NBND: %6D, NPwgts: [", mincut, mincutorder, nbnd); for (l=0; lmincut = mincut; graph->nbnd = nbnd; for (i=0; i /************************************************************************* * This function is the entry point of the bisection balancing algorithms. **************************************************************************/ void MocBalance2Way2(CtrlType *ctrl, GraphType *graph, float *tpwgts, float *ubvec) { idxtype i; float tvec[MAXNCON]; Compute2WayHLoadImbalanceVec(graph->ncon, graph->npwgts, tpwgts, tvec); if (!AreAllBelow(graph->ncon, tvec, ubvec)) MocGeneral2WayBalance2(ctrl, graph, tpwgts, ubvec); } /************************************************************************* * This function performs an edge-based FM refinement **************************************************************************/ void MocGeneral2WayBalance2(CtrlType *ctrl, GraphType *graph, float *tpwgts, float *ubvec) { idxtype i, ii, j, k, l, kwgt, nvtxs, ncon, nbnd, nswaps, from, to, pass, me, limit, tmp, cnum; idxtype *xadj, *adjncy, *adjwgt, *where, *id, *ed, *bndptr, *bndind; idxtype *moved, *swaps, *perm, *qnum; float *nvwgt, *npwgts, origbal[MAXNCON], minbal[MAXNCON], newbal[MAXNCON]; PQueueType parts[MAXNCON][2]; idxtype higain, oldgain, mincut, newcut, mincutorder; float *maxwgt, *minwgt, tvec[MAXNCON]; nvtxs = graph->nvtxs; ncon = graph->ncon; xadj = graph->xadj; nvwgt = graph->nvwgt; adjncy = graph->adjncy; adjwgt = graph->adjwgt; where = graph->where; id = graph->id; ed = graph->ed; npwgts = graph->npwgts; bndptr = graph->bndptr; bndind = graph->bndind; moved = idxwspacemalloc(ctrl, nvtxs); swaps = idxwspacemalloc(ctrl, nvtxs); perm = idxwspacemalloc(ctrl, nvtxs); qnum = idxwspacemalloc(ctrl, nvtxs); limit = amin(amax(0.01*nvtxs, 15), 100); /* Setup the weight intervals of the two subdomains */ minwgt = fwspacemalloc(ctrl, 2*ncon); maxwgt = fwspacemalloc(ctrl, 2*ncon); for (i=0; i<2; i++) { for (j=0; jmincut; mincutorder = -1; if (ctrl->dbglvl&DBG_REFINE) { mprintf("Parts: ["); for (l=0; lnvtxs, graph->nbnd, graph->mincut); for (i=0; imincut); ASSERT(CheckBnd(graph)); /* Insert all nodes in the priority queues */ nbnd = graph->nbnd; RandomPermute(nvtxs, perm, 1); for (ii=0; ii limit) { /* We hit the limit, undo last move */ newcut += (ed[higain]-id[higain]); gk_faxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+from*ncon, 1); gk_faxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1); break; } where[higain] = to; moved[higain] = nswaps; swaps[nswaps] = higain; if (ctrl->dbglvl&DBG_MOVEINFO) { mprintf("Moved %6D from %D(%D). Gain: %5D, Cut: %5D, NPwgts: ", higain, from, cnum, ed[higain]-id[higain], newcut); for (i=0; i 0 && bndptr[higain] == -1) BNDInsert(nbnd, bndind, bndptr, higain); for (j=xadj[higain]; j 0 && bndptr[k] == -1) BNDInsert(nbnd, bndind, bndptr, k); } } /**************************************************************** * Roll back computations *****************************************************************/ for (i=0; imincutorder; nswaps--) { higain = swaps[nswaps]; to = where[higain] = (where[higain]+1)%2; SWAP(id[higain], ed[higain], tmp); if (ed[higain] == 0 && bndptr[higain] != -1 && xadj[higain] < xadj[higain+1]) BNDDelete(nbnd, bndind, bndptr, higain); else if (ed[higain] > 0 && bndptr[higain] == -1) BNDInsert(nbnd, bndind, bndptr, higain); gk_faxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1); gk_faxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+((to+1)%2)*ncon, 1); for (j=xadj[higain]; j 0) BNDInsert(nbnd, bndind, bndptr, k); } } if (ctrl->dbglvl&DBG_REFINE) { mprintf("\tMincut: %6D at %5D, NBND: %6D, NPwgts: [", mincut, mincutorder, nbnd); for (i=0; imincut = mincut; graph->nbnd = nbnd; for (i=0; i= maxdiff) { maxdiff = diff; *from = j; *cnum = i; } } } /* DELETE j = *from; for (i=0; i 0) { maxdiff = (npwgts[(*from)*ncon+i] - maxwgt[(*from)*ncon+i]); *cnum = i; break; } } for (i++; i maxdiff && PQueueGetSize(&queues[i][*from]) > 0) { maxdiff = diff; *cnum = i; } } } /* If the constraints ar OK, select a high gain vertex */ if (*from == -1) { maxgain = -100000; for (j=0; j<2; j++) { for (i=0; i 0 && PQueueGetKey(&queues[i][j]) > maxgain) { maxgain = PQueueGetKey(&queues[i][0]); *from = j; *cnum = i; } } } /* mprintf("(%2D %2D) %3D\n", *from, *cnum, maxgain); */ } } PyMetis-0.90/src/metis/mcoarsen.c0000640000175000017500000000515110662171744016541 0ustar andreasandreas/* * mcoarsen.c * * This file contains the driving routines for the coarsening process * * Started 7/23/97 * George * * $Id: mcoarsen.c,v 1.3 2003/07/31 15:52:47 karypis Exp $ * */ #include /************************************************************************* * This function takes a graph and creates a sequence of coarser graphs **************************************************************************/ GraphType *MCCoarsen2Way(CtrlType *ctrl, GraphType *graph) { idxtype i, clevel; GraphType *cgraph; IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->CoarsenTmr)); cgraph = graph; clevel = 0; do { if (ctrl->dbglvl&DBG_COARSEN) { mprintf("%6D %7D %10D [%D] [%6.4f", cgraph->nvtxs, cgraph->nedges, idxsum(cgraph->nvtxs, cgraph->adjwgtsum, 1), ctrl->CoarsenTo, ctrl->nmaxvwgt); for (i=0; incon; i++) mprintf(" %5.3f", gk_fsum(cgraph->nvtxs, cgraph->nvwgt+i, cgraph->ncon)); mprintf("]\n"); } if (cgraph->nedges == 0) { MCMatch_RM(ctrl, cgraph); } else { switch (ctrl->CType) { case MTYPE_RM: MCMatch_RM(ctrl, cgraph); break; case MTYPE_HEM: if (clevel < 1) MCMatch_RM(ctrl, cgraph); else MCMatch_HEM(ctrl, cgraph); break; case MTYPE_SHEM: if (clevel < 1) MCMatch_RM(ctrl, cgraph); else MCMatch_SHEM(ctrl, cgraph); break; case MTYPE_SHEMKWAY: MCMatch_SHEM(ctrl, cgraph); break; case MTYPE_SHEBM_ONENORM: MCMatch_SHEBM(ctrl, cgraph, 1); break; case MTYPE_SHEBM_INFNORM: MCMatch_SHEBM(ctrl, cgraph, -1); break; case MTYPE_SBHEM_ONENORM: MCMatch_SBHEM(ctrl, cgraph, 1); break; case MTYPE_SBHEM_INFNORM: MCMatch_SBHEM(ctrl, cgraph, -1); break; default: errexit("Unknown CType: %d\n", ctrl->CType); } } cgraph = cgraph->coarser; clevel++; } while (cgraph->nvtxs > ctrl->CoarsenTo && cgraph->nvtxs < COARSEN_FRACTION2*cgraph->finer->nvtxs && cgraph->nedges > cgraph->nvtxs/2); if (ctrl->dbglvl&DBG_COARSEN) { mprintf("%6D %7D %10D [%D] [%6.4f", cgraph->nvtxs, cgraph->nedges, idxsum(cgraph->nvtxs, cgraph->adjwgtsum, 1), ctrl->CoarsenTo, ctrl->nmaxvwgt); for (i=0; incon; i++) mprintf(" %5.3f", gk_fsum(cgraph->nvtxs, cgraph->nvwgt+i, cgraph->ncon)); mprintf("]\n"); } IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->CoarsenTmr)); return cgraph; } PyMetis-0.90/src/metis/memory.c0000640000175000017500000002333110662171744016242 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * memory.c * * This file contains routines that deal with memory allocation * * Started 2/24/96 * George * * $Id: memory.c,v 1.2 2002/08/10 06:29:31 karypis Exp $ * */ #include /************************************************************************* * This function allocates memory for the workspace **************************************************************************/ void AllocateWorkSpace(CtrlType *ctrl, GraphType *graph, idxtype nparts) { ctrl->wspace.pmat = NULL; if (ctrl->optype == OP_KMETIS) { ctrl->wspace.edegrees = (EDegreeType *)gk_malloc(graph->nedges*sizeof(EDegreeType), "AllocateWorkSpace: edegrees"); ctrl->wspace.vedegrees = NULL; ctrl->wspace.auxcore = (idxtype *)ctrl->wspace.edegrees; ctrl->wspace.pmat = idxmalloc(nparts*nparts, "AllocateWorkSpace: pmat"); /* Memory requirements for different phases Coarsening Matching: 4*nvtxs vectors Contraction: 2*nvtxs vectors (from the above 4), 1*nparts, 1*Nedges Total = MAX(4*nvtxs, 2*nvtxs+nparts+nedges) Refinement Random Refinement/Balance: 5*nparts + 1*nvtxs + 2*nedges Greedy Refinement/Balance: 5*nparts + 2*nvtxs + 2*nedges + 1*PQueue(==Nvtxs) Total = 5*nparts + 3*nvtxs + 2*nedges Total = 5*nparts + 3*nvtxs + 2*nedges */ ctrl->wspace.maxcore = 3*(graph->nvtxs+1) + /* Match/Refinement vectors */ 5*(nparts+1) + /* Partition weights etc */ graph->nvtxs*(sizeof(ListNodeType)/sizeof(idxtype)) + /* Greedy k-way balance/refine */ 20 /* padding for 64 bit machines */ ; } else if (ctrl->optype == OP_KVMETIS) { ctrl->wspace.edegrees = NULL; ctrl->wspace.vedegrees = (VEDegreeType *)gk_malloc(graph->nedges*sizeof(VEDegreeType), "AllocateWorkSpace: vedegrees"); ctrl->wspace.auxcore = (idxtype *)ctrl->wspace.vedegrees; ctrl->wspace.pmat = idxmalloc(nparts*nparts, "AllocateWorkSpace: pmat"); /* Memory requirements for different phases are identical to KMETIS */ ctrl->wspace.maxcore = 3*(graph->nvtxs+1) + /* Match/Refinement vectors */ 3*(nparts+1) + /* Partition weights etc */ graph->nvtxs*(sizeof(ListNodeType)/sizeof(idxtype)) + /* Greedy k-way balance/refine */ 20 /* padding for 64 bit machines */ ; } else { ctrl->wspace.edegrees = (EDegreeType *)idxmalloc(graph->nedges, "AllocateWorkSpace: edegrees"); ctrl->wspace.vedegrees = NULL; ctrl->wspace.auxcore = (idxtype *)ctrl->wspace.edegrees; ctrl->wspace.maxcore = 5*(graph->nvtxs+1) + /* Refinement vectors */ 4*(nparts+1) + /* Partition weights etc */ 2*graph->ncon*graph->nvtxs*(sizeof(ListNodeType)/sizeof(idxtype)) + /* 2-way refinement */ 2*graph->ncon*(NEG_GAINSPAN+PLUS_GAINSPAN+1)*(sizeof(ListNodeType *)/sizeof(idxtype)) + /* 2-way refinement */ 20 /* padding for 64 bit machines */ ; } ctrl->wspace.maxcore += HTLENGTH; ctrl->wspace.core = idxmalloc(ctrl->wspace.maxcore, "AllocateWorkSpace: maxcore"); ctrl->wspace.ccore = 0; } /************************************************************************* * This function allocates memory for the workspace **************************************************************************/ void FreeWorkSpace(CtrlType *ctrl, GraphType *graph) { gk_free((void **)&ctrl->wspace.edegrees, &ctrl->wspace.vedegrees, &ctrl->wspace.core, &ctrl->wspace.pmat, LTERM); } /************************************************************************* * This function returns how may words are left in the workspace **************************************************************************/ idxtype WspaceAvail(CtrlType *ctrl) { return ctrl->wspace.maxcore - ctrl->wspace.ccore; } /************************************************************************* * This function allocate space from the core **************************************************************************/ idxtype *idxwspacemalloc(CtrlType *ctrl, idxtype n) { n += n%2; /* This is a fix for 64 bit machines that require 8-byte pointer allignment */ ctrl->wspace.ccore += n; ASSERT(ctrl->wspace.ccore <= ctrl->wspace.maxcore); return ctrl->wspace.core + ctrl->wspace.ccore - n; } /************************************************************************* * This function frees space from the core **************************************************************************/ void idxwspacefree(CtrlType *ctrl, idxtype n) { n += n%2; /* This is a fix for 64 bit machines that require 8-byte pointer allignment */ ctrl->wspace.ccore -= n; ASSERT(ctrl->wspace.ccore >= 0); } /************************************************************************* * This function allocate space from the core **************************************************************************/ float *fwspacemalloc(CtrlType *ctrl, idxtype n) { n += n%2; /* This is a fix for 64 bit machines that require 8-byte pointer allignment */ ctrl->wspace.ccore += n; ASSERT(ctrl->wspace.ccore <= ctrl->wspace.maxcore); return (float *) (ctrl->wspace.core + ctrl->wspace.ccore - n); } /************************************************************************* * This function frees space from the core **************************************************************************/ void fwspacefree(CtrlType *ctrl, idxtype n) { n += n%2; /* This is a fix for 64 bit machines that require 8-byte pointer allignment */ ctrl->wspace.ccore -= n; ASSERT(ctrl->wspace.ccore >= 0); } /************************************************************************* * This function creates a CoarseGraphType data structure and initializes * the various fields **************************************************************************/ GraphType *CreateGraph(void) { GraphType *graph; graph = (GraphType *)gk_malloc(sizeof(GraphType), "CreateCoarseGraph: graph"); InitGraph(graph); return graph; } /************************************************************************* * This function creates a CoarseGraphType data structure and initializes * the various fields **************************************************************************/ void InitGraph(GraphType *graph) { /* graph size constants */ graph->nvtxs = -1; graph->nedges = -1; graph->ncon = -1; graph->mincut = -1; graph->minvol = -1; graph->nbnd = -1; /* memory for the graph structure */ graph->xadj = NULL; graph->vwgt = NULL; graph->nvwgt = NULL; graph->vsize = NULL; graph->adjncy = NULL; graph->adjwgt = NULL; graph->adjwgtsum = NULL; graph->label = NULL; graph->cmap = NULL; graph->coords = NULL; /* by default these are set to true, but the can be explicitly changed afterwards */ graph->free_xadj = 1; graph->free_vwgt = 1; graph->free_vsize = 1; graph->free_adjncy = 1; graph->free_adjwgt = 1; /* memory for the partition/refinement structure */ graph->where = NULL; graph->pwgts = NULL; graph->npwgts = NULL; graph->id = NULL; graph->ed = NULL; graph->bndptr = NULL; graph->bndind = NULL; graph->rinfo = NULL; graph->vrinfo = NULL; graph->nrinfo = NULL; /* linked-list structure */ graph->coarser = NULL; graph->finer = NULL; } /************************************************************************* * This function allocates memory for the requested fields of the graph's * structure (i.e., not partition/refinement structure). * The size of these fields is determined by the size of the graph itself * The fields should be provided as a comma-separated string with no spaces * For example * AllocGraphFields(&graph, "xadj,adjncy,vwgt") **************************************************************************/ void AllocGraphFields(GraphType *graph, char *fields) { char *sptr, *eptr; } /************************************************************************* * This function frees the refinement/partition memory * any memory stored in a graph **************************************************************************/ void FreeRData(GraphType *graph) { /* free partition/refinement structure */ gk_free((void **)&graph->where, &graph->pwgts, &graph->npwgts, &graph->id, &graph->ed, &graph->bndptr, &graph->bndind, &graph->rinfo, &graph->vrinfo, &graph->nrinfo, LTERM); } /************************************************************************* * This function deallocates any memory stored in a graph **************************************************************************/ void FreeGraph(GraphType *graph, int flag) { /* free graph structure */ if (graph->free_xadj) gk_free((void **)&graph->xadj, LTERM); if (graph->free_vwgt) gk_free((void **)&graph->vwgt, LTERM); if (graph->free_vsize) gk_free((void **)&graph->vsize, LTERM); if (graph->free_adjncy) gk_free((void **)&graph->adjncy, LTERM); if (graph->free_adjwgt) gk_free((void **)&graph->adjwgt, LTERM); gk_free((void **)&graph->nvwgt, &graph->adjwgtsum, &graph->label, &graph->cmap, &graph->coords, LTERM); /* free partition/refinement structure */ gk_free((void **)&graph->where, &graph->pwgts, &graph->npwgts, &graph->id, &graph->ed, &graph->bndptr, &graph->bndind, &graph->rinfo, &graph->vrinfo, &graph->nrinfo, LTERM); if (flag) gk_free((void **)&graph, LTERM); } PyMetis-0.90/src/metis/mesh.c0000640000175000017500000006242110662171744015671 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * mesh.c * * This file contains routines for converting 3D and 4D finite element * meshes into dual or nodal graphs * * Started 8/18/97 * George * * $Id: mesh.c,v 1.2 2002/08/10 06:29:31 karypis Exp $ * */ #include /****************************************************************************** * This function counts the neighbours of each element ******************************************************************************/ idxtype METIS_MeshToDualCount(idxtype *ne, idxtype *nn, idxtype *elmnts, idxtype *elms, idxtype *etype, idxtype *numflag) { idxtype cnt, esizes[] = {-1, 3, 4, 8, 4, 2}; if (*numflag == 1) ChangeMesh2CNumbering((*ne)*esizes[*etype], elmnts); cnt=GENDUALMETIS_COUNT(*ne, *nn, *etype, elmnts, elms); if (*numflag == 1) ChangeMesh2FNumbering3((*ne)*esizes[*etype], elmnts); return cnt; } /***************************************************************************** * This function creates a graph corresponding to the dual of a finite element * mesh. At this point the supported elements are triangles, tetrahedrons, and * bricks. ******************************************************************************/ void METIS_MeshToDual(idxtype *ne, idxtype *nn, idxtype *elmnts, idxtype *elms, idxtype *etype, idxtype *numflag, idxtype *dxadj, idxtype *dadjncy) { idxtype esizes[] = {-1, 3, 4, 8, 4, 2}; if (*numflag == 1) ChangeMesh2CNumbering((*ne)*esizes[*etype], elmnts); GENDUALMETIS(*ne, *nn, *etype, elmnts, elms, dxadj, dadjncy); if (*numflag == 1) ChangeMesh2FNumbering((*ne)*esizes[*etype], elmnts, *ne, dxadj, dadjncy); } /****************************************************************************** * This function counts the neighbours of each element ******************************************************************************/ idxtype METIS_MixedMeshToDualCount(idxtype *ne, idxtype *nn, idxtype *elmnts, idxtype * elms, idxtype *etype, idxtype *numflag, idxtype *conmat, idxtype custom) { idxtype i, j, jj, k, kk, kkk, l, m, tot, n, nedges, mask, cnt=0; idxtype *nptr, *nind; idxtype *mark, ind[200], wgt[200]; idxtype sizes[] = {-1, 3, 4, 8, 4, 2}, mgcnums[] = {-1, 2, 3, 4, 2}; idxtype *hash; idxtype mgcnum[6][6] = {-1, -1, -1, -1, -1, -1, -1, 2, 3, 3, 2 , 2, -1, 3, 3, 3, 3, 2, -1, 3, 3, 4, 4, 2, -1, 2, 3, 4, 2, 2, -1, 2, 2, 2, 2, 1} ; if (custom==1) /* External magic numbers supplied */ for (i=0,k=0;i<6;i++) for (j=0;j<6;j++) mgcnum[i][j]=conmat[k++]; hash = idxsmalloc((*ne)+1, 0, "MXNODALMETIS: hash"); tot=0; for (i=0;i<(*ne);i++){ hash[i]=tot; tot+=sizes[etype[i]]; } if (*numflag == 1) ChangeMesh2CNumbering(tot, elmnts); mask = (1<<11)-1; mark = idxsmalloc(mask+1, -1, "GENDUALMETIS: mark"); /* Construct the node-element list first */ nptr = idxsmalloc((*nn)+1, 0, "MXDUALMETIS: nptr"); for(i=0;i<(*ne);i++){ l=hash[i]; for (j=(sizes[etype[i]]), k=0; k0; i--) nptr[i] = nptr[i-1]; nptr[0] = 0; for (i=0; i<(*ne); i++) { for (m=j=0; j=nptr[n]; k--) { if ((kk = nind[k]) <= i) break; kkk = kk&mask; if ((l = mark[kkk]) == -1) { ind[m] = kk; wgt[m] = 1; mark[kkk] = m++; } else if (ind[l] == kk) { wgt[l]++; } else { for (jj=0; jj= mgcnum[etype[i]][etype[ind[j]]]){ elms[i]++; elms[ind[j]]++; cnt+=2; } mark[ind[j]&mask] = -1; } } gk_free((void **)&mark, LTERM); gk_free((void **)&nptr, LTERM); gk_free((void **)&nind, LTERM); gk_free((void **)&hash, LTERM); if (*numflag == 1) ChangeMesh2FNumbering3(tot, elmnts); return cnt; } /***************************************************************************** * This function creates a graph corresponding to the dual of a mixed element * mesh. At this point the supported elements are triangles, tetrahedrons, * bricks and lines. ******************************************************************************/ void METIS_MixedMeshToDual(idxtype *ne, idxtype *nn, idxtype *elmnts, idxtype *elms, idxtype *etype, idxtype *numflag,idxtype *dxadj, idxtype *dadjncy,idxtype *conmat, idxtype custom) { idxtype i, j, jj, k, kk, kkk, l, m, tot, n, nedges, mask; idxtype *nptr, *nind; idxtype *mark, ind[200], wgt[200]; idxtype sizes[] = {-1, 3, 4, 8, 4, 2}, mgcnums[] = {-1, 2, 3, 4, 2}; idxtype *hash,*mhash; idxtype mgcnum[6][6] = {-1, -1, -1, -1, -1, -1, -1, 2, 3, 3, 2 , 2, -1, 3, 3, 3, 3, 2, -1, 3, 3, 4, 4, 2, -1, 2, 3, 4, 2, 2, -1, 2, 2, 2, 2, 1} ; if (custom==1) /*External magic numbers supplied */ for (i=0,k=0;i<6;i++) for (j=0;j<6;j++) mgcnum[i][j]=conmat[k++]; hash = idxsmalloc((*ne), 0, "MXNODALMETIS: hash"); mhash = idxsmalloc((*ne), 0, "MXNODALMETIS: hash"); tot=0; for (i=0;i<(*ne);i++){ hash[i]=tot; tot+=sizes[etype[i]]; } if (*numflag == 1) ChangeMesh2CNumbering(tot, elmnts); mask = (1<<11)-1; mark = idxsmalloc(mask+1, -1, "GENDUALMETIS: mark"); /* Construct the node-element list first */ nptr = idxsmalloc((*nn)+1, 0, "MXDUALMETIS: nptr"); for(i=0;i<(*ne);i++){ l=hash[i]; for (j=(sizes[etype[i]]), k=0; k0; i--) nptr[i] = nptr[i-1]; nptr[0] = 0; dxadj[0]=0; for (i=1; i<(*ne); i++) mhash[i]=dxadj[i]=dxadj[i-1]+elms[i-1]; for (i=0; i<(*ne); i++) { for (m=j=0; j=nptr[n]; k--) { if ((kk = nind[k]) <= i) break; kkk = kk&mask; if ((l = mark[kkk]) == -1) { ind[m] = kk; wgt[m] = 1; mark[kkk] = m++; } else if (ind[l] == kk) { wgt[l]++; } else { for (jj=0; jj= mgcnum[etype[i]][etype[ind[j]]]) { k = ind[j]; dadjncy[dxadj[i]++] = k; dadjncy[dxadj[k]++] = i; } mark[ind[j]&mask] = -1; } } /* Go and consolidate the dxadj and dadjncy */ for (j=i=0; i<*ne; i++) { for (k=mhash[i]; k0; i--) dxadj[i] = dxadj[i-1]; dxadj[0] = 0; gk_free((void **)&mark, LTERM); gk_free((void **)&nptr, LTERM); gk_free((void **)&nind, LTERM); gk_free((void **)&hash, LTERM); if (*numflag == 1) ChangeMesh2FNumbering(tot, elmnts, *nn, dxadj, dadjncy); } /***************************************************************************** * This function creates a graph corresponding to the finite element mesh. * At this point the supported elements are triangles, tetrahedrons. ******************************************************************************/ void METIS_MeshToNodal(idxtype *ne, idxtype *nn, idxtype *elmnts, idxtype *etype, idxtype *numflag, idxtype *dxadj, idxtype *dadjncy) { idxtype esizes[] = {-1, 3, 4, 8, 4, 2}; if (*numflag == 1) ChangeMesh2CNumbering((*ne)*esizes[*etype], elmnts); switch (*etype) { case 1: TRINODALMETIS(*ne, *nn, elmnts, dxadj, dadjncy); break; case 2: TETNODALMETIS(*ne, *nn, elmnts, dxadj, dadjncy); break; case 3: HEXNODALMETIS(*ne, *nn, elmnts, dxadj, dadjncy); break; case 4: QUADNODALMETIS(*ne, *nn, elmnts, dxadj, dadjncy); break; case 5: LINENODALMETIS(*ne, *nn, elmnts, dxadj, dadjncy); break; } if (*numflag == 1) ChangeMesh2FNumbering((*ne)*esizes[*etype], elmnts, *nn, dxadj, dadjncy); } /***************************************************************************** * This function creates a graph corresponding to the finite mixed element mesh. * At this point the supported elements are triangles, tetrahedrons, hexahedras, * quadilaterals and lines. ******************************************************************************/ void METIS_MixedMeshToNodal(idxtype *ne, idxtype *nn, idxtype *elmnts, idxtype *etype, idxtype *numflag, idxtype *dxadj, idxtype *dadjncy) { idxtype sizes[] = {-1, 3,4,8,4,2}; idxtype i, j, jj, k, kk, kkk, l, m, n, nedges; idxtype *nptr, *nind; idxtype *mark; idxtype *hash; idxtype tableH[8][3] = {1, 3, 4, 0, 2, 5, 1, 3, 6, 0, 2, 7, 0, 5, 7, 1, 4, 6, 2, 5, 7, 3, 4, 6}; idxtype tableQ[4][2] = {1, 3, 0, 2, 1, 3, 0, 2}; hash = idxsmalloc((*ne), 0, "MXNODALMETIS: hash"); m=0; for (i=0;i<(*ne);i++){ hash[i]=m; m+=sizes[etype[i]]; } if (*numflag == 1) ChangeMesh2CNumbering(m, elmnts); /* Construct the node-element list first */ nptr = idxsmalloc((*nn)+1, 0, "MXNODALMETIS: nptr"); for(i=0;i<(*ne);i++){ l=hash[i]; for (j=(sizes[etype[i]]), k=0; k0; i--) nptr[i] = nptr[i-1]; nptr[0] = 0; mark = idxsmalloc(*nn, -1, "MXNODALMETIS: mark"); nedges = dxadj[0] = 0; for (i=0; i<(*nn); i++) { mark[i] = i; dxadj[i+1]=dxadj[i]; for (j=nptr[i]; j0; i--) nptr[i] = nptr[i-1]; nptr[0] = 0; for (i=0; i=nptr[n]; k--) { if ((kk = nind[k]) <= i) break; kkk = kk&mask; if ((l = mark[kkk]) == -1) { ind[m] = kk; wgt[m] = 1; mark[kkk] = m++; } else if (ind[l] == kk) { wgt[l]++; } else { for (jj=0; jj0; i--) nptr[i] = nptr[i-1]; nptr[0] = 0; mhash = idxsmalloc(nelmnts, 0, "MXNODALMETIS: hash"); dxadj[0]=0; for (i=1; i=nptr[n]; k--) { if ((kk = nind[k]) <= i) break; kkk = kk&mask; if ((l = mark[kkk]) == -1) { ind[m] = kk; wgt[m] = 1; mark[kkk] = m++; } else if (ind[l] == kk) { wgt[l]++; } else { for (jj=0; jj0; i--) dxadj[i] = dxadj[i-1]; dxadj[0] = 0; gk_free((void **)&mark, LTERM); gk_free((void **)&nptr, LTERM); gk_free((void **)&nind, LTERM); gk_free((void **)&mhash, LTERM); } /***************************************************************************** * This function creates the nodal graph of a finite element mesh ******************************************************************************/ void TRINODALMETIS(idxtype nelmnts, idxtype nvtxs, idxtype *elmnts, idxtype *dxadj, idxtype *dadjncy) { idxtype i, j, jj, k, kk, kkk, l, m, n, nedges; idxtype *nptr, *nind; idxtype *mark; /* Construct the node-element list first */ nptr = idxsmalloc(nvtxs+1, 0, "TRINODALMETIS: nptr"); for (j=3*nelmnts, i=0; i0; i--) nptr[i] = nptr[i-1]; nptr[0] = 0; mark = idxsmalloc(nvtxs, -1, "TRINODALMETIS: mark"); nedges = dxadj[0] = 0; for (i=0; i0; i--) nptr[i] = nptr[i-1]; nptr[0] = 0; mark = idxsmalloc(nvtxs, -1, "TETNODALMETIS: mark"); nedges = dxadj[0] = 0; for (i=0; i0; i--) nptr[i] = nptr[i-1]; nptr[0] = 0; mark = idxsmalloc(nvtxs, -1, "HEXNODALMETIS: mark"); nedges = dxadj[0] = 0; for (i=0; i0; i--) nptr[i] = nptr[i-1]; nptr[0] = 0; mark = idxsmalloc(nvtxs, -1, "QUADNODALMETIS: mark"); nedges = dxadj[0] = 0; for (i=0; i0; i--) nptr[i] = nptr[i-1]; nptr[0] = 0; mark = idxsmalloc(nvtxs, -1, "TRINODALMETIS: mark"); nedges = dxadj[0] = 0; for (i=0; i /************************************************************************* * This function partitions a finite element mesh by partitioning its nodal * graph using KMETIS and then assigning elements in a load balanced fashion. **************************************************************************/ void METIS_PartMeshNodal(idxtype *ne, idxtype *nn, idxtype *elmnts, idxtype *etype, idxtype *numflag, idxtype *nparts, idxtype *edgecut, idxtype *epart, idxtype *npart) { idxtype i, j, k, me; idxtype *xadj, *adjncy, *pwgts; idxtype options[10], pnumflag=0, wgtflag=0; idxtype nnbrs, nbrind[200], nbrwgt[200], maxpwgt; idxtype esize, esizes[] = {-1, 3, 4, 8, 4, 2}; esize = esizes[*etype]; if (*numflag == 1) ChangeMesh2CNumbering((*ne)*esize, elmnts); xadj = idxmalloc(*nn+1, "METIS_MESHPARTNODAL: xadj"); adjncy = idxmalloc(20*(*nn), "METIS_MESHPARTNODAL: adjncy"); METIS_MeshToNodal(ne, nn, elmnts, etype, &pnumflag, xadj, adjncy); adjncy = realloc(adjncy, xadj[*nn]*sizeof(idxtype)); options[0] = 0; METIS_PartGraphKway(nn, xadj, adjncy, NULL, NULL, &wgtflag, &pnumflag, nparts, options, edgecut, npart); /* OK, now compute an element partition based on the nodal partition npart */ idxset(*ne, -1, epart); pwgts = idxsmalloc(*nparts, 0, "METIS_MESHPARTNODAL: pwgts"); for (i=0; i<*ne; i++) { me = npart[elmnts[i*esize]]; for (j=1; j0; i--) nptr[i] = nptr[i-1]; nptr[0] = 0; /* OK, now compute a nodal partition based on the element partition npart */ idxset(*nn, -1, npart); pwgts = idxsmalloc(*nparts, 0, "METIS_MESHPARTDUAL: pwgts"); for (i=0; i<*nn; i++) { me = epart[nind[nptr[i]]]; for (j=nptr[i]+1; j0; i--) nptr[i] = nptr[i-1]; nptr[0] = 0; /* OK, now compute a nodal partition based on the element partition npart */ idxset(*nn, -1, npart); pwgts = idxsmalloc(*nparts, 0, "METIS_MESHPARTDUAL: pwgts"); for (i=0; i<*nn; i++) { me = epart[nind[nptr[i]]]; for (j=nptr[i]+1; j #define __thread __declspec( thread ) typedef __int32 int32_t; typedef __int64 int64_t; typedef unsigned __int32 uint32_t; typedef unsigned __int64 uint64_t; #else #include #include #include #endif /*------------------------------------------------------------------------ * Undefine the following #define in order to use short idxtype as the idxtype *-------------------------------------------------------------------------*/ #if IDXTYPEWIDTH == 32 #define SCNIDX SCNd32 #define PRIIDX PRId32 typedef int32_t idxtype; #elif IDXTYPEWIDTH == 64 #define SCNIDX SCNd64 #define PRIIDX PRId64 typedef int64_t idxtype; #else #error "Incorrect user-supplied value fo IDXTYPEWIDTH" #endif /*------------------------------------------------------------------------ * Function prototypes *-------------------------------------------------------------------------*/ #if !defined(__cdecl) #define __cdecl #endif #ifdef __cplusplus extern "C" { #endif void __cdecl METIS_EstimateMemory(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *numflag, idxtype *optype, idxtype *nbytes); void __cdecl METIS_PartGraphKway(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, idxtype *options, idxtype *edgecut, idxtype *part); void __cdecl METIS_WPartGraphKway(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *tpwgts, idxtype *options, idxtype *edgecut, idxtype *part); void __cdecl METIS_PartGraphVKway(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *vsize, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, idxtype *options, idxtype *volume, idxtype *part); void __cdecl METIS_WPartGraphVKway(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *vsize, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *tpwgts, idxtype *options, idxtype *volume, idxtype *part); idxtype __cdecl METIS_MeshToDualCount(idxtype *ne, idxtype *nn, idxtype *elmnts, idxtype *elms, idxtype *etype, idxtype *numflag); void __cdecl METIS_MeshToDual(idxtype *ne, idxtype *nn, idxtype *elmnts, idxtype *elms, idxtype *etype, idxtype *numflag, idxtype *dxadj, idxtype *dadjncy); idxtype __cdecl METIS_MixedMeshToDualCount(idxtype *ne, idxtype *nn, idxtype *elmnts, idxtype * elms, idxtype *etype, idxtype *numflag, idxtype *conmat, idxtype custom); void __cdecl METIS_MixedMeshToDual(idxtype *ne, idxtype *nn, idxtype *elmnts, idxtype *elms, idxtype *etype, idxtype *numflag,idxtype *dxadj, idxtype *dadjncy,idxtype *conmat, idxtype custom); void __cdecl METIS_MeshToNodal(idxtype *ne, idxtype *nn, idxtype *elmnts, idxtype *etype, idxtype *numflag, idxtype *dxadj, idxtype *dadjncy); void __cdecl METIS_MixedMeshToNodal(idxtype *ne, idxtype *nn, idxtype *elmnts, idxtype *etype, idxtype *numflag, idxtype *dxadj, idxtype *dadjncy); void __cdecl METIS_PartMeshNodal(idxtype *ne, idxtype *nn, idxtype *elmnts, idxtype *etype, idxtype *numflag, idxtype *nparts, idxtype *edgecut, idxtype *epart, idxtype *npart); void __cdecl METIS_PartMixedMeshNodal(idxtype *ne, idxtype *nn, idxtype *elmnts, idxtype *etype, idxtype *numflag, idxtype *nparts, idxtype *edgecut, idxtype *epart, idxtype *npart); void __cdecl METIS_PartMeshDual(idxtype *ne, idxtype *nn, idxtype *elmnts, idxtype *etype, idxtype *numflag, idxtype *nparts, idxtype *edgecut, idxtype *epart, idxtype *npart, idxtype wgtflag, idxtype * vwgt); void __cdecl METIS_PartMixedMeshDual(idxtype *ne, idxtype *nn, idxtype *elmnts, idxtype *etype, idxtype *numflag, idxtype *nparts, idxtype *edgecut, idxtype *epart, idxtype *npart, idxtype *conmat, idxtype custom, idxtype wgtflag, idxtype *vwgt); void __cdecl METIS_mCPartGraphKway(idxtype *nvtxs, idxtype *ncon, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *rubvec, idxtype *options, idxtype *edgecut, idxtype *part); void __cdecl METIS_mCPartGraphRecursive(idxtype *nvtxs, idxtype *ncon, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, idxtype *options, idxtype *edgecut, idxtype *part); void __cdecl METIS_mCHPartGraphRecursive(idxtype *nvtxs, idxtype *ncon, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *ubvec, idxtype *options, idxtype *edgecut, idxtype *part); void __cdecl METIS_mCPartGraphRecursiveInternal(idxtype *nvtxs, idxtype *ncon, idxtype *xadj, idxtype *adjncy, float *nvwgt, idxtype *adjwgt, idxtype *nparts, idxtype *options, idxtype *edgecut, idxtype *part); void __cdecl METIS_mCHPartGraphRecursiveInternal(idxtype *nvtxs, idxtype *ncon, idxtype *xadj, idxtype *adjncy, float *nvwgt, idxtype *adjwgt, idxtype *nparts, float *ubvec, idxtype *options, idxtype *edgecut, idxtype *part); void __cdecl METIS_EdgeND(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *numflag, idxtype *options, idxtype *perm, idxtype *iperm); void __cdecl METIS_NodeND(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *numflag, idxtype *options, idxtype *perm, idxtype *iperm); void __cdecl METIS_NodeWND(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *numflag, idxtype *options, idxtype *perm, idxtype *iperm); void __cdecl METIS_PartGraphKway2(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, idxtype *options, idxtype *edgecut, idxtype *part); void __cdecl METIS_WPartGraphKway2(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *tpwgts, idxtype *options, idxtype *edgecut, idxtype *part); void __cdecl METIS_NodeNDP(idxtype nvtxs, idxtype *xadj, idxtype *adjncy, idxtype npes, idxtype *options, idxtype *perm, idxtype *iperm, idxtype *sizes); void __cdecl METIS_NodeComputeSeparator(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *options, idxtype *sepsize, idxtype *part); void __cdecl METIS_EdgeComputeSeparator(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *options, idxtype *sepsize, idxtype *part); void __cdecl METIS_PartGraphRecursive(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, idxtype *options, idxtype *edgecut, idxtype *part); void __cdecl METIS_WPartGraphRecursive(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *tpwgts, idxtype *options, idxtype *edgecut, idxtype *part); void __cdecl METIS_PartFillGraph(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, idxtype *options, idxtype *edgecut, idxtype *part); #ifdef __cplusplus } #endif /*------------------------------------------------------------------------ * Constant definitions *-------------------------------------------------------------------------*/ /* Matching Schemes */ #define MTYPE_RM 1 #define MTYPE_HEM 2 #define MTYPE_SHEM 3 #define MTYPE_SHEMKWAY 4 #define MTYPE_SHEBM_ONENORM 5 #define MTYPE_SHEBM_INFNORM 6 #define MTYPE_SBHEM_ONENORM 7 #define MTYPE_SBHEM_INFNORM 8 /* Initial partitioning schemes for PMETIS and ONMETIS */ #define ITYPE_GGPKL 1 #define ITYPE_GGPKLNODE 2 #define ITYPE_RANDOM 2 /* Refinement schemes for PMETIS */ #define RTYPE_FM 1 /* Initial partitioning schemes for KMETIS */ #define ITYPE_PMETIS 1 /* Refinement schemes for KMETIS */ #define RTYPE_KWAYRANDOM 1 #define RTYPE_KWAYGREEDY 2 #define RTYPE_KWAYRANDOM_MCONN 3 /* Refinement schemes for ONMETIS */ #define RTYPE_SEP2SIDED 1 #define RTYPE_SEP1SIDED 2 /* Initial Partitioning Schemes for McKMETIS */ #define ITYPE_McPMETIS 1 /* Simple McPMETIS */ #define ITYPE_McHPMETIS 2 /* horizontally relaxed McPMETIS */ /* Debug Levels */ #define DBG_TIME 1 /* Perform timing analysis */ #define DBG_OUTPUT 2 #define DBG_COARSEN 4 /* Show the coarsening progress */ #define DBG_REFINE 8 /* Show info on communication during folding */ #define DBG_IPART 16 /* Show info on initial partition */ #define DBG_MOVEINFO 32 /* Show info on communication during folding */ #define DBG_KWAYPINFO 64 /* Show info on communication during folding */ #define DBG_SEPINFO 128 /* Show info on communication during folding */ /* Metis's version number */ #define METIS_VER_MAJOR 5 #define METIS_VER_MINOR 0 #define METIS_VER_SUBMINOR 0 #endif /* METIS_H */ PyMetis-0.90/src/metis/metislib.h0000640000175000017500000000151310662171744016545 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * metis.h * * This file includes all necessary header files * * Started 8/27/94 * George * * $Id: metislib.h,v 1.1 2002/08/10 06:29:31 karypis Exp $ */ #include #include #include #include #include #include #include #include #include #include #include #include #include #if defined(ENABLE_OPENMP) #include #endif #include #include #include #include #include #include #if defined(COMPILER_MSC) #define rint(x) ((idxtype)((x)+0.5)) /* MSC does not have rint() function */ #endif #if defined(COMPILER_GCC) /* extern char* strdup (const char *); */ #endif PyMetis-0.90/src/metis/mfm.c0000640000175000017500000002570510662171744015520 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * mfm.c * * This file contains code that implements the edge-based FM refinement * * Started 7/23/97 * George * * $Id: mfm.c,v 1.2 2002/08/10 06:29:33 karypis Exp $ */ #include /************************************************************************* * This function performs an edge-based FM refinement **************************************************************************/ void MocFM_2WayEdgeRefine(CtrlType *ctrl, GraphType *graph, float *tpwgts, idxtype npasses) { idxtype i, ii, j, k, l, kwgt, nvtxs, ncon, nbnd, nswaps, from, to, pass, me, limit, tmp, cnum; idxtype *xadj, *adjncy, *adjwgt, *where, *id, *ed, *bndptr, *bndind; idxtype *moved, *swaps, *perm, *qnum; float *nvwgt, *npwgts, mindiff[MAXNCON], origbal, minbal, newbal; PQueueType parts[MAXNCON][2]; idxtype higain, oldgain, mincut, initcut, newcut, mincutorder; float rtpwgts[2]; nvtxs = graph->nvtxs; ncon = graph->ncon; xadj = graph->xadj; nvwgt = graph->nvwgt; adjncy = graph->adjncy; adjwgt = graph->adjwgt; where = graph->where; id = graph->id; ed = graph->ed; npwgts = graph->npwgts; bndptr = graph->bndptr; bndind = graph->bndind; moved = idxwspacemalloc(ctrl, nvtxs); swaps = idxwspacemalloc(ctrl, nvtxs); perm = idxwspacemalloc(ctrl, nvtxs); qnum = idxwspacemalloc(ctrl, nvtxs); limit = amin(amax(0.01*nvtxs, 25), 150); /* Initialize the queues */ for (i=0; idbglvl&DBG_REFINE) { mprintf("Parts: ["); for (l=0; lnvtxs, graph->nbnd, graph->mincut, origbal); } idxset(nvtxs, -1, moved); for (pass=0; passmincut; for (i=0; imincut); ASSERT(CheckBnd(graph)); /* Insert boundary nodes in the priority queues */ nbnd = graph->nbnd; RandomPermute(nbnd, perm, 1); for (ii=0; ii 0 || id[i] == 0); ASSERT(bndptr[i] != -1); PQueueInsert(&parts[qnum[i]][where[i]], i, ed[i]-id[i]); } for (nswaps=0; nswaps limit) { /* We hit the limit, undo last move */ newcut += (ed[higain]-id[higain]); gk_faxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+from*ncon, 1); gk_faxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1); break; } where[higain] = to; moved[higain] = nswaps; swaps[nswaps] = higain; if (ctrl->dbglvl&DBG_MOVEINFO) { mprintf("Moved %6D from %D(%D). Gain: %5D, Cut: %5D, NPwgts: ", higain, from, cnum, ed[higain]-id[higain], newcut); for (l=0; l 0) { /* It will now become a boundary vertex */ BNDInsert(nbnd, bndind, bndptr, k); if (moved[k] == -1) PQueueInsert(&parts[qnum[k]][where[k]], k, ed[k]-id[k]); } } } } /**************************************************************** * Roll back computations *****************************************************************/ for (i=0; imincutorder; nswaps--) { higain = swaps[nswaps]; to = where[higain] = (where[higain]+1)%2; SWAP(id[higain], ed[higain], tmp); if (ed[higain] == 0 && bndptr[higain] != -1 && xadj[higain] < xadj[higain+1]) BNDDelete(nbnd, bndind, bndptr, higain); else if (ed[higain] > 0 && bndptr[higain] == -1) BNDInsert(nbnd, bndind, bndptr, higain); gk_faxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1); gk_faxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+((to+1)%2)*ncon, 1); for (j=xadj[higain]; j 0) BNDInsert(nbnd, bndind, bndptr, k); } } if (ctrl->dbglvl&DBG_REFINE) { mprintf("\tMincut: %6D at %5D, NBND: %6D, NPwgts: [", mincut, mincutorder, nbnd); for (l=0; lmincut = mincut; graph->nbnd = nbnd; if (mincutorder == -1 || mincut == initcut) break; } for (i=0; i= maxdiff) { maxdiff = npwgts[part*ncon+i]-tpwgts[part]; *from = part; *cnum = i; } } } /* mprintf("Selected1 %D(%D) -> %D [%5f]\n", *from, *cnum, PQueueGetSize(&queues[*cnum][*from]), maxdiff); */ if (*from != -1 && PQueueGetSize(&queues[*cnum][*from]) == 0) { /* The desired queue is empty, select a node from that side anyway */ for (i=0; i 0) { max = npwgts[(*from)*ncon + i]; *cnum = i; break; } } for (i++; i max && PQueueGetSize(&queues[i][*from]) > 0) { max = npwgts[(*from)*ncon + i]; *cnum = i; } } } /* Check to see if you can focus on the cut */ if (maxdiff <= 0.0 || *from == -1) { maxgain = -100000; for (part=0; part<2; part++) { for (i=0; i 0 && PQueueGetKey(&queues[i][part]) > maxgain) { maxgain = PQueueGetKey(&queues[i][part]); *from = part; *cnum = i; } } } } /* mprintf("Selected2 %D(%D) -> %D\n", *from, *cnum, PQueueGetSize(&queues[*cnum][*from])); */ } /************************************************************************* * This function checks if the balance achieved is better than the diff * For now, it uses a 2-norm measure **************************************************************************/ idxtype BetterBalance(idxtype ncon, float *npwgts, float *tpwgts, float *diff) { idxtype i; float ndiff[MAXNCON]; for (i=0; i /************************************************************************* * This function performs an edge-based FM refinement **************************************************************************/ void MocFM_2WayEdgeRefine2(CtrlType *ctrl, GraphType *graph, float *tpwgts, float *orgubvec, idxtype npasses) { idxtype i, ii, j, k, l, kwgt, nvtxs, ncon, nbnd, nswaps, from, to, pass, me, limit, tmp, cnum; idxtype *xadj, *adjncy, *adjwgt, *where, *id, *ed, *bndptr, *bndind; idxtype *moved, *swaps, *perm, *qnum; float *nvwgt, *npwgts, origdiff[MAXNCON], origbal[MAXNCON], minbal[MAXNCON]; PQueueType parts[MAXNCON][2]; idxtype higain, oldgain, mincut, initcut, newcut, mincutorder; float *maxwgt, *minwgt, ubvec[MAXNCON], tvec[MAXNCON]; nvtxs = graph->nvtxs; ncon = graph->ncon; xadj = graph->xadj; nvwgt = graph->nvwgt; adjncy = graph->adjncy; adjwgt = graph->adjwgt; where = graph->where; id = graph->id; ed = graph->ed; npwgts = graph->npwgts; bndptr = graph->bndptr; bndind = graph->bndind; moved = idxwspacemalloc(ctrl, nvtxs); swaps = idxwspacemalloc(ctrl, nvtxs); perm = idxwspacemalloc(ctrl, nvtxs); qnum = idxwspacemalloc(ctrl, nvtxs); limit = amin(amax(0.01*nvtxs, 15), 100); Compute2WayHLoadImbalanceVec(ncon, npwgts, tpwgts, origbal); for (i=0; idbglvl&DBG_REFINE) { mprintf("Parts: ["); for (l=0; lnvtxs, graph->nbnd, graph->mincut); for (i=0; imincut; Compute2WayHLoadImbalanceVec(ncon, npwgts, tpwgts, minbal); ASSERT(ComputeCut(graph, where) == graph->mincut); ASSERT(CheckBnd(graph)); /* Insert boundary nodes in the priority queues */ nbnd = graph->nbnd; RandomPermute(nbnd, perm, 1); for (ii=0; ii 0 || id[i] == 0); ASSERT(bndptr[i] != -1); PQueueInsert(&parts[qnum[i]][where[i]], i, ed[i]-id[i]); } for (nswaps=0; nswaps limit) { /* We hit the limit, undo last move */ newcut += (ed[higain]-id[higain]); gk_faxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+from*ncon, 1); gk_faxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1); break; } where[higain] = to; moved[higain] = nswaps; swaps[nswaps] = higain; if (ctrl->dbglvl&DBG_MOVEINFO) { mprintf("Moved %6D from %D(%D). Gain: %5D, Cut: %5D, NPwgts: ", higain, from, cnum, ed[higain]-id[higain], newcut); for (l=0; l 0) { /* It will now become a boundary vertex */ BNDInsert(nbnd, bndind, bndptr, k); if (moved[k] == -1) PQueueInsert(&parts[qnum[k]][where[k]], k, ed[k]-id[k]); } } } } /**************************************************************** * Roll back computations *****************************************************************/ for (i=0; imincutorder; nswaps--) { higain = swaps[nswaps]; to = where[higain] = (where[higain]+1)%2; SWAP(id[higain], ed[higain], tmp); if (ed[higain] == 0 && bndptr[higain] != -1 && xadj[higain] < xadj[higain+1]) BNDDelete(nbnd, bndind, bndptr, higain); else if (ed[higain] > 0 && bndptr[higain] == -1) BNDInsert(nbnd, bndind, bndptr, higain); gk_faxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1); gk_faxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+((to+1)%2)*ncon, 1); for (j=xadj[higain]; j 0) BNDInsert(nbnd, bndind, bndptr, k); } } if (ctrl->dbglvl&DBG_REFINE) { mprintf("\tMincut: %6D at %5D, NBND: %6D, NPwgts: [", mincut, mincutorder, nbnd); for (l=0; lmincut = mincut; graph->nbnd = nbnd; if (mincutorder == -1 || mincut == initcut) break; } for (i=0; i= maxdiff) { maxdiff = diff; *from = j; *cnum = i; } } } if (*from != -1 && PQueueGetSize(&queues[*cnum][*from]) == 0) { /* The desired queue is empty, select a node from that side anyway */ for (i=0; i 0) { max = (npwgts[(*from)*ncon+i] - maxwgt[(*from)*ncon+i]); *cnum = i; break; } } for (i++; i max && PQueueGetSize(&queues[i][*from]) > 0) { max = diff; *cnum = i; } } } /* Check to see if you can focus on the cut */ if (maxdiff <= 0.0 || *from == -1) { maxgain = -100000; for (j=0; j<2; j++) { for (i=0; i 0 && PQueueGetKey(&queues[i][j]) > maxgain) { maxgain = PQueueGetKey(&queues[i][j]); *from = j; *cnum = i; } } } /* mprintf("(%2D %2D) %3D\n", *from, *cnum, maxgain); */ } } /************************************************************************* * This function checks if the newbal is better than oldbal given the * ubvector ubvec **************************************************************************/ idxtype IsBetter2wayBalance(idxtype ncon, float *newbal, float *oldbal, float *ubvec) { idxtype i, j; float max1=0.0, max2=0.0, sum1=0.0, sum2=0.0, tmp; for (i=0; i max2) return 0; else return sum1 <= sum2; } PyMetis-0.90/src/metis/mincover.c0000640000175000017500000001627510662171744016565 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * mincover.c * * This file implements the minimum cover algorithm * * Started 8/1/97 * George * * $Id: mincover.c,v 1.2 2002/08/10 06:29:33 karypis Exp $ */ #include /************************************************************************* * Constants used by mincover algorithm **************************************************************************/ #define INCOL 10 #define INROW 20 #define VC 1 #define SC 2 #define HC 3 #define VR 4 #define SR 5 #define HR 6 /************************************************************************* * This function returns the min-cover of a bipartite graph. * The algorithm used is due to Hopcroft and Karp as modified by Duff etal * adj: the adjacency list of the bipartite graph * asize: the number of vertices in the first part of the bipartite graph * bsize-asize: the number of vertices in the second part * 0..(asize-1) > A vertices * asize..bsize > B vertices * * Returns: * cover : the actual cover (array) * csize : the size of the cover **************************************************************************/ void MinCover(idxtype *xadj, idxtype *adjncy, idxtype asize, idxtype bsize, idxtype *cover, idxtype *csize) { idxtype i, j; idxtype *mate, *queue, *flag, *level, *lst; idxtype fptr, rptr, lstptr; idxtype row, maxlevel, col; mate = idxsmalloc(bsize, -1, "MinCover: mate"); flag = idxmalloc(bsize, "MinCover: flag"); level = idxmalloc(bsize, "MinCover: level"); queue = idxmalloc(bsize, "MinCover: queue"); lst = idxmalloc(bsize, "MinCover: lst"); /* Get a cheap matching */ for (i=0; i /************************************************************************* * This function computes the initial bisection of the coarsest graph **************************************************************************/ void MocInit2WayPartition(CtrlType *ctrl, GraphType *graph, float *tpwgts, float ubfactor) { idxtype i, dbglvl; dbglvl = ctrl->dbglvl; IFSET(ctrl->dbglvl, DBG_REFINE, ctrl->dbglvl -= DBG_REFINE); IFSET(ctrl->dbglvl, DBG_MOVEINFO, ctrl->dbglvl -= DBG_MOVEINFO); IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->InitPartTmr)); switch (ctrl->IType) { case ITYPE_GGPKL: if (graph->nedges == 0) MocRandomBisection(ctrl, graph, tpwgts, ubfactor); else MocGrowBisection(ctrl, graph, tpwgts, ubfactor); break; case ITYPE_RANDOM: MocRandomBisection(ctrl, graph, tpwgts, ubfactor); break; default: errexit("Unknown initial partition type: %d\n", ctrl->IType); } IFSET(ctrl->dbglvl, DBG_IPART, mprintf("Initial Cut: %D [%D]\n", graph->mincut, graph->where[0])); IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->InitPartTmr)); ctrl->dbglvl = dbglvl; } /************************************************************************* * This function takes a graph and produces a bisection by using a region * growing algorithm. The resulting partition is returned in * graph->where **************************************************************************/ void MocGrowBisection(CtrlType *ctrl, GraphType *graph, float *tpwgts, float ubfactor) { idxtype i, j, k, nvtxs, ncon, from, bestcut, mincut, nbfs, inbfs; idxtype *bestwhere, *where; nvtxs = graph->nvtxs; MocAllocate2WayPartitionMemory(ctrl, graph); where = graph->where; bestwhere = idxmalloc(nvtxs, "BisectGraph: bestwhere"); nbfs = 2*(nvtxs <= ctrl->CoarsenTo ? SMALLNIPARTS : LARGENIPARTS); for (inbfs=0; inbfs= graph->mincut) { bestcut = graph->mincut; idxcopy(nvtxs, where, bestwhere); if (bestcut == 0) break; } } graph->mincut = bestcut; idxcopy(nvtxs, bestwhere, where); gk_free((void **)&bestwhere, LTERM); } /************************************************************************* * This function takes a graph and produces a bisection by using a region * growing algorithm. The resulting partition is returned in * graph->where **************************************************************************/ void MocRandomBisection(CtrlType *ctrl, GraphType *graph, float *tpwgts, float ubfactor) { idxtype i, ii, j, k, nvtxs, ncon, from, bestcut, mincut, nbfs, inbfs, qnum; idxtype *bestwhere, *where, *perm; idxtype counts[MAXNCON]; float *nvwgt; nvtxs = graph->nvtxs; ncon = graph->ncon; nvwgt = graph->nvwgt; MocAllocate2WayPartitionMemory(ctrl, graph); where = graph->where; bestwhere = idxmalloc(nvtxs, "BisectGraph: bestwhere"); nbfs = 2*(nvtxs <= ctrl->CoarsenTo ? SMALLNIPARTS : LARGENIPARTS); perm = idxmalloc(nvtxs, "BisectGraph: perm"); for (inbfs=0; inbfsmincut); for (i=0; incon; i++) mprintf("(%.3f %.3f) ", graph->npwgts[i], graph->npwgts[graph->ncon+i]); mprintf("]\n"); */ if (inbfs == 0 || bestcut >= graph->mincut) { bestcut = graph->mincut; idxcopy(nvtxs, where, bestwhere); if (bestcut == 0) break; } } graph->mincut = bestcut; idxcopy(nvtxs, bestwhere, where); gk_free((void **)&bestwhere, &perm, LTERM); } /************************************************************************* * This function balances two partitions by moving the highest gain * (including negative gain) vertices to the other domain. * It is used only when tha unbalance is due to non contigous * subdomains. That is, the are no boundary vertices. * It moves vertices from the domain that is overweight to the one that * is underweight. **************************************************************************/ void MocInit2WayBalance(CtrlType *ctrl, GraphType *graph, float *tpwgts) { idxtype i, ii, j, k, l, kwgt, nvtxs, nbnd, ncon, nswaps, from, to, pass, me, cnum, tmp; idxtype *xadj, *adjncy, *adjwgt, *where, *id, *ed, *bndptr, *bndind; idxtype *perm, *qnum; float *nvwgt, *npwgts; PQueueType parts[MAXNCON][2]; idxtype higain, oldgain, mincut; nvtxs = graph->nvtxs; ncon = graph->ncon; xadj = graph->xadj; adjncy = graph->adjncy; nvwgt = graph->nvwgt; adjwgt = graph->adjwgt; where = graph->where; id = graph->id; ed = graph->ed; npwgts = graph->npwgts; bndptr = graph->bndptr; bndind = graph->bndind; perm = idxwspacemalloc(ctrl, nvtxs); qnum = idxwspacemalloc(ctrl, nvtxs); /* This is called for initial partitioning so we know from where to pick nodes */ from = 1; to = (from+1)%2; if (ctrl->dbglvl&DBG_REFINE) { mprintf("Parts: ["); for (l=0; lnvtxs, graph->nbnd, graph->mincut, Compute2WayHLoadImbalance(ncon, npwgts, tpwgts)); } for (i=0; imincut); ASSERT(CheckBnd(graph)); ASSERT(CheckGraph(graph)); /* Compute the queues in which each vertex will be assigned to */ for (i=0; i 0) PQueueInsert(&parts[qnum[i]][0], i, ed[i]-id[i]); else PQueueInsert(&parts[qnum[i]][1], i, ed[i]-id[i]); } } mincut = graph->mincut; nbnd = graph->nbnd; for (nswaps=0; nswapsdbglvl&DBG_MOVEINFO) { mprintf("Moved %6D from %D(%D). [%5D] %5D, NPwgts: ", higain, from, cnum, ed[higain]-id[higain], mincut); for (l=0; l 0) mprintf("\t Pulled from the interior!\n"); } /************************************************************** * Update the id[i]/ed[i] values of the affected nodes ***************************************************************/ SWAP(id[higain], ed[higain], tmp); if (ed[higain] == 0 && bndptr[higain] != -1 && xadj[higain] < xadj[higain+1]) BNDDelete(nbnd, bndind, bndptr, higain); if (ed[higain] > 0 && bndptr[higain] == -1) BNDInsert(nbnd, bndind, bndptr, higain); for (j=xadj[higain]; j 0 && bndptr[k] == -1) { /* It moves in boundary */ PQueueDelete(&parts[qnum[k]][1], k, oldgain); PQueueInsert(&parts[qnum[k]][0], k, ed[k]-id[k]); } else { /* It must be in the boundary already */ if (bndptr[k] == -1) mprintf("What you thought was wrong!\n"); PQueueUpdate(&parts[qnum[k]][0], k, oldgain, ed[k]-id[k]); } } /* Update its boundary information */ if (ed[k] == 0 && bndptr[k] != -1) BNDDelete(nbnd, bndind, bndptr, k); else if (ed[k] > 0 && bndptr[k] == -1) BNDInsert(nbnd, bndind, bndptr, k); } ASSERTP(ComputeCut(graph, where) == mincut, ("%d != %d\n", ComputeCut(graph, where), mincut)); } if (ctrl->dbglvl&DBG_REFINE) { mprintf("\tMincut: %6D, NBND: %6D, NPwgts: ", mincut, nbnd); for (l=0; lmincut = mincut; graph->nbnd = nbnd; for (i=0; imincut); ASSERT(CheckBnd(graph)); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); } /************************************************************************* * This function selects the partition number and the queue from which * we will move vertices out **************************************************************************/ idxtype SelectQueueOneWay(idxtype ncon, float *npwgts, float *tpwgts, idxtype from, PQueueType queues[MAXNCON][2]) { idxtype i, cnum=-1; float max=0.0; for (i=0; i= max && PQueueGetSize(&queues[i][0]) + PQueueGetSize(&queues[i][1]) > 0) { max = npwgts[from*ncon+i]-tpwgts[0]; cnum = i; } } return cnum; } PyMetis-0.90/src/metis/minitpart2.c0000640000175000017500000002534710662171744017034 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * minitpart2.c * * This file contains code that performs the initial partition of the * coarsest graph * * Started 7/23/97 * George * * $Id: minitpart2.c,v 1.3 2002/08/10 06:57:50 karypis Exp $ * */ #include /************************************************************************* * This function computes the initial bisection of the coarsest graph **************************************************************************/ void MocInit2WayPartition2(CtrlType *ctrl, GraphType *graph, float *tpwgts, float *ubvec) { idxtype dbglvl; dbglvl = ctrl->dbglvl; IFSET(ctrl->dbglvl, DBG_REFINE, ctrl->dbglvl -= DBG_REFINE); IFSET(ctrl->dbglvl, DBG_MOVEINFO, ctrl->dbglvl -= DBG_MOVEINFO); IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->InitPartTmr)); switch (ctrl->IType) { case ITYPE_GGPKL: case ITYPE_RANDOM: MocGrowBisection2(ctrl, graph, tpwgts, ubvec); break; case 3: MocGrowBisectionNew2(ctrl, graph, tpwgts, ubvec); break; default: errexit("Unknown initial partition type: %d\n", ctrl->IType); } IFSET(ctrl->dbglvl, DBG_IPART, mprintf("Initial Cut: %D\n", graph->mincut)); IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->InitPartTmr)); ctrl->dbglvl = dbglvl; } /************************************************************************* * This function takes a graph and produces a bisection by using a region * growing algorithm. The resulting partition is returned in * graph->where **************************************************************************/ void MocGrowBisection2(CtrlType *ctrl, GraphType *graph, float *tpwgts, float *ubvec) { idxtype i, j, k, nvtxs, ncon, from, bestcut, mincut, nbfs, inbfs; idxtype *bestwhere, *where; nvtxs = graph->nvtxs; MocAllocate2WayPartitionMemory(ctrl, graph); where = graph->where; bestwhere = idxmalloc(nvtxs, "BisectGraph: bestwhere"); nbfs = 2*(nvtxs <= ctrl->CoarsenTo ? SMALLNIPARTS : LARGENIPARTS); for (inbfs=0; inbfs graph->mincut) { bestcut = graph->mincut; idxcopy(nvtxs, where, bestwhere); if (bestcut == 0) break; } } graph->mincut = bestcut; idxcopy(nvtxs, bestwhere, where); gk_free((void **)&bestwhere, LTERM); } /************************************************************************* * This function takes a graph and produces a bisection by using a region * growing algorithm. The resulting partition is returned in * graph->where **************************************************************************/ void MocGrowBisectionNew2(CtrlType *ctrl, GraphType *graph, float *tpwgts, float *ubvec) { idxtype i, j, k, nvtxs, ncon, from, bestcut, mincut, nbfs, inbfs; idxtype *bestwhere, *where; nvtxs = graph->nvtxs; MocAllocate2WayPartitionMemory(ctrl, graph); where = graph->where; bestwhere = idxmalloc(nvtxs, "BisectGraph: bestwhere"); nbfs = 2*(nvtxs <= ctrl->CoarsenTo ? SMALLNIPARTS : LARGENIPARTS); for (inbfs=0; inbfs graph->mincut) { bestcut = graph->mincut; idxcopy(nvtxs, where, bestwhere); if (bestcut == 0) break; } } graph->mincut = bestcut; idxcopy(nvtxs, bestwhere, where); gk_free((void **)&bestwhere, LTERM); } /************************************************************************* * This function balances two partitions by moving the highest gain * (including negative gain) vertices to the other domain. * It is used only when tha unbalance is due to non contigous * subdomains. That is, the are no boundary vertices. * It moves vertices from the domain that is overweight to the one that * is underweight. **************************************************************************/ void MocInit2WayBalance2(CtrlType *ctrl, GraphType *graph, float *tpwgts, float *ubvec) { idxtype i, ii, j, k, l, kwgt, nvtxs, nbnd, ncon, nswaps, from, to, pass, me, cnum, tmp, imin; idxtype *xadj, *adjncy, *adjwgt, *where, *id, *ed, *bndptr, *bndind; idxtype *moved, *perm, *qnum; float *nvwgt, *npwgts, minwgt; PQueueType parts[MAXNCON][2]; idxtype higain, oldgain, mincut; nvtxs = graph->nvtxs; ncon = graph->ncon; xadj = graph->xadj; adjncy = graph->adjncy; nvwgt = graph->nvwgt; adjwgt = graph->adjwgt; where = graph->where; id = graph->id; ed = graph->ed; npwgts = graph->npwgts; bndptr = graph->bndptr; bndind = graph->bndind; moved = idxwspacemalloc(ctrl, nvtxs); perm = idxwspacemalloc(ctrl, nvtxs); qnum = idxwspacemalloc(ctrl, nvtxs); /* This is called for initial partitioning so we know from where to pick nodes */ from = 1; to = (from+1)%2; if (ctrl->dbglvl&DBG_REFINE) { mprintf("Parts: ["); for (l=0; lnvtxs, graph->nbnd, graph->mincut, ComputeLoadImbalance(ncon, 2, npwgts, tpwgts)); } for (i=0; imincut); ASSERT(CheckBnd(graph)); ASSERT(CheckGraph(graph)); /* Compute the queues in which each vertex will be assigned to */ for (i=0; i 0) PQueueInsert(&parts[qnum[i]][0], i, ed[i]-id[i]); else PQueueInsert(&parts[qnum[i]][1], i, ed[i]-id[i]); } } /* for (i=0; imincut; nbnd = graph->nbnd; for (nswaps=0; nswaps minwgt) break; if ((cnum = SelectQueueOneWay2(ncon, npwgts+to*ncon, parts, ubvec)) == -1) break; if ((higain = PQueueGetMax(&parts[cnum][0])) == -1) higain = PQueueGetMax(&parts[cnum][1]); mincut -= (ed[higain]-id[higain]); gk_faxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1); gk_faxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+from*ncon, 1); where[higain] = to; moved[higain] = nswaps; if (ctrl->dbglvl&DBG_MOVEINFO) { mprintf("Moved %6D from %D(%D). [%5D] %5D, NPwgts: ", higain, from, cnum, ed[higain]-id[higain], mincut); for (l=0; l 0) mprintf("\t Pulled from the interior!\n"); } /************************************************************** * Update the id[i]/ed[i] values of the affected nodes ***************************************************************/ SWAP(id[higain], ed[higain], tmp); if (ed[higain] == 0 && bndptr[higain] != -1 && xadj[higain] < xadj[higain+1]) BNDDelete(nbnd, bndind, bndptr, higain); if (ed[higain] > 0 && bndptr[higain] == -1) BNDInsert(nbnd, bndind, bndptr, higain); for (j=xadj[higain]; j 0 && bndptr[k] == -1) { /* It moves in boundary */ PQueueDelete(&parts[qnum[k]][1], k, oldgain); PQueueInsert(&parts[qnum[k]][0], k, ed[k]-id[k]); } else { /* It must be in the boundary already */ if (bndptr[k] == -1) mprintf("What you thought was wrong!\n"); PQueueUpdate(&parts[qnum[k]][0], k, oldgain, ed[k]-id[k]); } } /* Update its boundary information */ if (ed[k] == 0 && bndptr[k] != -1) BNDDelete(nbnd, bndind, bndptr, k); else if (ed[k] > 0 && bndptr[k] == -1) BNDInsert(nbnd, bndind, bndptr, k); } ASSERTP(ComputeCut(graph, where) == mincut, ("%d != %d\n", ComputeCut(graph, where), mincut)); } if (ctrl->dbglvl&DBG_REFINE) { mprintf("\tMincut: %6D, NBND: %6D, NPwgts: ", mincut, nbnd); for (l=0; lmincut = mincut; graph->nbnd = nbnd; for (i=0; imincut); ASSERT(CheckBnd(graph)); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); } /************************************************************************* * This function selects the partition number and the queue from which * we will move vertices out **************************************************************************/ idxtype SelectQueueOneWay2(idxtype ncon, float *pto, PQueueType queues[MAXNCON][2], float *ubvec) { idxtype i, cnum=-1, imax, maxgain; float max=0.0; float twgt[MAXNCON]; for (i=0; i 0 || PQueueGetSize(&queues[i][1]) > 0)) { max = twgt[i]; cnum = i; } } if (max > 1) return cnum; /* optimize of cut */ maxgain = -10000000; for (i=0; i 0 && PQueueGetKey(&queues[i][0]) > maxgain) { maxgain = PQueueGetKey(&queues[i][0]); cnum = i; } } return cnum; } PyMetis-0.90/src/metis/mkmetis.c0000640000175000017500000000735410662171744016412 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * mkmetis.c * * This file contains the top level routines for the multilevel k-way partitioning * algorithm KMETIS. * * Started 7/28/97 * George * * $Id: mkmetis.c,v 1.3 2002/08/10 07:07:27 karypis Exp $ * */ #include /************************************************************************* * This function is the entry point for KWMETIS **************************************************************************/ void METIS_mCPartGraphKway(idxtype *nvtxs, idxtype *ncon, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *rubvec, idxtype *options, idxtype *edgecut, idxtype *part) { idxtype i, j; GraphType graph; CtrlType ctrl; if (*numflag == 1) Change2CNumbering(*nvtxs, xadj, adjncy); SetUpGraph(&graph, OP_KMETIS, *nvtxs, *ncon, xadj, adjncy, vwgt, adjwgt, *wgtflag); if (options[0] == 0) { /* Use the default parameters */ ctrl.CType = McKMETIS_CTYPE; ctrl.IType = McKMETIS_ITYPE; ctrl.RType = McKMETIS_RTYPE; ctrl.dbglvl = McKMETIS_DBGLVL; } else { ctrl.CType = options[OPTION_CTYPE]; ctrl.IType = options[OPTION_ITYPE]; ctrl.RType = options[OPTION_RTYPE]; ctrl.dbglvl = options[OPTION_DBGLVL]; } ctrl.optype = OP_KMETIS; ctrl.CoarsenTo = amax((*nvtxs)/(20*gk_log2(*nparts)), 30*(*nparts)); ctrl.nmaxvwgt = 1.5/(1.0*ctrl.CoarsenTo); InitRandom(-1); AllocateWorkSpace(&ctrl, &graph, *nparts); IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl)); IFSET(ctrl.dbglvl, DBG_TIME, gk_startcputimer(ctrl.TotalTmr)); *edgecut = MCMlevelKWayPartitioning(&ctrl, &graph, *nparts, part, rubvec); IFSET(ctrl.dbglvl, DBG_TIME, gk_stopcputimer(ctrl.TotalTmr)); IFSET(ctrl.dbglvl, DBG_TIME, PrintTimers(&ctrl)); FreeWorkSpace(&ctrl, &graph); if (*numflag == 1) Change2FNumbering(*nvtxs, xadj, adjncy, part); } /************************************************************************* * This function takes a graph and produces a bisection of it **************************************************************************/ idxtype MCMlevelKWayPartitioning(CtrlType *ctrl, GraphType *graph, idxtype nparts, idxtype *part, float *rubvec) { idxtype i, j, nvtxs; GraphType *cgraph; idxtype options[10], edgecut; cgraph = MCCoarsen2Way(ctrl, graph); IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->InitPartTmr)); MocAllocateKWayPartitionMemory(ctrl, cgraph, nparts); options[0] = 1; options[OPTION_CTYPE] = MTYPE_SBHEM_INFNORM; options[OPTION_ITYPE] = ITYPE_RANDOM; options[OPTION_RTYPE] = RTYPE_FM; options[OPTION_DBGLVL] = 0; /* Determine what you will use as the initial partitioner, based on tolerances */ for (i=0; incon; i++) { if (rubvec[i] > 1.2) break; } if (i == graph->ncon) METIS_mCPartGraphRecursiveInternal(&cgraph->nvtxs, &cgraph->ncon, cgraph->xadj, cgraph->adjncy, cgraph->nvwgt, cgraph->adjwgt, &nparts, options, &edgecut, cgraph->where); else METIS_mCHPartGraphRecursiveInternal(&cgraph->nvtxs, &cgraph->ncon, cgraph->xadj, cgraph->adjncy, cgraph->nvwgt, cgraph->adjwgt, &nparts, rubvec, options, &edgecut, cgraph->where); IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->InitPartTmr)); IFSET(ctrl->dbglvl, DBG_IPART, mprintf("Initial %D-way partitioning cut: %D\n", nparts, edgecut)); IFSET(ctrl->dbglvl, DBG_KWAYPINFO, ComputePartitionInfo(cgraph, nparts, cgraph->where)); MocRefineKWayHorizontal(ctrl, graph, cgraph, nparts, rubvec); idxcopy(graph->nvtxs, graph->where, part); FreeGraph(graph, 0); return graph->mincut; } PyMetis-0.90/src/metis/mkwayfmh.c0000640000175000017500000004773510662171744016573 0ustar andreasandreas/* * mkwayfmh.c * * This file contains code that implements the multilevel k-way refinement * * Started 7/28/97 * George * * $Id: mkwayfmh.c,v 1.2 2002/08/10 06:29:33 karypis Exp $ * */ #include /************************************************************************* * This function performs k-way refinement **************************************************************************/ void MCRandom_KWayEdgeRefineHorizontal(CtrlType *ctrl, GraphType *graph, idxtype nparts, float *orgubvec, idxtype npasses) { idxtype i, ii, iii, j, jj, k, l, pass, nvtxs, ncon, nmoves, nbnd, myndegrees, same; idxtype from, me, to, oldcut, gain; idxtype *xadj, *adjncy, *adjwgt; idxtype *where, *perm, *bndptr, *bndind; EDegreeType *myedegrees; RInfoType *myrinfo; float *npwgts, *nvwgt, *minwgt, *maxwgt, maxlb, minlb, ubvec[MAXNCON], tvec[MAXNCON]; nvtxs = graph->nvtxs; ncon = graph->ncon; xadj = graph->xadj; adjncy = graph->adjncy; adjwgt = graph->adjwgt; bndptr = graph->bndptr; bndind = graph->bndind; where = graph->where; npwgts = graph->npwgts; /* Setup the weight intervals of the various subdomains */ minwgt = fwspacemalloc(ctrl, nparts*ncon); maxwgt = fwspacemalloc(ctrl, nparts*ncon); /* See if the orgubvec consists of identical constraints */ maxlb = minlb = orgubvec[0]; for (i=1; i maxlb ? orgubvec[i] : maxlb); } same = (fabs(maxlb-minlb) < .01 ? 1 : 0); /* Let's not get very optimistic. Let Balancing do the work */ ComputeHKWayLoadImbalance(ncon, nparts, npwgts, ubvec); for (i=0; i maxlb ? ubvec[i] : maxlb); for (i=0; idbglvl&DBG_REFINE) { mprintf("Partitions: [%5.4f %5.4f], Nv-Nb[%6D %6D]. Cut: %6D, LB: ", npwgts[gk_fargmin(ncon*nparts, npwgts)], npwgts[gk_fargmax(ncon*nparts, npwgts)], graph->nvtxs, graph->nbnd, graph->mincut); ComputeHKWayLoadImbalance(ncon, nparts, npwgts, tvec); for (i=0; imincut); oldcut = graph->mincut; nbnd = graph->nbnd; RandomPermute(nbnd, perm, 1); for (nmoves=iii=0; iiinbnd; iii++) { ii = perm[iii]; if (ii >= nbnd) continue; i = bndind[ii]; myrinfo = graph->rinfo+i; if (myrinfo->ed >= myrinfo->id) { /* Total ED is too high */ from = where[i]; nvwgt = graph->nvwgt+i*ncon; if (myrinfo->id > 0 && AreAllHVwgtsBelow(ncon, 1.0, npwgts+from*ncon, -1.0, nvwgt, minwgt+from*ncon)) continue; /* This cannot be moved! */ myedegrees = myrinfo->edegrees; myndegrees = myrinfo->ndegrees; for (k=0; kid; if (gain >= 0 && (AreAllHVwgtsBelow(ncon, 1.0, npwgts+to*ncon, 1.0, nvwgt, maxwgt+to*ncon) || IsHBalanceBetterFT(ncon, nparts, npwgts+from*ncon, npwgts+to*ncon, nvwgt, ubvec))) break; } if (k == myndegrees) continue; /* break out if you did not find a candidate */ for (j=k+1; j myedegrees[k].ed && (AreAllHVwgtsBelow(ncon, 1.0, npwgts+to*ncon, 1.0, nvwgt, maxwgt+to*ncon) || IsHBalanceBetterFT(ncon, nparts, npwgts+from*ncon, npwgts+to*ncon, nvwgt, ubvec))) || (myedegrees[j].ed == myedegrees[k].ed && IsHBalanceBetterTT(ncon, nparts, npwgts+myedegrees[k].pid*ncon, npwgts+to*ncon, nvwgt, ubvec))) k = j; } to = myedegrees[k].pid; if (myedegrees[k].ed-myrinfo->id == 0 && !IsHBalanceBetterFT(ncon, nparts, npwgts+from*ncon, npwgts+to*ncon, nvwgt, ubvec) && AreAllHVwgtsBelow(ncon, 1.0, npwgts+from*ncon, 0.0, npwgts+from*ncon, maxwgt+from*ncon)) continue; /*===================================================================== * If we got here, we can now move the vertex from 'from' to 'to' *======================================================================*/ graph->mincut -= myedegrees[k].ed-myrinfo->id; IFSET(ctrl->dbglvl, DBG_MOVEINFO, mprintf("\t\tMoving %6D to %3D. Gain: %4D. Cut: %6D\n", i, to, myedegrees[k].ed-myrinfo->id, graph->mincut)); /* Update where, weight, and ID/ED information of the vertex you moved */ gk_faxpy(ncon, 1.0, nvwgt, 1, npwgts+to*ncon, 1); gk_faxpy(ncon, -1.0, nvwgt, 1, npwgts+from*ncon, 1); where[i] = to; myrinfo->ed += myrinfo->id-myedegrees[k].ed; SWAP(myrinfo->id, myedegrees[k].ed, j); if (myedegrees[k].ed == 0) myedegrees[k] = myedegrees[--myrinfo->ndegrees]; else myedegrees[k].pid = from; if (myrinfo->ed-myrinfo->id < 0) BNDDelete(nbnd, bndind, bndptr, i); /* Update the degrees of adjacent vertices */ for (j=xadj[i]; jrinfo+ii; if (myrinfo->edegrees == NULL) { myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree; ctrl->wspace.cdegree += xadj[ii+1]-xadj[ii]; } myedegrees = myrinfo->edegrees; ASSERT(CheckRInfo(myrinfo)); if (me == from) { INC_DEC(myrinfo->ed, myrinfo->id, adjwgt[j]); if (myrinfo->ed-myrinfo->id >= 0 && bndptr[ii] == -1) BNDInsert(nbnd, bndind, bndptr, ii); } else if (me == to) { INC_DEC(myrinfo->id, myrinfo->ed, adjwgt[j]); if (myrinfo->ed-myrinfo->id < 0 && bndptr[ii] != -1) BNDDelete(nbnd, bndind, bndptr, ii); } /* Remove contribution from the .ed of 'from' */ if (me != from) { for (k=0; kndegrees; k++) { if (myedegrees[k].pid == from) { if (myedegrees[k].ed == adjwgt[j]) myedegrees[k] = myedegrees[--myrinfo->ndegrees]; else myedegrees[k].ed -= adjwgt[j]; break; } } } /* Add contribution to the .ed of 'to' */ if (me != to) { for (k=0; kndegrees; k++) { if (myedegrees[k].pid == to) { myedegrees[k].ed += adjwgt[j]; break; } } if (k == myrinfo->ndegrees) { myedegrees[myrinfo->ndegrees].pid = to; myedegrees[myrinfo->ndegrees++].ed = adjwgt[j]; } } ASSERT(myrinfo->ndegrees <= xadj[ii+1]-xadj[ii]); ASSERT(CheckRInfo(myrinfo)); } nmoves++; } } graph->nbnd = nbnd; if (ctrl->dbglvl&DBG_REFINE) { mprintf("\t [%5.4f %5.4f], Nb: %6D, Nmoves: %5D, Cut: %6D, LB: ", npwgts[gk_fargmin(ncon*nparts, npwgts)], npwgts[gk_fargmax(ncon*nparts, npwgts)], nbnd, nmoves, graph->mincut); ComputeHKWayLoadImbalance(ncon, nparts, npwgts, tvec); for (i=0; imincut == oldcut) break; } fwspacefree(ctrl, ncon*nparts); fwspacefree(ctrl, ncon*nparts); idxwspacefree(ctrl, nvtxs); } /************************************************************************* * This function performs k-way refinement **************************************************************************/ void MCGreedy_KWayEdgeBalanceHorizontal(CtrlType *ctrl, GraphType *graph, idxtype nparts, float *ubvec, idxtype npasses) { idxtype i, ii, iii, j, jj, k, l, pass, nvtxs, ncon, nbnd, myndegrees, oldgain, gain, nmoves; idxtype from, me, to, oldcut; idxtype *xadj, *adjncy, *adjwgt; idxtype *where, *perm, *bndptr, *bndind, *moved; EDegreeType *myedegrees; RInfoType *myrinfo; PQueueType queue; float *npwgts, *nvwgt, *minwgt, *maxwgt, tvec[MAXNCON]; nvtxs = graph->nvtxs; ncon = graph->ncon; xadj = graph->xadj; adjncy = graph->adjncy; adjwgt = graph->adjwgt; bndind = graph->bndind; bndptr = graph->bndptr; where = graph->where; npwgts = graph->npwgts; /* Setup the weight intervals of the various subdomains */ minwgt = fwspacemalloc(ctrl, ncon*nparts); maxwgt = fwspacemalloc(ctrl, ncon*nparts); for (i=0; iadjwgtsum[idxargmax(nvtxs, graph->adjwgtsum)]); if (ctrl->dbglvl&DBG_REFINE) { mprintf("Partitions: [%5.4f %5.4f], Nv-Nb[%6D %6D]. Cut: %6D, LB: ", npwgts[gk_fargmin(ncon*nparts, npwgts)], npwgts[gk_fargmax(ncon*nparts, npwgts)], graph->nvtxs, graph->nbnd, graph->mincut); ComputeHKWayLoadImbalance(ncon, nparts, npwgts, tvec); for (i=0; imincut); /* Check to see if things are out of balance, given the tolerance */ if (MocIsHBalanced(ncon, nparts, npwgts, ubvec)) break; PQueueReset(&queue); idxset(nvtxs, -1, moved); oldcut = graph->mincut; nbnd = graph->nbnd; RandomPermute(nbnd, perm, 1); for (ii=0; iirinfo[i].ed - graph->rinfo[i].id); moved[i] = 2; } nmoves = 0; for (;;) { if ((i = PQueueGetMax(&queue)) == -1) break; moved[i] = 1; myrinfo = graph->rinfo+i; from = where[i]; nvwgt = graph->nvwgt+i*ncon; if (AreAllHVwgtsBelow(ncon, 1.0, npwgts+from*ncon, -1.0, nvwgt, minwgt+from*ncon)) continue; /* This cannot be moved! */ myedegrees = myrinfo->edegrees; myndegrees = myrinfo->ndegrees; for (k=0; kid >= 0) j++; if (!AreAllHVwgtsAbove(ncon, 1.0, npwgts+to*ncon, 0.0, nvwgt, minwgt+to*ncon) && AreAllHVwgtsBelow(ncon, 1.0, npwgts+to*ncon, 1.0, nvwgt, maxwgt+to*ncon)) j++; if (j == 0) continue; /* DELETE if (myedegrees[k].ed-myrinfo->id < 0 && AreAllHVwgtsBelow(ncon, 1.0, npwgts+from*ncon, 0.0, nvwgt, maxwgt+from*ncon) && AreAllHVwgtsAbove(ncon, 1.0, npwgts+to*ncon, 0.0, nvwgt, minwgt+to*ncon) && AreAllHVwgtsBelow(ncon, 1.0, npwgts+to*ncon, 1.0, nvwgt, maxwgt+to*ncon)) continue; */ /*===================================================================== * If we got here, we can now move the vertex from 'from' to 'to' *======================================================================*/ graph->mincut -= myedegrees[k].ed-myrinfo->id; IFSET(ctrl->dbglvl, DBG_MOVEINFO, mprintf("\t\tMoving %6D to %3D. Gain: %4D. Cut: %6D\n", i, to, myedegrees[k].ed-myrinfo->id, graph->mincut)); /* Update where, weight, and ID/ED information of the vertex you moved */ gk_faxpy(ncon, 1.0, nvwgt, 1, npwgts+to*ncon, 1); gk_faxpy(ncon, -1.0, nvwgt, 1, npwgts+from*ncon, 1); where[i] = to; myrinfo->ed += myrinfo->id-myedegrees[k].ed; SWAP(myrinfo->id, myedegrees[k].ed, j); if (myedegrees[k].ed == 0) myedegrees[k] = myedegrees[--myrinfo->ndegrees]; else myedegrees[k].pid = from; if (myrinfo->ed == 0) BNDDelete(nbnd, bndind, bndptr, i); /* Update the degrees of adjacent vertices */ for (j=xadj[i]; jrinfo+ii; if (myrinfo->edegrees == NULL) { myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree; ctrl->wspace.cdegree += xadj[ii+1]-xadj[ii]; } myedegrees = myrinfo->edegrees; ASSERT(CheckRInfo(myrinfo)); oldgain = (myrinfo->ed-myrinfo->id); if (me == from) { INC_DEC(myrinfo->ed, myrinfo->id, adjwgt[j]); if (myrinfo->ed > 0 && bndptr[ii] == -1) BNDInsert(nbnd, bndind, bndptr, ii); } else if (me == to) { INC_DEC(myrinfo->id, myrinfo->ed, adjwgt[j]); if (myrinfo->ed == 0 && bndptr[ii] != -1) BNDDelete(nbnd, bndind, bndptr, ii); } /* Remove contribution from the .ed of 'from' */ if (me != from) { for (k=0; kndegrees; k++) { if (myedegrees[k].pid == from) { if (myedegrees[k].ed == adjwgt[j]) myedegrees[k] = myedegrees[--myrinfo->ndegrees]; else myedegrees[k].ed -= adjwgt[j]; break; } } } /* Add contribution to the .ed of 'to' */ if (me != to) { for (k=0; kndegrees; k++) { if (myedegrees[k].pid == to) { myedegrees[k].ed += adjwgt[j]; break; } } if (k == myrinfo->ndegrees) { myedegrees[myrinfo->ndegrees].pid = to; myedegrees[myrinfo->ndegrees++].ed = adjwgt[j]; } } /* Update the queue */ if (me == to || me == from) { gain = myrinfo->ed-myrinfo->id; if (moved[ii] == 2) { if (myrinfo->ed > 0) PQueueUpdate(&queue, ii, oldgain, gain); else { PQueueDelete(&queue, ii, oldgain); moved[ii] = -1; } } else if (moved[ii] == -1 && myrinfo->ed > 0) { PQueueInsert(&queue, ii, gain); moved[ii] = 2; } } ASSERT(myrinfo->ndegrees <= xadj[ii+1]-xadj[ii]); ASSERT(CheckRInfo(myrinfo)); } nmoves++; } graph->nbnd = nbnd; if (ctrl->dbglvl&DBG_REFINE) { mprintf("\t [%5.4f %5.4f], Nb: %6D, Nmoves: %5D, Cut: %6D, LB: ", npwgts[gk_fargmin(ncon*nparts, npwgts)], npwgts[gk_fargmax(ncon*nparts, npwgts)], nbnd, nmoves, graph->mincut); ComputeHKWayLoadImbalance(ncon, nparts, npwgts, tvec); for (i=0; i limit[i]) return 0; return 1; } /************************************************************************* * This function checks if the vertex weights of two vertices are above * a given set of values **************************************************************************/ idxtype AreAllHVwgtsAbove(idxtype ncon, float alpha, float *vwgt1, float beta, float *vwgt2, float *limit) { idxtype i; for (i=0; i max) max = npwgts[j*ncon+i]; } lbvec[i] = max*nparts; } } /************************************************************************* * This function determines if a partitioning is horizontally balanced **************************************************************************/ idxtype MocIsHBalanced(idxtype ncon, idxtype nparts, float *npwgts, float *ubvec) { idxtype i, j; float max; for (i=0; i max) max = npwgts[j*ncon+i]; } if (ubvec[i] < max*nparts) return 0; } return 1; } /************************************************************************* * This function checks if the pairwise balance of the between the two * partitions will improve by moving the vertex v from pfrom to pto, * subject to the target partition weights of tfrom, and tto respectively **************************************************************************/ idxtype IsHBalanceBetterFT(idxtype ncon, idxtype nparts, float *pfrom, float *pto, float *vwgt, float *ubvec) { idxtype i, j, k; float blb1=0.0, alb1=0.0, sblb=0.0, salb=0.0; float blb2=0.0, alb2=0.0; float temp; for (i=0; i m11) return 0; if (m22 < m12) return 1; if (m22 > m12) return 0; return sm2 < sm1; } PyMetis-0.90/src/metis/mkwayrefine.c0000640000175000017500000002065610662171744017262 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * mkwayrefine.c * * This file contains the driving routines for multilevel k-way refinement * * Started 7/28/97 * George * * $Id: mkwayrefine.c,v 1.2 2002/08/10 06:29:33 karypis Exp $ */ #include /************************************************************************* * This function is the entry point of refinement **************************************************************************/ void MocRefineKWayHorizontal(CtrlType *ctrl, GraphType *orggraph, GraphType *graph, idxtype nparts, float *ubvec) { IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->UncoarsenTmr)); /* Compute the parameters of the coarsest graph */ MocComputeKWayPartitionParams(ctrl, graph, nparts); for (;;) { IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->RefTmr)); if (!MocIsHBalanced(graph->ncon, nparts, graph->npwgts, ubvec)) { MocComputeKWayBalanceBoundary(ctrl, graph, nparts); MCGreedy_KWayEdgeBalanceHorizontal(ctrl, graph, nparts, ubvec, 4); ComputeKWayBoundary(ctrl, graph, nparts); } MCRandom_KWayEdgeRefineHorizontal(ctrl, graph, nparts, ubvec, 10); IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->RefTmr)); if (graph == orggraph) break; graph = graph->finer; IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->ProjectTmr)); MocProjectKWayPartition(ctrl, graph, nparts); IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->ProjectTmr)); } if (!MocIsHBalanced(graph->ncon, nparts, graph->npwgts, ubvec)) { MocComputeKWayBalanceBoundary(ctrl, graph, nparts); MCGreedy_KWayEdgeBalanceHorizontal(ctrl, graph, nparts, ubvec, 4); ComputeKWayBoundary(ctrl, graph, nparts); MCRandom_KWayEdgeRefineHorizontal(ctrl, graph, nparts, ubvec, 10); } IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->UncoarsenTmr)); } /************************************************************************* * This function allocates memory for k-way edge refinement **************************************************************************/ void MocAllocateKWayPartitionMemory(CtrlType *ctrl, GraphType *graph, idxtype nparts) { idxtype nvtxs, ncon; nvtxs = graph->nvtxs; ncon = graph->ncon; graph->where = idxmalloc(nvtxs, "MocAllocateKWayPartitionMemory: where"); graph->bndptr = idxmalloc(nvtxs, "MocAllocateKWayPartitionMemory: bndptr"); graph->bndind = idxmalloc(nvtxs, "MocAllocateKWayPartitionMemory: bndind"); graph->npwgts = gk_fmalloc(ncon*nparts, "MocAllocateKWayPartitionMemory: npwgts"); graph->rinfo = (RInfoType *)gk_malloc(nvtxs*sizeof(RInfoType), "MocAllocateKWayPartitionMemory: rinfo"); } /************************************************************************* * This function computes the initial id/ed **************************************************************************/ void MocComputeKWayPartitionParams(CtrlType *ctrl, GraphType *graph, idxtype nparts) { idxtype i, j, k, l, nvtxs, ncon, nbnd, mincut, me, other; idxtype *xadj, *adjncy, *adjwgt, *where, *bndind, *bndptr; RInfoType *rinfo, *myrinfo; EDegreeType *myedegrees; float *nvwgt, *npwgts; nvtxs = graph->nvtxs; ncon = graph->ncon; xadj = graph->xadj; nvwgt = graph->nvwgt; adjncy = graph->adjncy; adjwgt = graph->adjwgt; where = graph->where; npwgts = gk_fset(ncon*nparts, 0.0, graph->npwgts); bndind = graph->bndind; bndptr = idxset(nvtxs, -1, graph->bndptr); rinfo = graph->rinfo; /*------------------------------------------------------------ / Compute now the id/ed degrees /------------------------------------------------------------*/ ctrl->wspace.cdegree = 0; nbnd = mincut = 0; for (i=0; iid = myrinfo->ed = myrinfo->ndegrees = 0; myrinfo->edegrees = NULL; for (j=xadj[i]; jed += adjwgt[j]; } myrinfo->id = graph->adjwgtsum[i] - myrinfo->ed; if (myrinfo->ed > 0) mincut += myrinfo->ed; if (myrinfo->ed-myrinfo->id >= 0) BNDInsert(nbnd, bndind, bndptr, i); /* Time to compute the particular external degrees */ if (myrinfo->ed > 0) { myedegrees = myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree; ctrl->wspace.cdegree += xadj[i+1]-xadj[i]; for (j=xadj[i]; jndegrees; k++) { if (myedegrees[k].pid == other) { myedegrees[k].ed += adjwgt[j]; break; } } if (k == myrinfo->ndegrees) { myedegrees[myrinfo->ndegrees].pid = other; myedegrees[myrinfo->ndegrees++].ed = adjwgt[j]; } } } ASSERT(myrinfo->ndegrees <= xadj[i+1]-xadj[i]); } } graph->mincut = mincut/2; graph->nbnd = nbnd; } /************************************************************************* * This function projects a partition, and at the same time computes the * parameters for refinement. **************************************************************************/ void MocProjectKWayPartition(CtrlType *ctrl, GraphType *graph, idxtype nparts) { idxtype i, j, k, nvtxs, nbnd, me, other, istart, iend, ndegrees; idxtype *xadj, *adjncy, *adjwgt, *adjwgtsum; idxtype *cmap, *where, *bndptr, *bndind; idxtype *cwhere; GraphType *cgraph; RInfoType *crinfo, *rinfo, *myrinfo; EDegreeType *myedegrees; idxtype *htable; cgraph = graph->coarser; cwhere = cgraph->where; crinfo = cgraph->rinfo; nvtxs = graph->nvtxs; cmap = graph->cmap; xadj = graph->xadj; adjncy = graph->adjncy; adjwgt = graph->adjwgt; adjwgtsum = graph->adjwgtsum; MocAllocateKWayPartitionMemory(ctrl, graph, nparts); where = graph->where; rinfo = graph->rinfo; bndind = graph->bndind; bndptr = idxset(nvtxs, -1, graph->bndptr); /* Go through and project partition and compute id/ed for the nodes */ for (i=0; iwspace.cdegree = 0; for (nbnd=0, i=0; iid = myrinfo->ed = myrinfo->ndegrees = 0; myrinfo->edegrees = NULL; myrinfo->id = adjwgtsum[i]; if (cmap[i] > 0) { /* If it is an interface node. Note cmap[i] = crinfo[cmap[i]].ed */ istart = xadj[i]; iend = xadj[i+1]; myedegrees = myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree; ctrl->wspace.cdegree += iend-istart; ndegrees = 0; for (j=istart; jed += adjwgt[j]; if ((k = htable[other]) == -1) { htable[other] = ndegrees; myedegrees[ndegrees].pid = other; myedegrees[ndegrees++].ed = adjwgt[j]; } else { myedegrees[k].ed += adjwgt[j]; } } } myrinfo->id -= myrinfo->ed; /* Remove space for edegrees if it was interior */ if (myrinfo->ed == 0) { myrinfo->edegrees = NULL; ctrl->wspace.cdegree -= iend-istart; } else { if (myrinfo->ed-myrinfo->id >= 0) BNDInsert(nbnd, bndind, bndptr, i); myrinfo->ndegrees = ndegrees; for (j=0; jncon*nparts, cgraph->npwgts, graph->npwgts); graph->mincut = cgraph->mincut; graph->nbnd = nbnd; FreeGraph(graph->coarser, 1); graph->coarser = NULL; idxwspacefree(ctrl, nparts); ASSERT(CheckBnd2(graph)); } /************************************************************************* * This function computes the boundary definition for balancing **************************************************************************/ void MocComputeKWayBalanceBoundary(CtrlType *ctrl, GraphType *graph, idxtype nparts) { idxtype i, nvtxs, nbnd; idxtype *bndind, *bndptr; nvtxs = graph->nvtxs; bndind = graph->bndind; bndptr = idxset(nvtxs, -1, graph->bndptr); /* Compute the new boundary */ nbnd = 0; for (i=0; irinfo[i].ed > 0) BNDInsert(nbnd, bndind, bndptr, i); } graph->nbnd = nbnd; } PyMetis-0.90/src/metis/mmatch.c0000640000175000017500000003220010662171744016176 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * mmatch.c * * This file contains the code that computes matchings and creates the next * level coarse graph. * * Started 7/23/97 * George * * $Id: mmatch.c,v 1.2 2002/08/10 06:29:33 karypis Exp $ * */ #include /************************************************************************* * This function finds a matching using the HEM heuristic **************************************************************************/ void MCMatch_RM(CtrlType *ctrl, GraphType *graph) { idxtype i, ii, j, k, nvtxs, ncon, cnvtxs, maxidx; idxtype *xadj, *adjncy, *adjwgt; idxtype *match, *cmap, *perm; float *nvwgt; IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->MatchTmr)); nvtxs = graph->nvtxs; ncon = graph->ncon; xadj = graph->xadj; nvwgt = graph->nvwgt; adjncy = graph->adjncy; adjwgt = graph->adjwgt; cmap = graph->cmap; match = idxset(nvtxs, UNMATCHED, idxwspacemalloc(ctrl, nvtxs)); perm = idxwspacemalloc(ctrl, nvtxs); RandomPermute(nvtxs, perm, 1); cnvtxs = 0; for (ii=0; iinmaxvwgt)) { maxidx = k; break; } } cmap[i] = cmap[maxidx] = cnvtxs++; match[i] = maxidx; match[maxidx] = i; } } IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->MatchTmr)); CreateCoarseGraph(ctrl, graph, cnvtxs, match, perm); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); } /************************************************************************* * This function finds a matching using the HEM heuristic **************************************************************************/ void MCMatch_HEM(CtrlType *ctrl, GraphType *graph) { idxtype i, ii, j, k, l, nvtxs, cnvtxs, ncon, maxidx, maxwgt; idxtype *xadj, *adjncy, *adjwgt; idxtype *match, *cmap, *perm; float *nvwgt; IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->MatchTmr)); nvtxs = graph->nvtxs; ncon = graph->ncon; xadj = graph->xadj; nvwgt = graph->nvwgt; adjncy = graph->adjncy; adjwgt = graph->adjwgt; cmap = graph->cmap; match = idxset(nvtxs, UNMATCHED, idxwspacemalloc(ctrl, nvtxs)); perm = idxwspacemalloc(ctrl, nvtxs); RandomPermute(nvtxs, perm, 1); cnvtxs = 0; for (ii=0; iinmaxvwgt)) { maxwgt = adjwgt[j]; maxidx = adjncy[j]; } } cmap[i] = cmap[maxidx] = cnvtxs++; match[i] = maxidx; match[maxidx] = i; } } IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->MatchTmr)); CreateCoarseGraph(ctrl, graph, cnvtxs, match, perm); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); } /************************************************************************* * This function finds a matching using the HEM heuristic **************************************************************************/ void MCMatch_SHEM(CtrlType *ctrl, GraphType *graph) { idxtype i, ii, j, k, nvtxs, cnvtxs, ncon, maxidx, maxwgt, avgdegree; idxtype *xadj, *adjncy, *adjwgt; idxtype *match, *cmap, *degrees, *perm, *tperm; float *nvwgt; IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->MatchTmr)); nvtxs = graph->nvtxs; ncon = graph->ncon; xadj = graph->xadj; nvwgt = graph->nvwgt; adjncy = graph->adjncy; adjwgt = graph->adjwgt; cmap = graph->cmap; match = idxset(nvtxs, UNMATCHED, idxwspacemalloc(ctrl, nvtxs)); perm = idxwspacemalloc(ctrl, nvtxs); tperm = idxwspacemalloc(ctrl, nvtxs); degrees = idxwspacemalloc(ctrl, nvtxs); RandomPermute(nvtxs, tperm, 1); avgdegree = 0.7*(xadj[nvtxs]/nvtxs); for (i=0; i avgdegree ? avgdegree : xadj[i+1]-xadj[i]); BucketSortKeysInc(nvtxs, avgdegree, degrees, tperm, perm); cnvtxs = 0; /* Take care any islands. Islands are matched with non-islands due to coarsening */ for (ii=0; iiii; j--) { k = perm[j]; if (match[k] == UNMATCHED && xadj[k] < xadj[k+1]) { maxidx = k; break; } } cmap[i] = cmap[maxidx] = cnvtxs++; match[i] = maxidx; match[maxidx] = i; } } /* Continue with normal matching */ for (; iinmaxvwgt)) { maxwgt = adjwgt[j]; maxidx = adjncy[j]; } } cmap[i] = cmap[maxidx] = cnvtxs++; match[i] = maxidx; match[maxidx] = i; } } IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->MatchTmr)); idxwspacefree(ctrl, nvtxs); /* degrees */ idxwspacefree(ctrl, nvtxs); /* tperm */ CreateCoarseGraph(ctrl, graph, cnvtxs, match, perm); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); } /************************************************************************* * This function finds a matching using the HEM heuristic **************************************************************************/ void MCMatch_SHEBM(CtrlType *ctrl, GraphType *graph, idxtype norm) { idxtype i, ii, j, k, nvtxs, cnvtxs, ncon, maxidx, maxwgt, avgdegree; idxtype *xadj, *adjncy, *adjwgt; idxtype *match, *cmap, *degrees, *perm, *tperm; float *nvwgt; IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->MatchTmr)); nvtxs = graph->nvtxs; ncon = graph->ncon; xadj = graph->xadj; nvwgt = graph->nvwgt; adjncy = graph->adjncy; adjwgt = graph->adjwgt; cmap = graph->cmap; match = idxset(nvtxs, UNMATCHED, idxwspacemalloc(ctrl, nvtxs)); perm = idxwspacemalloc(ctrl, nvtxs); tperm = idxwspacemalloc(ctrl, nvtxs); degrees = idxwspacemalloc(ctrl, nvtxs); RandomPermute(nvtxs, tperm, 1); avgdegree = 0.7*(xadj[nvtxs]/nvtxs); for (i=0; i avgdegree ? avgdegree : xadj[i+1]-xadj[i]); BucketSortKeysInc(nvtxs, avgdegree, degrees, tperm, perm); cnvtxs = 0; /* Take care any islands. Islands are matched with non-islands due to coarsening */ for (ii=0; iiii; j--) { k = perm[j]; if (match[k] == UNMATCHED && xadj[k] < xadj[k+1]) { maxidx = k; break; } } cmap[i] = cmap[maxidx] = cnvtxs++; match[i] = maxidx; match[maxidx] = i; } } /* Continue with normal matching */ for (; iinmaxvwgt) && (maxwgt < adjwgt[j] || (maxwgt == adjwgt[j] && BetterVBalance(ncon, norm, nvwgt+i*ncon, nvwgt+maxidx*ncon, nvwgt+k*ncon) >= 0 ) ) ) { maxwgt = adjwgt[j]; maxidx = k; } } cmap[i] = cmap[maxidx] = cnvtxs++; match[i] = maxidx; match[maxidx] = i; } } IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->MatchTmr)); idxwspacefree(ctrl, nvtxs); /* degrees */ idxwspacefree(ctrl, nvtxs); /* tperm */ CreateCoarseGraph(ctrl, graph, cnvtxs, match, perm); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); } /************************************************************************* * This function finds a matching using the HEM heuristic **************************************************************************/ void MCMatch_SBHEM(CtrlType *ctrl, GraphType *graph, idxtype norm) { idxtype i, ii, j, k, nvtxs, cnvtxs, ncon, maxidx, maxwgt, avgdegree; idxtype *xadj, *adjncy, *adjwgt; idxtype *match, *cmap, *degrees, *perm, *tperm; float *nvwgt, vbal; IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->MatchTmr)); nvtxs = graph->nvtxs; ncon = graph->ncon; xadj = graph->xadj; nvwgt = graph->nvwgt; adjncy = graph->adjncy; adjwgt = graph->adjwgt; cmap = graph->cmap; match = idxset(nvtxs, UNMATCHED, idxwspacemalloc(ctrl, nvtxs)); perm = idxwspacemalloc(ctrl, nvtxs); tperm = idxwspacemalloc(ctrl, nvtxs); degrees = idxwspacemalloc(ctrl, nvtxs); RandomPermute(nvtxs, tperm, 1); avgdegree = 0.7*(xadj[nvtxs]/nvtxs); for (i=0; i avgdegree ? avgdegree : xadj[i+1]-xadj[i]); BucketSortKeysInc(nvtxs, avgdegree, degrees, tperm, perm); cnvtxs = 0; /* Take care any islands. Islands are matched with non-islands due to coarsening */ for (ii=0; iiii; j--) { k = perm[j]; if (match[k] == UNMATCHED && xadj[k] < xadj[k+1]) { maxidx = k; break; } } cmap[i] = cmap[maxidx] = cnvtxs++; match[i] = maxidx; match[maxidx] = i; } } /* Continue with normal matching */ for (; iinmaxvwgt)) { if (maxidx != i) vbal = BetterVBalance(ncon, norm, nvwgt+i*ncon, nvwgt+maxidx*ncon, nvwgt+k*ncon); if (vbal > 0 || (vbal > -.01 && maxwgt < adjwgt[j])) { maxwgt = adjwgt[j]; maxidx = k; } } } cmap[i] = cmap[maxidx] = cnvtxs++; match[i] = maxidx; match[maxidx] = i; } } IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->MatchTmr)); idxwspacefree(ctrl, nvtxs); /* degrees */ idxwspacefree(ctrl, nvtxs); /* tperm */ CreateCoarseGraph(ctrl, graph, cnvtxs, match, perm); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); } /************************************************************************* * This function checks if v+u2 provides a better balance in the weight * vector that v+u1 **************************************************************************/ float BetterVBalance(idxtype ncon, idxtype norm, float *vwgt, float *u1wgt, float *u2wgt) { idxtype i; float sum1, sum2, max1, max2, min1, min2, diff1, diff2; if (norm == -1) { max1 = min1 = vwgt[0]+u1wgt[0]; max2 = min2 = vwgt[0]+u2wgt[0]; sum1 = vwgt[0]+u1wgt[0]; sum2 = vwgt[0]+u2wgt[0]; for (i=1; i vwgt[i]+u1wgt[i]) min1 = vwgt[i]+u1wgt[i]; if (max2 < vwgt[i]+u2wgt[i]) max2 = vwgt[i]+u2wgt[i]; if (min2 > vwgt[i]+u2wgt[i]) min2 = vwgt[i]+u2wgt[i]; sum1 += vwgt[i]+u1wgt[i]; sum2 += vwgt[i]+u2wgt[i]; } if (sum1 == 0.0) return 1; else if (sum2 == 0.0) return -1; else return ((max1-min1)/sum1) - ((max2-min2)/sum2); } else if (norm == 1) { sum1 = sum2 = 0.0; for (i=0; i limit) return 0; return 1; } PyMetis-0.90/src/metis/mmd.c0000640000175000017500000005146210662171744015515 0ustar andreasandreas/* * mmd.c * * ************************************************************** * The following C function was developed from a FORTRAN subroutine * in SPARSPAK written by Eleanor Chu, Alan George, Joseph Liu * and Esmond Ng. * * The FORTRAN-to-C transformation and modifications such as dynamic * memory allocation and deallocation were performed by Chunguang * Sun. * ************************************************************** * * Taken from SMMS, George 12/13/94 * * The meaning of invperm, and perm vectors is different from that * in genqmd_ of SparsPak * * $Id: mmd.c,v 1.2 2002/08/10 06:29:33 karypis Exp $ */ #include /************************************************************************* * genmmd -- multiple minimum external degree * purpose -- this routine implements the minimum degree * algorithm. it makes use of the implicit representation * of elimination graphs by quotient graphs, and the notion * of indistinguishable nodes. It also implements the modifications * by multiple elimination and minimum external degree. * Caution -- the adjacency vector adjncy will be destroyed. * Input parameters -- * neqns -- number of equations. * (xadj, adjncy) -- the adjacency structure. * delta -- tolerance value for multiple elimination. * maxint -- maximum machine representable (short) integer * (any smaller estimate will do) for marking nodes. * Output parameters -- * perm -- the minimum degree ordering. * invp -- the inverse of perm. * *ncsub -- an upper bound on the number of nonzero subscripts * for the compressed storage scheme. * Working parameters -- * head -- vector for head of degree lists. * invp -- used temporarily for degree forward link. * perm -- used temporarily for degree backward link. * qsize -- vector for size of supernodes. * list -- vector for temporary linked lists. * marker -- a temporary marker vector. * Subroutines used -- mmdelm, mmdint, mmdnum, mmdupd. **************************************************************************/ void genmmd(idxtype neqns, idxtype *xadj, idxtype *adjncy, idxtype *invp, idxtype *perm, idxtype delta, idxtype *head, idxtype *qsize, idxtype *list, idxtype *marker, idxtype maxint, idxtype *ncsub) { idxtype ehead, i, mdeg, mdlmt, mdeg_node, nextmd, num, tag; if (neqns <= 0) return; /* Adjust from C to Fortran */ xadj--; adjncy--; invp--; perm--; head--; qsize--; list--; marker--; /* initialization for the minimum degree algorithm. */ *ncsub = 0; mmdint(neqns, xadj, adjncy, head, invp, perm, qsize, list, marker); /* 'num' counts the number of ordered nodes plus 1. */ num = 1; /* eliminate all isolated nodes. */ nextmd = head[1]; while (nextmd > 0) { mdeg_node = nextmd; nextmd = invp[mdeg_node]; marker[mdeg_node] = maxint; invp[mdeg_node] = -num; num = num + 1; } /* search for node of the minimum degree. 'mdeg' is the current */ /* minimum degree; 'tag' is used to facilitate marking nodes. */ if (num > neqns) goto n1000; tag = 1; head[1] = 0; mdeg = 2; /* infinite loop here ! */ while (1) { while (head[mdeg] <= 0) mdeg++; /* use value of 'delta' to set up 'mdlmt', which governs */ /* when a degree update is to be performed. */ mdlmt = mdeg + delta; ehead = 0; n500: mdeg_node = head[mdeg]; while (mdeg_node <= 0) { mdeg++; if (mdeg > mdlmt) goto n900; mdeg_node = head[mdeg]; }; /* remove 'mdeg_node' from the degree structure. */ nextmd = invp[mdeg_node]; head[mdeg] = nextmd; if (nextmd > 0) perm[nextmd] = -mdeg; invp[mdeg_node] = -num; *ncsub += mdeg + qsize[mdeg_node] - 2; if ((num+qsize[mdeg_node]) > neqns) goto n1000; /* eliminate 'mdeg_node' and perform quotient graph */ /* transformation. reset 'tag' value if necessary. */ tag++; if (tag >= maxint) { tag = 1; for (i = 1; i <= neqns; i++) if (marker[i] < maxint) marker[i] = 0; }; mmdelm(mdeg_node, xadj, adjncy, head, invp, perm, qsize, list, marker, maxint, tag); num += qsize[mdeg_node]; list[mdeg_node] = ehead; ehead = mdeg_node; if (delta >= 0) goto n500; n900: /* update degrees of the nodes involved in the */ /* minimum degree nodes elimination. */ if (num > neqns) goto n1000; mmdupd( ehead, neqns, xadj, adjncy, delta, &mdeg, head, invp, perm, qsize, list, marker, maxint, &tag); }; /* end of -- while ( 1 ) -- */ n1000: mmdnum( neqns, perm, invp, qsize ); /* Adjust from Fortran back to C*/ xadj++; adjncy++; invp++; perm++; head++; qsize++; list++; marker++; } /************************************************************************** * mmdelm ...... multiple minimum degree elimination * Purpose -- This routine eliminates the node mdeg_node of minimum degree * from the adjacency structure, which is stored in the quotient * graph format. It also transforms the quotient graph representation * of the elimination graph. * Input parameters -- * mdeg_node -- node of minimum degree. * maxint -- estimate of maximum representable (short) integer. * tag -- tag value. * Updated parameters -- * (xadj, adjncy) -- updated adjacency structure. * (head, forward, backward) -- degree doubly linked structure. * qsize -- size of supernode. * marker -- marker vector. * list -- temporary linked list of eliminated nabors. ***************************************************************************/ void mmdelm(idxtype mdeg_node, idxtype *xadj, idxtype *adjncy, idxtype *head, idxtype *forward, idxtype *backward, idxtype *qsize, idxtype *list, idxtype *marker, idxtype maxint, idxtype tag) { idxtype element, i, istop, istart, j, jstop, jstart, link, nabor, node, npv, nqnbrs, nxnode, pvnode, rlmt, rloc, rnode, xqnbr; /* find the reachable set of 'mdeg_node' and */ /* place it in the data structure. */ marker[mdeg_node] = tag; istart = xadj[mdeg_node]; istop = xadj[mdeg_node+1] - 1; /* 'element' points to the beginning of the list of */ /* eliminated nabors of 'mdeg_node', and 'rloc' gives the */ /* storage location for the next reachable node. */ element = 0; rloc = istart; rlmt = istop; for ( i = istart; i <= istop; i++ ) { nabor = adjncy[i]; if ( nabor == 0 ) break; if ( marker[nabor] < tag ) { marker[nabor] = tag; if ( forward[nabor] < 0 ) { list[nabor] = element; element = nabor; } else { adjncy[rloc] = nabor; rloc++; }; }; /* end of -- if -- */ }; /* end of -- for -- */ /* merge with reachable nodes from generalized elements. */ while ( element > 0 ) { adjncy[rlmt] = -element; link = element; n400: jstart = xadj[link]; jstop = xadj[link+1] - 1; for ( j = jstart; j <= jstop; j++ ) { node = adjncy[j]; link = -node; if ( node < 0 ) goto n400; if ( node == 0 ) break; if ((marker[node]=0)) { marker[node] = tag; /*use storage from eliminated nodes if necessary.*/ while ( rloc >= rlmt ) { link = -adjncy[rlmt]; rloc = xadj[link]; rlmt = xadj[link+1] - 1; }; adjncy[rloc] = node; rloc++; }; }; /* end of -- for ( j = jstart; -- */ element = list[element]; }; /* end of -- while ( element > 0 ) -- */ if ( rloc <= rlmt ) adjncy[rloc] = 0; /* for each node in the reachable set, do the following. */ link = mdeg_node; n1100: istart = xadj[link]; istop = xadj[link+1] - 1; for ( i = istart; i <= istop; i++ ) { rnode = adjncy[i]; link = -rnode; if ( rnode < 0 ) goto n1100; if ( rnode == 0 ) return; /* 'rnode' is in the degree list structure. */ pvnode = backward[rnode]; if (( pvnode != 0 ) && ( pvnode != (-maxint) )) { /* then remove 'rnode' from the structure. */ nxnode = forward[rnode]; if ( nxnode > 0 ) backward[nxnode] = pvnode; if ( pvnode > 0 ) forward[pvnode] = nxnode; npv = -pvnode; if ( pvnode < 0 ) head[npv] = nxnode; }; /* purge inactive quotient nabors of 'rnode'. */ jstart = xadj[rnode]; jstop = xadj[rnode+1] - 1; xqnbr = jstart; for ( j = jstart; j <= jstop; j++ ) { nabor = adjncy[j]; if ( nabor == 0 ) break; if ( marker[nabor] < tag ) { adjncy[xqnbr] = nabor; xqnbr++; }; }; /* no active nabor after the purging. */ nqnbrs = xqnbr - jstart; if ( nqnbrs <= 0 ) { /* merge 'rnode' with 'mdeg_node'. */ qsize[mdeg_node] += qsize[rnode]; qsize[rnode] = 0; marker[rnode] = maxint; forward[rnode] = -mdeg_node; backward[rnode] = -maxint; } else { /* flag 'rnode' for degree update, and */ /* add 'mdeg_node' as a nabor of 'rnode'. */ forward[rnode] = nqnbrs + 1; backward[rnode] = 0; adjncy[xqnbr] = mdeg_node; xqnbr++; if ( xqnbr <= jstop ) adjncy[xqnbr] = 0; }; }; /* end of -- for ( i = istart; -- */ return; } /*************************************************************************** * mmdint ---- mult minimum degree initialization * purpose -- this routine performs initialization for the * multiple elimination version of the minimum degree algorithm. * input parameters -- * neqns -- number of equations. * (xadj, adjncy) -- adjacency structure. * output parameters -- * (head, dfrow, backward) -- degree doubly linked structure. * qsize -- size of supernode ( initialized to one). * list -- linked list. * marker -- marker vector. ****************************************************************************/ idxtype mmdint(idxtype neqns, idxtype *xadj, idxtype *adjncy, idxtype *head, idxtype *forward, idxtype *backward, idxtype *qsize, idxtype *list, idxtype *marker) { idxtype fnode, ndeg, node; for ( node = 1; node <= neqns; node++ ) { head[node] = 0; qsize[node] = 1; marker[node] = 0; list[node] = 0; }; /* initialize the degree doubly linked lists. */ for ( node = 1; node <= neqns; node++ ) { ndeg = xadj[node+1] - xadj[node]/* + 1*/; /* george */ if (ndeg == 0) ndeg = 1; fnode = head[ndeg]; forward[node] = fnode; head[ndeg] = node; if ( fnode > 0 ) backward[fnode] = node; backward[node] = -ndeg; }; return 0; } /**************************************************************************** * mmdnum --- multi minimum degree numbering * purpose -- this routine performs the final step in producing * the permutation and inverse permutation vectors in the * multiple elimination version of the minimum degree * ordering algorithm. * input parameters -- * neqns -- number of equations. * qsize -- size of supernodes at elimination. * updated parameters -- * invp -- inverse permutation vector. on input, * if qsize[node] = 0, then node has been merged * into the node -invp[node]; otherwise, * -invp[node] is its inverse labelling. * output parameters -- * perm -- the permutation vector. ****************************************************************************/ void mmdnum(idxtype neqns, idxtype *perm, idxtype *invp, idxtype *qsize) { idxtype father, nextf, node, nqsize, num, root; for ( node = 1; node <= neqns; node++ ) { nqsize = qsize[node]; if ( nqsize <= 0 ) perm[node] = invp[node]; if ( nqsize > 0 ) perm[node] = -invp[node]; }; /* for each node which has been merged, do the following. */ for ( node = 1; node <= neqns; node++ ) { if ( perm[node] <= 0 ) { /* trace the merged tree until one which has not */ /* been merged, call it root. */ father = node; while ( perm[father] <= 0 ) father = - perm[father]; /* number node after root. */ root = father; num = perm[root] + 1; invp[node] = -num; perm[root] = num; /* shorten the merged tree. */ father = node; nextf = - perm[father]; while ( nextf > 0 ) { perm[father] = -root; father = nextf; nextf = -perm[father]; }; }; /* end of -- if ( perm[node] <= 0 ) -- */ }; /* end of -- for ( node = 1; -- */ /* ready to compute perm. */ for ( node = 1; node <= neqns; node++ ) { num = -invp[node]; invp[node] = num; perm[num] = node; }; return; } /**************************************************************************** * mmdupd ---- multiple minimum degree update * purpose -- this routine updates the degrees of nodes after a * multiple elimination step. * input parameters -- * ehead -- the beginning of the list of eliminated nodes * (i.e., newly formed elements). * neqns -- number of equations. * (xadj, adjncy) -- adjacency structure. * delta -- tolerance value for multiple elimination. * maxint -- maximum machine representable (short) integer. * updated parameters -- * mdeg -- new minimum degree after degree update. * (head, forward, backward) -- degree doubly linked structure. * qsize -- size of supernode. * list -- marker vector for degree update. * *tag -- tag value. ****************************************************************************/ void mmdupd(idxtype ehead, idxtype neqns, idxtype *xadj, idxtype *adjncy, idxtype delta, idxtype *mdeg, idxtype *head, idxtype *forward, idxtype *backward, idxtype *qsize, idxtype *list, idxtype *marker, idxtype maxint, idxtype *tag) { idxtype deg, deg0, element, enode, fnode, i, iq2, istop, istart, j, jstop, jstart, link, mdeg0, mtag, nabor, node, q2head, qxhead; mdeg0 = *mdeg + delta; element = ehead; n100: if ( element <= 0 ) return; /* for each of the newly formed element, do the following. */ /* reset tag value if necessary. */ mtag = *tag + mdeg0; if ( mtag >= maxint ) { *tag = 1; for ( i = 1; i <= neqns; i++ ) if ( marker[i] < maxint ) marker[i] = 0; mtag = *tag + mdeg0; }; /* create two linked lists from nodes associated with 'element': */ /* one with two nabors (q2head) in the adjacency structure, and the*/ /* other with more than two nabors (qxhead). also compute 'deg0',*/ /* number of nodes in this element. */ q2head = 0; qxhead = 0; deg0 = 0; link =element; n400: istart = xadj[link]; istop = xadj[link+1] - 1; for ( i = istart; i <= istop; i++ ) { enode = adjncy[i]; link = -enode; if ( enode < 0 ) goto n400; if ( enode == 0 ) break; if ( qsize[enode] != 0 ) { deg0 += qsize[enode]; marker[enode] = mtag; /*'enode' requires a degree update*/ if ( backward[enode] == 0 ) { /* place either in qxhead or q2head list. */ if ( forward[enode] != 2 ) { list[enode] = qxhead; qxhead = enode; } else { list[enode] = q2head; q2head = enode; }; }; }; /* enf of -- if ( qsize[enode] != 0 ) -- */ }; /* end of -- for ( i = istart; -- */ /* for each node in q2 list, do the following. */ enode = q2head; iq2 = 1; n900: if ( enode <= 0 ) goto n1500; if ( backward[enode] != 0 ) goto n2200; (*tag)++; deg = deg0; /* identify the other adjacent element nabor. */ istart = xadj[enode]; nabor = adjncy[istart]; if ( nabor == element ) nabor = adjncy[istart+1]; link = nabor; if ( forward[nabor] >= 0 ) { /* nabor is uneliminated, increase degree count. */ deg += qsize[nabor]; goto n2100; }; /* the nabor is eliminated. for each node in the 2nd element */ /* do the following. */ n1000: istart = xadj[link]; istop = xadj[link+1] - 1; for ( i = istart; i <= istop; i++ ) { node = adjncy[i]; link = -node; if ( node != enode ) { if ( node < 0 ) goto n1000; if ( node == 0 ) goto n2100; if ( qsize[node] != 0 ) { if ( marker[node] < *tag ) { /* 'node' is not yet considered. */ marker[node] = *tag; deg += qsize[node]; } else { if ( backward[node] == 0 ) { if ( forward[node] == 2 ) { /* 'node' is indistinguishable from 'enode'.*/ /* merge them into a new supernode. */ qsize[enode] += qsize[node]; qsize[node] = 0; marker[node] = maxint; forward[node] = -enode; backward[node] = -maxint; } else { /* 'node' is outmacthed by 'enode' */ if (backward[node]==0) backward[node] = -maxint; }; }; /* end of -- if ( backward[node] == 0 ) -- */ }; /* end of -- if ( marker[node] < *tag ) -- */ }; /* end of -- if ( qsize[node] != 0 ) -- */ }; /* end of -- if ( node != enode ) -- */ }; /* end of -- for ( i = istart; -- */ goto n2100; n1500: /* for each 'enode' in the 'qx' list, do the following. */ enode = qxhead; iq2 = 0; n1600: if ( enode <= 0 ) goto n2300; if ( backward[enode] != 0 ) goto n2200; (*tag)++; deg = deg0; /*for each unmarked nabor of 'enode', do the following.*/ istart = xadj[enode]; istop = xadj[enode+1] - 1; for ( i = istart; i <= istop; i++ ) { nabor = adjncy[i]; if ( nabor == 0 ) break; if ( marker[nabor] < *tag ) { marker[nabor] = *tag; link = nabor; if ( forward[nabor] >= 0 ) /*if uneliminated, include it in deg count.*/ deg += qsize[nabor]; else { n1700: /* if eliminated, include unmarked nodes in this*/ /* element into the degree count. */ jstart = xadj[link]; jstop = xadj[link+1] - 1; for ( j = jstart; j <= jstop; j++ ) { node = adjncy[j]; link = -node; if ( node < 0 ) goto n1700; if ( node == 0 ) break; if ( marker[node] < *tag ) { marker[node] = *tag; deg += qsize[node]; }; }; /* end of -- for ( j = jstart; -- */ }; /* end of -- if ( forward[nabor] >= 0 ) -- */ }; /* end of -- if ( marker[nabor] < *tag ) -- */ }; /* end of -- for ( i = istart; -- */ n2100: /* update external degree of 'enode' in degree structure, */ /* and '*mdeg' if necessary. */ deg = deg - qsize[enode] + 1; fnode = head[deg]; forward[enode] = fnode; backward[enode] = -deg; if ( fnode > 0 ) backward[fnode] = enode; head[deg] = enode; if ( deg < *mdeg ) *mdeg = deg; n2200: /* get next enode in current element. */ enode = list[enode]; if ( iq2 == 1 ) goto n900; goto n1600; n2300: /* get next element in the list. */ *tag = mtag; element = list[element]; goto n100; } PyMetis-0.90/src/metis/mpmetis.c0000640000175000017500000002665410662171744016423 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * mpmetis.c * * This file contains the top level routines for the multilevel recursive * bisection algorithm PMETIS. * * Started 7/24/97 * George * * $Id: mpmetis.c,v 1.2 2002/08/10 06:29:33 karypis Exp $ * */ #include /************************************************************************* * This function is the entry point for PWMETIS that accepts exact weights * for the target partitions **************************************************************************/ void METIS_mCPartGraphRecursive(idxtype *nvtxs, idxtype *ncon, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, idxtype *options, idxtype *edgecut, idxtype *part) { idxtype i, j; GraphType graph; CtrlType ctrl; if (*numflag == 1) Change2CNumbering(*nvtxs, xadj, adjncy); SetUpGraph(&graph, OP_PMETIS, *nvtxs, *ncon, xadj, adjncy, vwgt, adjwgt, *wgtflag); if (options[0] == 0) { /* Use the default parameters */ ctrl.CType = McPMETIS_CTYPE; ctrl.IType = McPMETIS_ITYPE; ctrl.RType = McPMETIS_RTYPE; ctrl.dbglvl = McPMETIS_DBGLVL; } else { ctrl.CType = options[OPTION_CTYPE]; ctrl.IType = options[OPTION_ITYPE]; ctrl.RType = options[OPTION_RTYPE]; ctrl.dbglvl = options[OPTION_DBGLVL]; } ctrl.optype = OP_PMETIS; ctrl.CoarsenTo = 100; ctrl.nmaxvwgt = 1.5/(1.0*ctrl.CoarsenTo); InitRandom(-1); AllocateWorkSpace(&ctrl, &graph, *nparts); IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl)); IFSET(ctrl.dbglvl, DBG_TIME, gk_startcputimer(ctrl.TotalTmr)); *edgecut = MCMlevelRecursiveBisection(&ctrl, &graph, *nparts, part, 1.000, 0); IFSET(ctrl.dbglvl, DBG_TIME, gk_stopcputimer(ctrl.TotalTmr)); IFSET(ctrl.dbglvl, DBG_TIME, PrintTimers(&ctrl)); FreeWorkSpace(&ctrl, &graph); if (*numflag == 1) Change2FNumbering(*nvtxs, xadj, adjncy, part); } /************************************************************************* * This function is the entry point for PWMETIS that accepts exact weights * for the target partitions **************************************************************************/ void METIS_mCHPartGraphRecursive(idxtype *nvtxs, idxtype *ncon, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *ubvec, idxtype *options, idxtype *edgecut, idxtype *part) { idxtype i, j; GraphType graph; CtrlType ctrl; float *myubvec; if (*numflag == 1) Change2CNumbering(*nvtxs, xadj, adjncy); SetUpGraph(&graph, OP_PMETIS, *nvtxs, *ncon, xadj, adjncy, vwgt, adjwgt, *wgtflag); if (options[0] == 0) { /* Use the default parameters */ ctrl.CType = PMETIS_CTYPE; ctrl.IType = PMETIS_ITYPE; ctrl.RType = PMETIS_RTYPE; ctrl.dbglvl = PMETIS_DBGLVL; } else { ctrl.CType = options[OPTION_CTYPE]; ctrl.IType = options[OPTION_ITYPE]; ctrl.RType = options[OPTION_RTYPE]; ctrl.dbglvl = options[OPTION_DBGLVL]; } ctrl.optype = OP_PMETIS; ctrl.CoarsenTo = 100; ctrl.nmaxvwgt = 1.5/(1.0*ctrl.CoarsenTo); myubvec = gk_fmalloc(*ncon, "PWMETIS: mytpwgts"); gk_fcopy(*ncon, ubvec, myubvec); InitRandom(-1); AllocateWorkSpace(&ctrl, &graph, *nparts); IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl)); IFSET(ctrl.dbglvl, DBG_TIME, gk_startcputimer(ctrl.TotalTmr)); *edgecut = MCHMlevelRecursiveBisection(&ctrl, &graph, *nparts, part, myubvec, 0); IFSET(ctrl.dbglvl, DBG_TIME, gk_stopcputimer(ctrl.TotalTmr)); IFSET(ctrl.dbglvl, DBG_TIME, PrintTimers(&ctrl)); FreeWorkSpace(&ctrl, &graph); gk_free((void **)&myubvec, LTERM); if (*numflag == 1) Change2FNumbering(*nvtxs, xadj, adjncy, part); } /************************************************************************* * This function is the entry point for PWMETIS that accepts exact weights * for the target partitions **************************************************************************/ void METIS_mCPartGraphRecursiveInternal(idxtype *nvtxs, idxtype *ncon, idxtype *xadj, idxtype *adjncy, float *nvwgt, idxtype *adjwgt, idxtype *nparts, idxtype *options, idxtype *edgecut, idxtype *part) { idxtype i, j; GraphType graph; CtrlType ctrl; SetUpGraph2(&graph, *nvtxs, *ncon, xadj, adjncy, nvwgt, adjwgt); if (options[0] == 0) { /* Use the default parameters */ ctrl.CType = PMETIS_CTYPE; ctrl.IType = PMETIS_ITYPE; ctrl.RType = PMETIS_RTYPE; ctrl.dbglvl = PMETIS_DBGLVL; } else { ctrl.CType = options[OPTION_CTYPE]; ctrl.IType = options[OPTION_ITYPE]; ctrl.RType = options[OPTION_RTYPE]; ctrl.dbglvl = options[OPTION_DBGLVL]; } ctrl.optype = OP_PMETIS; ctrl.CoarsenTo = 100; ctrl.nmaxvwgt = 1.5/(1.0*ctrl.CoarsenTo); InitRandom(-1); AllocateWorkSpace(&ctrl, &graph, *nparts); IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl)); IFSET(ctrl.dbglvl, DBG_TIME, gk_startcputimer(ctrl.TotalTmr)); *edgecut = MCMlevelRecursiveBisection(&ctrl, &graph, *nparts, part, 1.000, 0); IFSET(ctrl.dbglvl, DBG_TIME, gk_stopcputimer(ctrl.TotalTmr)); IFSET(ctrl.dbglvl, DBG_TIME, PrintTimers(&ctrl)); FreeWorkSpace(&ctrl, &graph); } /************************************************************************* * This function is the entry point for PWMETIS that accepts exact weights * for the target partitions **************************************************************************/ void METIS_mCHPartGraphRecursiveInternal(idxtype *nvtxs, idxtype *ncon, idxtype *xadj, idxtype *adjncy, float *nvwgt, idxtype *adjwgt, idxtype *nparts, float *ubvec, idxtype *options, idxtype *edgecut, idxtype *part) { idxtype i, j; GraphType graph; CtrlType ctrl; float *myubvec; SetUpGraph2(&graph, *nvtxs, *ncon, xadj, adjncy, nvwgt, adjwgt); if (options[0] == 0) { /* Use the default parameters */ ctrl.CType = PMETIS_CTYPE; ctrl.IType = PMETIS_ITYPE; ctrl.RType = PMETIS_RTYPE; ctrl.dbglvl = PMETIS_DBGLVL; } else { ctrl.CType = options[OPTION_CTYPE]; ctrl.IType = options[OPTION_ITYPE]; ctrl.RType = options[OPTION_RTYPE]; ctrl.dbglvl = options[OPTION_DBGLVL]; } ctrl.optype = OP_PMETIS; ctrl.CoarsenTo = 100; ctrl.nmaxvwgt = 1.5/(1.0*ctrl.CoarsenTo); myubvec = gk_fmalloc(*ncon, "PWMETIS: mytpwgts"); gk_fcopy(*ncon, ubvec, myubvec); InitRandom(-1); AllocateWorkSpace(&ctrl, &graph, *nparts); IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl)); IFSET(ctrl.dbglvl, DBG_TIME, gk_startcputimer(ctrl.TotalTmr)); *edgecut = MCHMlevelRecursiveBisection(&ctrl, &graph, *nparts, part, myubvec, 0); IFSET(ctrl.dbglvl, DBG_TIME, gk_stopcputimer(ctrl.TotalTmr)); IFSET(ctrl.dbglvl, DBG_TIME, PrintTimers(&ctrl)); FreeWorkSpace(&ctrl, &graph); gk_free((void **)&myubvec, LTERM); } /************************************************************************* * This function takes a graph and produces a bisection of it **************************************************************************/ idxtype MCMlevelRecursiveBisection(CtrlType *ctrl, GraphType *graph, idxtype nparts, idxtype *part, float ubfactor, idxtype fpart) { idxtype i, j, nvtxs, ncon, cut; idxtype *label, *where; GraphType lgraph, rgraph; float tpwgts[2]; nvtxs = graph->nvtxs; if (nvtxs == 0) { mprintf("\t***Cannot bisect a graph with 0 vertices!\n\t***You are trying to partition a graph into too many parts!\n"); return 0; } /* Determine the weights of the partitions */ tpwgts[0] = 1.0*(nparts>>1)/(1.0*nparts); tpwgts[1] = 1.0 - tpwgts[0]; MCMlevelEdgeBisection(ctrl, graph, tpwgts, ubfactor); cut = graph->mincut; label = graph->label; where = graph->where; for (i=0; i 2) SplitGraphPart(ctrl, graph, &lgraph, &rgraph); /* Free the memory of the top level graph */ FreeGraph(graph, 0); /* Do the recursive call */ if (nparts > 3) { cut += MCMlevelRecursiveBisection(ctrl, &lgraph, nparts/2, part, ubfactor, fpart); cut += MCMlevelRecursiveBisection(ctrl, &rgraph, nparts-nparts/2, part, ubfactor, fpart+nparts/2); } else if (nparts == 3) { cut += MCMlevelRecursiveBisection(ctrl, &rgraph, nparts-nparts/2, part, ubfactor, fpart+nparts/2); FreeGraph(&lgraph, 0); } return cut; } /************************************************************************* * This function takes a graph and produces a bisection of it **************************************************************************/ idxtype MCHMlevelRecursiveBisection(CtrlType *ctrl, GraphType *graph, idxtype nparts, idxtype *part, float *ubvec, idxtype fpart) { idxtype i, j, nvtxs, ncon, cut; idxtype *label, *where; GraphType lgraph, rgraph; float tpwgts[2], *npwgts, *lubvec, *rubvec; lubvec = rubvec = NULL; nvtxs = graph->nvtxs; ncon = graph->ncon; if (nvtxs == 0) { mprintf("\t***Cannot bisect a graph with 0 vertices!\n\t***You are trying to partition a graph into too many parts!\n"); return 0; } /* Determine the weights of the partitions */ tpwgts[0] = 1.0*(nparts>>1)/(1.0*nparts); tpwgts[1] = 1.0 - tpwgts[0]; /* For now, relax at the coarsest level only */ if (nparts == 2) MCHMlevelEdgeBisection(ctrl, graph, tpwgts, ubvec); else MCMlevelEdgeBisection(ctrl, graph, tpwgts, 1.000); cut = graph->mincut; label = graph->label; where = graph->where; for (i=0; i 2) { /* Adjust the ubvecs before the split */ npwgts = graph->npwgts; lubvec = gk_fmalloc(ncon, "MCHMlevelRecursiveBisection"); rubvec = gk_fmalloc(ncon, "MCHMlevelRecursiveBisection"); for (i=0; i 3) { cut += MCHMlevelRecursiveBisection(ctrl, &lgraph, nparts/2, part, lubvec, fpart); cut += MCHMlevelRecursiveBisection(ctrl, &rgraph, nparts-nparts/2, part, rubvec, fpart+nparts/2); } else if (nparts == 3) { cut += MCHMlevelRecursiveBisection(ctrl, &rgraph, nparts-nparts/2, part, rubvec, fpart+nparts/2); FreeGraph(&lgraph, 0); } gk_free((void **)&lubvec, &rubvec, LTERM); return cut; } /************************************************************************* * This function performs multilevel bisection **************************************************************************/ void MCMlevelEdgeBisection(CtrlType *ctrl, GraphType *graph, float *tpwgts, float ubfactor) { GraphType *cgraph; cgraph = MCCoarsen2Way(ctrl, graph); MocInit2WayPartition(ctrl, cgraph, tpwgts, ubfactor); MocRefine2Way(ctrl, graph, cgraph, tpwgts, ubfactor); } /************************************************************************* * This function performs multilevel bisection **************************************************************************/ void MCHMlevelEdgeBisection(CtrlType *ctrl, GraphType *graph, float *tpwgts, float *ubvec) { idxtype i; GraphType *cgraph; /* for (i=0; incon; i++) mprintf("%.4f ", ubvec[i]); mprintf("\n"); */ cgraph = MCCoarsen2Way(ctrl, graph); MocInit2WayPartition2(ctrl, cgraph, tpwgts, ubvec); MocRefine2Way2(ctrl, graph, cgraph, tpwgts, ubvec); } PyMetis-0.90/src/metis/mrefine.c0000640000175000017500000001366210662171744016365 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * refine.c * * This file contains the driving routines for multilevel refinement * * Started 7/24/97 * George * * $Id: mrefine.c,v 1.2 2002/08/10 06:29:33 karypis Exp $ */ #include /************************************************************************* * This function is the entry point of refinement **************************************************************************/ void MocRefine2Way(CtrlType *ctrl, GraphType *orggraph, GraphType *graph, float *tpwgts, float ubfactor) { idxtype i; float tubvec[MAXNCON]; for (i=0; incon; i++) tubvec[i] = 1.0; IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->UncoarsenTmr)); /* Compute the parameters of the coarsest graph */ MocCompute2WayPartitionParams(ctrl, graph); for (;;) { ASSERT(CheckBnd(graph)); IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->RefTmr)); switch (ctrl->RType) { case RTYPE_FM: MocBalance2Way(ctrl, graph, tpwgts, 1.03); MocFM_2WayEdgeRefine(ctrl, graph, tpwgts, 8); break; case 2: MocBalance2Way(ctrl, graph, tpwgts, 1.03); MocFM_2WayEdgeRefine2(ctrl, graph, tpwgts, tubvec, 8); break; default: errexit("Unknown refinement type: %d\n", ctrl->RType); } IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->RefTmr)); if (graph == orggraph) break; graph = graph->finer; IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->ProjectTmr)); MocProject2WayPartition(ctrl, graph); IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->ProjectTmr)); } MocBalance2Way(ctrl, graph, tpwgts, 1.01); MocFM_2WayEdgeRefine(ctrl, graph, tpwgts, 8); IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->UncoarsenTmr)); } /************************************************************************* * This function allocates memory for 2-way edge refinement **************************************************************************/ void MocAllocate2WayPartitionMemory(CtrlType *ctrl, GraphType *graph) { idxtype nvtxs, ncon; nvtxs = graph->nvtxs; ncon = graph->ncon; graph->npwgts = gk_fmalloc(2*ncon, "MocAllocate2WayPartitionMemory: npwgts"); graph->where = idxmalloc(nvtxs, "MocAllocate2WayPartitionMemory: where"); graph->id = idxmalloc(nvtxs, "MocAllocate2WayPartitionMemory: id"); graph->ed = idxmalloc(nvtxs, "MocAllocate2WayPartitionMemory: ed"); graph->bndptr = idxmalloc(nvtxs, "MocAllocate2WayPartitionMemory: bndptr"); graph->bndind = idxmalloc(nvtxs, "MocAllocate2WayPartitionMemory: bndind"); } /************************************************************************* * This function computes the initial id/ed **************************************************************************/ void MocCompute2WayPartitionParams(CtrlType *ctrl, GraphType *graph) { idxtype i, j, k, l, nvtxs, ncon, nbnd, mincut; idxtype *xadj, *adjncy, *adjwgt; float *nvwgt, *npwgts; idxtype *id, *ed, *where; idxtype *bndptr, *bndind; idxtype me, other; nvtxs = graph->nvtxs; ncon = graph->ncon; xadj = graph->xadj; nvwgt = graph->nvwgt; adjncy = graph->adjncy; adjwgt = graph->adjwgt; where = graph->where; npwgts = gk_fset(2*ncon, 0.0, graph->npwgts); id = idxset(nvtxs, 0, graph->id); ed = idxset(nvtxs, 0, graph->ed); bndptr = idxset(nvtxs, -1, graph->bndptr); bndind = graph->bndind; /*------------------------------------------------------------ / Compute now the id/ed degrees /------------------------------------------------------------*/ nbnd = mincut = 0; for (i=0; i= 0 && where[i] <= 1); me = where[i]; gk_faxpy(ncon, 1.0, nvwgt+i*ncon, 1, npwgts+me*ncon, 1); for (j=xadj[i]; j 0 || xadj[i] == xadj[i+1]) { mincut += ed[i]; bndptr[i] = nbnd; bndind[nbnd++] = i; } } graph->mincut = mincut/2; graph->nbnd = nbnd; } /************************************************************************* * This function projects a partition, and at the same time computes the * parameters for refinement. **************************************************************************/ void MocProject2WayPartition(CtrlType *ctrl, GraphType *graph) { idxtype i, j, k, nvtxs, nbnd, me; idxtype *xadj, *adjncy, *adjwgt, *adjwgtsum; idxtype *cmap, *where, *id, *ed, *bndptr, *bndind; idxtype *cwhere, *cid, *ced, *cbndptr; GraphType *cgraph; cgraph = graph->coarser; cwhere = cgraph->where; cid = cgraph->id; ced = cgraph->ed; cbndptr = cgraph->bndptr; nvtxs = graph->nvtxs; cmap = graph->cmap; xadj = graph->xadj; adjncy = graph->adjncy; adjwgt = graph->adjwgt; adjwgtsum = graph->adjwgtsum; MocAllocate2WayPartitionMemory(ctrl, graph); where = graph->where; id = idxset(nvtxs, 0, graph->id); ed = idxset(nvtxs, 0, graph->ed); bndptr = idxset(nvtxs, -1, graph->bndptr); bndind = graph->bndind; /* Go through and project partition and compute id/ed for the nodes */ for (i=0; i 0 || xadj[i] == xadj[i+1]) { bndptr[i] = nbnd; bndind[nbnd++] = i; } } } } graph->mincut = cgraph->mincut; graph->nbnd = nbnd; gk_fcopy(2*graph->ncon, cgraph->npwgts, graph->npwgts); FreeGraph(graph->coarser, 1); graph->coarser = NULL; } PyMetis-0.90/src/metis/mrefine2.c0000640000175000017500000000277110662171744016446 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * mrefine2.c * * This file contains the driving routines for multilevel refinement * * Started 7/24/97 * George * * $Id: mrefine2.c,v 1.2 2002/08/10 06:29:33 karypis Exp $ */ #include /************************************************************************* * This function is the entry point of refinement **************************************************************************/ void MocRefine2Way2(CtrlType *ctrl, GraphType *orggraph, GraphType *graph, float *tpwgts, float *ubvec) { IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->UncoarsenTmr)); /* Compute the parameters of the coarsest graph */ MocCompute2WayPartitionParams(ctrl, graph); for (;;) { ASSERT(CheckBnd(graph)); IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->RefTmr)); switch (ctrl->RType) { case RTYPE_FM: MocBalance2Way2(ctrl, graph, tpwgts, ubvec); MocFM_2WayEdgeRefine2(ctrl, graph, tpwgts, ubvec, 8); break; default: errexit("Unknown refinement type: %d\n", ctrl->RType); } IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->RefTmr)); if (graph == orggraph) break; graph = graph->finer; IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->ProjectTmr)); MocProject2WayPartition(ctrl, graph); IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->ProjectTmr)); } IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->UncoarsenTmr)); } PyMetis-0.90/src/metis/mrkmetis.c0000640000175000017500000000570310662171744016570 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * mrkmetis.c * * This file contains the top level routines for the multilevel k-way partitioning * algorithm KMETIS. * * Started 7/28/97 * George * * $Id: mrkmetis.c,v 1.2 2003/04/04 23:25:10 karypis Exp $ * */ #include /************************************************************************* * This function is the entry point for KWMETIS **************************************************************************/ void METIS_mCRefineGraphKway(idxtype *nvtxs, idxtype *ncon, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *rubvec, idxtype *options, idxtype *edgecut, idxtype *part) { idxtype i, j; GraphType graph; CtrlType ctrl; if (*numflag == 1) Change2CNumbering(*nvtxs, xadj, adjncy); SetUpGraph(&graph, OP_KMETIS, *nvtxs, *ncon, xadj, adjncy, vwgt, adjwgt, *wgtflag); if (options[0] == 0) { /* Use the default parameters */ ctrl.CType = McKMETIS_CTYPE; ctrl.IType = McKMETIS_ITYPE; ctrl.RType = McKMETIS_RTYPE; ctrl.dbglvl = McKMETIS_DBGLVL; } else { ctrl.CType = options[OPTION_CTYPE]; ctrl.IType = options[OPTION_ITYPE]; ctrl.RType = options[OPTION_RTYPE]; ctrl.dbglvl = options[OPTION_DBGLVL]; } ctrl.optype = OP_KMETIS; ctrl.CoarsenTo = amax((*nvtxs)/(20*gk_log2(*nparts)), 30*(*nparts)); ctrl.nmaxvwgt = 0.0; /* GK-MOD: Ensure that no coarsening will take place */ InitRandom(-1); AllocateWorkSpace(&ctrl, &graph, *nparts); IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl)); IFSET(ctrl.dbglvl, DBG_TIME, gk_startcputimer(ctrl.TotalTmr)); *edgecut = MCMlevelKWayRefinement(&ctrl, &graph, *nparts, part, rubvec); IFSET(ctrl.dbglvl, DBG_TIME, gk_stopcputimer(ctrl.TotalTmr)); IFSET(ctrl.dbglvl, DBG_TIME, PrintTimers(&ctrl)); FreeWorkSpace(&ctrl, &graph); if (*numflag == 1) Change2FNumbering(*nvtxs, xadj, adjncy, part); } /************************************************************************* * This function takes a graph and produces a bisection of it **************************************************************************/ idxtype MCMlevelKWayRefinement(CtrlType *ctrl, GraphType *graph, idxtype nparts, idxtype *part, float *rubvec) { idxtype i, j, nvtxs; GraphType *cgraph; idxtype options[10], edgecut; cgraph = MCCoarsen2Way(ctrl, graph); IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->InitPartTmr)); MocAllocateKWayPartitionMemory(ctrl, cgraph, nparts); if (cgraph->nvtxs != graph->nvtxs) errexit("GK-MOD Failed: %d %d\n", cgraph->nvtxs, graph->nvtxs); for (i=0; invtxs; i++) cgraph->where[graph->cmap[i]] = part[i]; MocRefineKWayHorizontal(ctrl, graph, cgraph, nparts, rubvec); idxcopy(graph->nvtxs, graph->where, part); FreeGraph(graph, 0); return graph->mincut; } PyMetis-0.90/src/metis/mutil.c0000640000175000017500000000515310662171744016066 0ustar andreasandreas/* * mutil.c * * This file contains various utility functions for the MOC portion of the * code * * Started 2/15/98 * George * * $Id: mutil.c,v 1.2 2002/08/10 06:29:33 karypis Exp $ * */ #include /************************************************************************* * This function checks if the vertex weights of two vertices are below * a given set of values **************************************************************************/ idxtype AreAllVwgtsBelow(idxtype ncon, float alpha, float *vwgt1, float beta, float *vwgt2, float limit) { idxtype i; for (i=0; i limit) return 0; return 1; } /************************************************************************* * This function checks if the vertex weights of two vertices are below * a given set of values **************************************************************************/ idxtype AreAnyVwgtsBelow(idxtype ncon, float alpha, float *vwgt1, float beta, float *vwgt2, float limit) { idxtype i; for (i=0; i max) max = npwgts[j*ncon+i]; } if (max*nparts > lb) lb = max*nparts; } return lb; } /************************************************************************* * This function checks if the vertex weights of two vertices are below * a given set of values **************************************************************************/ idxtype AreAllBelow(idxtype ncon, float *v1, float *v2) { idxtype i; for (i=0; i v2[i]) return 0; return 1; } PyMetis-0.90/src/metis/myqsort.c0000640000175000017500000000336110662171744016451 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * myqsort.c * * This file contains a fast idxtype increasing qsort algorithm. * Addopted from TeX * * Started 10/18/96 * George * * $Id: myqsort.c,v 1.2 2002/08/10 06:29:33 karypis Exp $ */ #include /* only for type declarations */ /************************************************************************* * Entry point of idxtype increasing sort **************************************************************************/ void iidxsort(size_t n, idxtype *base) { #define idxtype_lt(a, b) ((*a) < (*b)) GKQSORT(idxtype, base, n, idxtype_lt); } /************************************************************************* * Entry point of KeyVal increasing sort, ONLY key part **************************************************************************/ void ikeysort(size_t n, KeyValueType *base) { #define keyvalue_lt(a, b) ((a)->key < (b)->key) GKQSORT(KeyValueType, base, n, keyvalue_lt); } /************************************************************************* * Entry point of KeyVal increasing sort, BOTH key and val part **************************************************************************/ void ikeyvalsort(size_t n, KeyValueType *base) { #define keyvalueboth_lt(a, b) ((a)->key < (b)->key || ((a)->key == (b)->key && (a)->val < (b)->val)) GKQSORT(KeyValueType, base, n, keyvalueboth_lt); } /************************************************************************* * Entry point of DKeyValueType increasing sort based on keys **************************************************************************/ void idkeysort(size_t n, DKeyValueType *base) { #define dkeyvalue_lt(a, b) ((a)->key < (b)->key) GKQSORT(DKeyValueType, base, n, dkeyvalue_lt); } PyMetis-0.90/src/metis/ometis.c0000640000175000017500000005420510662171744016236 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * ometis.c * * This file contains the top level routines for the multilevel recursive * bisection algorithm PMETIS. * * Started 7/24/97 * George * * $Id: ometis.c,v 1.4 2003/07/31 06:04:52 karypis Exp $ * */ #include /************************************************************************* * This function is the entry point for OEMETIS **************************************************************************/ void METIS_EdgeND(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *numflag, idxtype *options, idxtype *perm, idxtype *iperm) { idxtype i, j; GraphType graph; CtrlType ctrl; if (*numflag == 1) Change2CNumbering(*nvtxs, xadj, adjncy); SetUpGraph(&graph, OP_OEMETIS, *nvtxs, 1, xadj, adjncy, NULL, NULL, 0); if (options[0] == 0) { /* Use the default parameters */ ctrl.CType = OEMETIS_CTYPE; ctrl.IType = OEMETIS_ITYPE; ctrl.RType = OEMETIS_RTYPE; ctrl.dbglvl = OEMETIS_DBGLVL; } else { ctrl.CType = options[OPTION_CTYPE]; ctrl.IType = options[OPTION_ITYPE]; ctrl.RType = options[OPTION_RTYPE]; ctrl.dbglvl = options[OPTION_DBGLVL]; } ctrl.oflags = 0; ctrl.pfactor = -1; ctrl.nseps = 1; ctrl.optype = OP_OEMETIS; ctrl.CoarsenTo = 20; ctrl.maxvwgt = 1.5*(idxsum(*nvtxs, graph.vwgt, 1)/ctrl.CoarsenTo); InitRandom(-1); AllocateWorkSpace(&ctrl, &graph, 2); IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl)); IFSET(ctrl.dbglvl, DBG_TIME, gk_startcputimer(ctrl.TotalTmr)); MlevelNestedDissection(&ctrl, &graph, iperm, ORDER_UNBALANCE_FRACTION, *nvtxs); IFSET(ctrl.dbglvl, DBG_TIME, gk_stopcputimer(ctrl.TotalTmr)); IFSET(ctrl.dbglvl, DBG_TIME, PrintTimers(&ctrl)); for (i=0; i<*nvtxs; i++) perm[iperm[i]] = i; FreeWorkSpace(&ctrl, &graph); if (*numflag == 1) Change2FNumberingOrder(*nvtxs, xadj, adjncy, perm, iperm); } /************************************************************************* * This function is the entry point for ONCMETIS **************************************************************************/ void METIS_NodeND(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *numflag, idxtype *options, idxtype *perm, idxtype *iperm) { idxtype i, ii, j, l, wflag, nflag; GraphType graph; CtrlType ctrl; idxtype *cptr, *cind, *piperm; if (*numflag == 1) Change2CNumbering(*nvtxs, xadj, adjncy); if (options[0] == 0) { /* Use the default parameters */ ctrl.CType = ONMETIS_CTYPE; ctrl.IType = ONMETIS_ITYPE; ctrl.RType = ONMETIS_RTYPE; ctrl.dbglvl = ONMETIS_DBGLVL; ctrl.oflags = ONMETIS_OFLAGS; ctrl.pfactor = ONMETIS_PFACTOR; ctrl.nseps = ONMETIS_NSEPS; } else { ctrl.CType = options[OPTION_CTYPE]; ctrl.IType = options[OPTION_ITYPE]; ctrl.RType = options[OPTION_RTYPE]; ctrl.dbglvl = options[OPTION_DBGLVL]; ctrl.oflags = options[OPTION_OFLAGS]; ctrl.pfactor = options[OPTION_PFACTOR]; ctrl.nseps = options[OPTION_NSEPS]; } if (ctrl.nseps < 1) ctrl.nseps = 1; ctrl.optype = OP_ONMETIS; ctrl.CoarsenTo = 100; IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl)); IFSET(ctrl.dbglvl, DBG_TIME, gk_startcputimer(ctrl.TotalTmr)); InitRandom(-1); if (ctrl.pfactor > 0) { /*============================================================ * Prune the dense columns ==============================================================*/ piperm = idxmalloc(*nvtxs, "ONMETIS: piperm"); PruneGraph(&ctrl, &graph, *nvtxs, xadj, adjncy, piperm, (float)(0.1*ctrl.pfactor)); } else if (ctrl.oflags&OFLAG_COMPRESS) { /*============================================================ * Compress the graph ==============================================================*/ cptr = idxmalloc(*nvtxs+1, "ONMETIS: cptr"); cind = idxmalloc(*nvtxs, "ONMETIS: cind"); CompressGraph(&ctrl, &graph, *nvtxs, xadj, adjncy, cptr, cind); if (graph.nvtxs >= COMPRESSION_FRACTION*(*nvtxs)) { ctrl.oflags--; /* We actually performed no compression */ gk_free((void **)&cptr, &cind, LTERM); } else if (2*graph.nvtxs < *nvtxs && ctrl.nseps == 1) ctrl.nseps = 2; } else { SetUpGraph(&graph, OP_ONMETIS, *nvtxs, 1, xadj, adjncy, NULL, NULL, 0); } /*============================================================= * Do the nested dissection ordering --=============================================================*/ ctrl.maxvwgt = 1.5*(idxsum(graph.nvtxs, graph.vwgt, 1)/ctrl.CoarsenTo); AllocateWorkSpace(&ctrl, &graph, 2); if (ctrl.oflags&OFLAG_CCMP) MlevelNestedDissectionCC(&ctrl, &graph, iperm, ORDER_UNBALANCE_FRACTION, graph.nvtxs); else MlevelNestedDissection(&ctrl, &graph, iperm, ORDER_UNBALANCE_FRACTION, graph.nvtxs); FreeWorkSpace(&ctrl, &graph); if (ctrl.pfactor > 0) { /* Order any prunned vertices */ if (graph.nvtxs < *nvtxs) { idxcopy(graph.nvtxs, iperm, perm); /* Use perm as an auxiliary array */ for (i=0; invtxs; /* Determine the weights of the partitions */ tvwgt = idxsum(nvtxs, graph->vwgt, 1); tpwgts2[0] = tvwgt/2; tpwgts2[1] = tvwgt-tpwgts2[0]; switch (ctrl->optype) { case OP_OEMETIS: MlevelEdgeBisection(ctrl, graph, tpwgts2, ubfactor); IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->SepTmr)); ConstructMinCoverSeparator(ctrl, graph, ubfactor); IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->SepTmr)); break; case OP_ONMETIS: MlevelNodeBisectionMultiple(ctrl, graph, tpwgts2, ubfactor); IFSET(ctrl->dbglvl, DBG_SEPINFO, mprintf("Nvtxs: %6D, [%6D %6D %6D]\n", graph->nvtxs, graph->pwgts[0], graph->pwgts[1], graph->pwgts[2])); break; } /* Order the nodes in the separator */ nbnd = graph->nbnd; bndind = graph->bndind; label = graph->label; for (i=0; i MMDSWITCH) MlevelNestedDissection(ctrl, &rgraph, order, ubfactor, lastvtx); else { MMDOrder(ctrl, &rgraph, order, lastvtx); FreeGraph(&rgraph, 0); } if (lgraph.nvtxs > MMDSWITCH) MlevelNestedDissection(ctrl, &lgraph, order, ubfactor, lastvtx-rgraph.nvtxs); else { MMDOrder(ctrl, &lgraph, order, lastvtx-rgraph.nvtxs); FreeGraph(&lgraph, 0); } } /************************************************************************* * This function takes a graph and produces a bisection of it **************************************************************************/ void MlevelNestedDissectionCC(CtrlType *ctrl, GraphType *graph, idxtype *order, float ubfactor, idxtype lastvtx) { idxtype i, j, nvtxs, nbnd, tvwgt, tpwgts2[2], nsgraphs, ncmps, rnvtxs; idxtype *label, *bndind; idxtype *cptr, *cind; GraphType *sgraphs; nvtxs = graph->nvtxs; /* Determine the weights of the partitions */ tvwgt = idxsum(nvtxs, graph->vwgt, 1); tpwgts2[0] = tvwgt/2; tpwgts2[1] = tvwgt-tpwgts2[0]; MlevelNodeBisectionMultiple(ctrl, graph, tpwgts2, ubfactor); IFSET(ctrl->dbglvl, DBG_SEPINFO, mprintf("Nvtxs: %6D, [%6D %6D %6D]\n", graph->nvtxs, graph->pwgts[0], graph->pwgts[1], graph->pwgts[2])); /* Order the nodes in the separator */ nbnd = graph->nbnd; bndind = graph->bndind; label = graph->label; for (i=0; i 2) mprintf("[%5D] has %3D components\n", nvtxs, ncmps); */ sgraphs = (GraphType *)gk_malloc(ncmps*sizeof(GraphType), "MlevelNestedDissectionCC: sgraphs"); nsgraphs = SplitGraphOrderCC(ctrl, graph, sgraphs, ncmps, cptr, cind); gk_free((void **)&cptr, &cind, LTERM); /* Free the memory of the top level graph */ FreeGraph(graph, 0); /* Go and process the subgraphs */ for (rnvtxs=i=0; inseps == 1 || graph->nvtxs < (ctrl->oflags&OFLAG_COMPRESS ? 1000 : 2000)) { MlevelNodeBisection(ctrl, graph, tpwgts, ubfactor); return; } nvtxs = graph->nvtxs; if (ctrl->oflags&OFLAG_COMPRESS) { /* Multiple separators at the original graph */ bestwhere = idxmalloc(nvtxs, "MlevelNodeBisection2: bestwhere"); for (i=ctrl->nseps; i>0; i--) { MlevelNodeBisection(ctrl, graph, tpwgts, ubfactor); /* mprintf("%5D ", cgraph->mincut); */ if (i==ctrl->nseps || graph->mincut < mincut) { mincut = graph->mincut; idxcopy(nvtxs, graph->where, bestwhere); } FreeRData(graph); if (mincut == 0) break; } /* mprintf("[%5D]\n", mincut); */ Allocate2WayNodePartitionMemory(ctrl, graph); idxcopy(nvtxs, bestwhere, graph->where); gk_free((void **)&bestwhere, LTERM); Compute2WayNodePartitionParams(ctrl, graph); } else { /* Coarsen it a bit */ ctrl->CoarsenTo = nvtxs-1; cgraph = Coarsen2Way(ctrl, graph); cnvtxs = cgraph->nvtxs; bestwhere = idxmalloc(cnvtxs, "MlevelNodeBisection2: bestwhere"); for (i=ctrl->nseps; i>0; i--) { ctrl->CType += 20; /* This is a hack. Look at coarsen.c */ MlevelNodeBisection(ctrl, cgraph, tpwgts, ubfactor); /* mprintf("%5D ", cgraph->mincut); */ if (i==ctrl->nseps || cgraph->mincut < mincut) { mincut = cgraph->mincut; idxcopy(cnvtxs, cgraph->where, bestwhere); } FreeRData(graph); if (mincut == 0) break; } /* mprintf("[%5D]\n", mincut); */ Allocate2WayNodePartitionMemory(ctrl, cgraph); idxcopy(cnvtxs, bestwhere, cgraph->where); gk_free((void **)&bestwhere, LTERM); Compute2WayNodePartitionParams(ctrl, cgraph); Refine2WayNode(ctrl, graph, cgraph, ubfactor); } } /************************************************************************* * This function performs multilevel bisection **************************************************************************/ void MlevelNodeBisection(CtrlType *ctrl, GraphType *graph, idxtype *tpwgts, float ubfactor) { GraphType *cgraph; ctrl->CoarsenTo = graph->nvtxs/8; if (ctrl->CoarsenTo > 100) ctrl->CoarsenTo = 100; else if (ctrl->CoarsenTo < 40) ctrl->CoarsenTo = 40; ctrl->maxvwgt = 1.5*((tpwgts[0]+tpwgts[1])/ctrl->CoarsenTo); cgraph = Coarsen2Way(ctrl, graph); switch (ctrl->IType) { case ITYPE_GGPKL: Init2WayPartition(ctrl, cgraph, tpwgts, ubfactor); IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->SepTmr)); Compute2WayPartitionParams(ctrl, cgraph); ConstructSeparator(ctrl, cgraph, ubfactor); IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->SepTmr)); break; case ITYPE_GGPKLNODE: InitSeparator(ctrl, cgraph, ubfactor); break; } Refine2WayNode(ctrl, graph, cgraph, ubfactor); } /************************************************************************* * This function takes a graph and a bisection and splits it into two graphs. * This function relies on the fact that adjwgt is all equal to 1. **************************************************************************/ void SplitGraphOrder(CtrlType *ctrl, GraphType *graph, GraphType *lgraph, GraphType *rgraph) { idxtype i, ii, j, k, l, istart, iend, mypart, nvtxs, snvtxs[3], snedges[3]; idxtype *xadj, *vwgt, *adjncy, *adjwgt, *adjwgtsum, *label, *where, *bndptr, *bndind; idxtype *sxadj[2], *svwgt[2], *sadjncy[2], *sadjwgt[2], *sadjwgtsum[2], *slabel[2]; idxtype *rename; idxtype *auxadjncy, *auxadjwgt; IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->SplitTmr)); nvtxs = graph->nvtxs; xadj = graph->xadj; vwgt = graph->vwgt; adjncy = graph->adjncy; adjwgt = graph->adjwgt; adjwgtsum = graph->adjwgtsum; label = graph->label; where = graph->where; bndptr = graph->bndptr; bndind = graph->bndind; ASSERT(bndptr != NULL); rename = idxwspacemalloc(ctrl, nvtxs); snvtxs[0] = snvtxs[1] = snvtxs[2] = snedges[0] = snedges[1] = snedges[2] = 0; for (i=0; ixadj; svwgt[0] = lgraph->vwgt; sadjwgtsum[0] = lgraph->adjwgtsum; sadjncy[0] = lgraph->adjncy; sadjwgt[0] = lgraph->adjwgt; slabel[0] = lgraph->label; SetUpSplitGraph(graph, rgraph, snvtxs[1], snedges[1]); sxadj[1] = rgraph->xadj; svwgt[1] = rgraph->vwgt; sadjwgtsum[1] = rgraph->adjwgtsum; sadjncy[1] = rgraph->adjncy; sadjwgt[1] = rgraph->adjwgt; slabel[1] = rgraph->label; /* Go and use bndptr to also mark the boundary nodes in the two partitions */ for (ii=0; iinbnd; ii++) { i = bndind[ii]; for (j=xadj[i]; jnvtxs = snvtxs[0]; lgraph->nedges = snedges[0]; rgraph->nvtxs = snvtxs[1]; rgraph->nedges = snedges[1]; IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->SplitTmr)); idxwspacefree(ctrl, nvtxs); } /************************************************************************* * This function uses MMD to order the graph. The vertices are numbered * from lastvtx downwards **************************************************************************/ void MMDOrder(CtrlType *ctrl, GraphType *graph, idxtype *order, idxtype lastvtx) { idxtype i, j, k, nvtxs, nofsub, firstvtx; idxtype *xadj, *adjncy, *label; idxtype *perm, *iperm, *head, *qsize, *list, *marker; nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; /* Relabel the vertices so that it starts from 1 */ k = xadj[nvtxs]; for (i=0; ilabel; firstvtx = lastvtx-nvtxs; for (i=0; idbglvl, DBG_TIME, gk_startcputimer(ctrl->SplitTmr)); nvtxs = graph->nvtxs; xadj = graph->xadj; vwgt = graph->vwgt; adjncy = graph->adjncy; adjwgt = graph->adjwgt; adjwgtsum = graph->adjwgtsum; label = graph->label; where = graph->where; bndptr = graph->bndptr; bndind = graph->bndind; ASSERT(bndptr != NULL); /* Go and use bndptr to also mark the boundary nodes in the two partitions */ for (ii=0; iinbnd; ii++) { i = bndind[ii]; for (j=xadj[i]; jdbglvl, DBG_TIME, gk_stopcputimer(ctrl->SplitTmr)); idxwspacefree(ctrl, nvtxs); return ncmps; } PyMetis-0.90/src/metis/parmetis.c0000640000175000017500000002605210662171744016561 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * parmetis.c * * This file contains top level routines that are used by ParMETIS * * Started 10/14/97 * George * * $Id: parmetis.c,v 1.5 2002/08/13 07:16:43 karypis Exp $ * */ #include /************************************************************************* * This function is the entry point for KMETIS with seed specification * in options[7] **************************************************************************/ void METIS_PartGraphKway2(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, idxtype *options, idxtype *edgecut, idxtype *part) { idxtype i; float *tpwgts; tpwgts = gk_fmalloc(*nparts, "KMETIS: tpwgts"); for (i=0; i<*nparts; i++) tpwgts[i] = 1.0/(1.0*(*nparts)); METIS_WPartGraphKway2(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, tpwgts, options, edgecut, part); gk_free((void **)&tpwgts, LTERM); } /************************************************************************* * This function is the entry point for KWMETIS with seed specification * in options[7] **************************************************************************/ void METIS_WPartGraphKway2(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *tpwgts, idxtype *options, idxtype *edgecut, idxtype *part) { idxtype i, j; GraphType graph; CtrlType ctrl; if (*numflag == 1) Change2CNumbering(*nvtxs, xadj, adjncy); SetUpGraph(&graph, OP_KMETIS, *nvtxs, 1, xadj, adjncy, vwgt, adjwgt, *wgtflag); if (options[0] == 0) { /* Use the default parameters */ ctrl.CType = KMETIS_CTYPE; ctrl.IType = KMETIS_ITYPE; ctrl.RType = KMETIS_RTYPE; ctrl.dbglvl = KMETIS_DBGLVL; } else { ctrl.CType = options[OPTION_CTYPE]; ctrl.IType = options[OPTION_ITYPE]; ctrl.RType = options[OPTION_RTYPE]; ctrl.dbglvl = options[OPTION_DBGLVL]; } ctrl.optype = OP_KMETIS; ctrl.CoarsenTo = 20*(*nparts); ctrl.maxvwgt = 1.5*((graph.vwgt ? idxsum(*nvtxs, graph.vwgt, 1) : (*nvtxs))/ctrl.CoarsenTo); InitRandom(options[7]); AllocateWorkSpace(&ctrl, &graph, *nparts); IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl)); IFSET(ctrl.dbglvl, DBG_TIME, gk_startcputimer(ctrl.TotalTmr)); *edgecut = MlevelKWayPartitioning(&ctrl, &graph, *nparts, part, tpwgts, 1.03); IFSET(ctrl.dbglvl, DBG_TIME, gk_stopcputimer(ctrl.TotalTmr)); IFSET(ctrl.dbglvl, DBG_TIME, PrintTimers(&ctrl)); FreeWorkSpace(&ctrl, &graph); if (*numflag == 1) Change2FNumbering(*nvtxs, xadj, adjncy, part); } /************************************************************************* * This function is the entry point for the node ND code for ParMETIS **************************************************************************/ void METIS_NodeNDP(idxtype nvtxs, idxtype *xadj, idxtype *adjncy, idxtype npes, idxtype *options, idxtype *perm, idxtype *iperm, idxtype *sizes) { idxtype i, ii, j, l, wflag, nflag; GraphType graph; CtrlType ctrl; idxtype *cptr, *cind; if (options[0] == 0) { /* Use the default parameters */ ctrl.CType = ONMETIS_CTYPE; ctrl.IType = ONMETIS_ITYPE; ctrl.RType = ONMETIS_RTYPE; ctrl.dbglvl = ONMETIS_DBGLVL; ctrl.oflags = ONMETIS_OFLAGS; ctrl.pfactor = ONMETIS_PFACTOR; ctrl.nseps = ONMETIS_NSEPS; } else { ctrl.CType = options[OPTION_CTYPE]; ctrl.IType = options[OPTION_ITYPE]; ctrl.RType = options[OPTION_RTYPE]; ctrl.dbglvl = options[OPTION_DBGLVL]; ctrl.oflags = options[OPTION_OFLAGS]; ctrl.pfactor = options[OPTION_PFACTOR]; ctrl.nseps = options[OPTION_NSEPS]; } if (ctrl.nseps < 1) ctrl.nseps = 1; ctrl.optype = OP_ONMETIS; ctrl.CoarsenTo = 100; IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl)); IFSET(ctrl.dbglvl, DBG_TIME, gk_startcputimer(ctrl.TotalTmr)); InitRandom(-1); if (ctrl.oflags&OFLAG_COMPRESS) { /*============================================================ * Compress the graph ==============================================================*/ cptr = idxmalloc(nvtxs+1, "ONMETIS: cptr"); cind = idxmalloc(nvtxs, "ONMETIS: cind"); CompressGraph(&ctrl, &graph, nvtxs, xadj, adjncy, cptr, cind); if (graph.nvtxs >= COMPRESSION_FRACTION*(nvtxs)) { ctrl.oflags--; /* We actually performed no compression */ gk_free((void **)&cptr, &cind, LTERM); } else if (2*graph.nvtxs < nvtxs && ctrl.nseps == 1) ctrl.nseps = 2; } else { SetUpGraph(&graph, OP_ONMETIS, nvtxs, 1, xadj, adjncy, NULL, NULL, 0); } /*============================================================= * Do the nested dissection ordering --=============================================================*/ ctrl.maxvwgt = 1.5*(idxsum(graph.nvtxs, graph.vwgt, 1)/ctrl.CoarsenTo); AllocateWorkSpace(&ctrl, &graph, 2); idxset(2*npes-1, 0, sizes); MlevelNestedDissectionP(&ctrl, &graph, iperm, graph.nvtxs, npes, 0, sizes); FreeWorkSpace(&ctrl, &graph); if (ctrl.oflags&OFLAG_COMPRESS) { /* Uncompress the ordering */ if (graph.nvtxs < COMPRESSION_FRACTION*(nvtxs)) { /* construct perm from iperm */ for (i=0; invtxs; if (nvtxs == 0) { FreeGraph(graph, 0); return; } /* Determine the weights of the partitions */ tvwgt = idxsum(nvtxs, graph->vwgt, 1); tpwgts2[0] = tvwgt/2; tpwgts2[1] = tvwgt-tpwgts2[0]; if (cpos >= npes-1) ubfactor = ORDER_UNBALANCE_FRACTION; else ubfactor = 1.05; MlevelNodeBisectionMultiple(ctrl, graph, tpwgts2, ubfactor); IFSET(ctrl->dbglvl, DBG_SEPINFO, mprintf("Nvtxs: %6D, [%6D %6D %6D]\n", graph->nvtxs, graph->pwgts[0], graph->pwgts[1], graph->pwgts[2])); if (cpos < npes-1) { sizes[2*npes-2-cpos] = graph->pwgts[2]; sizes[2*npes-2-(2*cpos+1)] = graph->pwgts[1]; sizes[2*npes-2-(2*cpos+2)] = graph->pwgts[0]; } /* Order the nodes in the separator */ nbnd = graph->nbnd; bndind = graph->bndind; label = graph->label; for (i=0; i MMDSWITCH || 2*cpos+1 < npes-1) MlevelNestedDissectionP(ctrl, &rgraph, order, lastvtx, npes, 2*cpos+1, sizes); else { MMDOrder(ctrl, &rgraph, order, lastvtx); FreeGraph(&rgraph, 0); } if (lgraph.nvtxs > MMDSWITCH || 2*cpos+2 < npes-1) MlevelNestedDissectionP(ctrl, &lgraph, order, lastvtx-rgraph.nvtxs, npes, 2*cpos+2, sizes); else { MMDOrder(ctrl, &lgraph, order, lastvtx-rgraph.nvtxs); FreeGraph(&lgraph, 0); } } /************************************************************************* * This function is the entry point for ONWMETIS. It requires weights on the * vertices. It is for the case that the matrix has been pre-compressed. **************************************************************************/ void METIS_NodeComputeSeparator(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *options, idxtype *sepsize, idxtype *part) { idxtype i, j, tvwgt, tpwgts[2]; GraphType graph; CtrlType ctrl; SetUpGraph(&graph, OP_ONMETIS, *nvtxs, 1, xadj, adjncy, vwgt, adjwgt, 3); tvwgt = idxsum(*nvtxs, graph.vwgt, 1); if (options[0] == 0) { /* Use the default parameters */ ctrl.CType = ONMETIS_CTYPE; ctrl.IType = ONMETIS_ITYPE; ctrl.RType = ONMETIS_RTYPE; ctrl.dbglvl = ONMETIS_DBGLVL; } else { ctrl.CType = options[OPTION_CTYPE]; ctrl.IType = options[OPTION_ITYPE]; ctrl.RType = options[OPTION_RTYPE]; ctrl.dbglvl = options[OPTION_DBGLVL]; } ctrl.oflags = 0; ctrl.pfactor = 0; ctrl.nseps = 3; ctrl.optype = OP_ONMETIS; ctrl.CoarsenTo = amin(100, *nvtxs-1); ctrl.maxvwgt = 1.5*tvwgt/ctrl.CoarsenTo; InitRandom(options[7]); AllocateWorkSpace(&ctrl, &graph, 2); /*============================================================ * Perform the bisection *============================================================*/ tpwgts[0] = tvwgt/2; tpwgts[1] = tvwgt-tpwgts[0]; MlevelNodeBisectionMultiple(&ctrl, &graph, tpwgts, 1.02); *sepsize = graph.pwgts[2]; idxcopy(*nvtxs, graph.where, part); FreeGraph(&graph, 0); FreeWorkSpace(&ctrl, &graph); } /************************************************************************* * This function is the entry point for ONWMETIS. It requires weights on the * vertices. It is for the case that the matrix has been pre-compressed. **************************************************************************/ void METIS_EdgeComputeSeparator(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *options, idxtype *sepsize, idxtype *part) { idxtype i, j, tvwgt, tpwgts[2]; GraphType graph; CtrlType ctrl; SetUpGraph(&graph, OP_ONMETIS, *nvtxs, 1, xadj, adjncy, vwgt, adjwgt, 3); tvwgt = idxsum(*nvtxs, graph.vwgt, 1); if (options[0] == 0) { /* Use the default parameters */ ctrl.CType = ONMETIS_CTYPE; ctrl.IType = ONMETIS_ITYPE; ctrl.RType = ONMETIS_RTYPE; ctrl.dbglvl = ONMETIS_DBGLVL; } else { ctrl.CType = options[OPTION_CTYPE]; ctrl.IType = options[OPTION_ITYPE]; ctrl.RType = options[OPTION_RTYPE]; ctrl.dbglvl = options[OPTION_DBGLVL]; } ctrl.oflags = 0; ctrl.pfactor = 0; ctrl.nseps = 1; ctrl.optype = OP_OEMETIS; ctrl.CoarsenTo = amin(100, *nvtxs-1); ctrl.maxvwgt = 1.5*tvwgt/ctrl.CoarsenTo; InitRandom(options[7]); AllocateWorkSpace(&ctrl, &graph, 2); /*============================================================ * Perform the bisection *============================================================*/ tpwgts[0] = tvwgt/2; tpwgts[1] = tvwgt-tpwgts[0]; MlevelEdgeBisection(&ctrl, &graph, tpwgts, 1.05); ConstructMinCoverSeparator(&ctrl, &graph, 1.05); *sepsize = graph.pwgts[2]; idxcopy(*nvtxs, graph.where, part); FreeGraph(&graph, 0); FreeWorkSpace(&ctrl, &graph); } PyMetis-0.90/src/metis/pmetis.c0000640000175000017500000002401210662171744016230 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * pmetis.c * * This file contains the top level routines for the multilevel recursive * bisection algorithm PMETIS. * * Started 7/24/97 * George * * $Id: pmetis.c,v 1.2 2002/08/10 06:29:33 karypis Exp $ * */ #include /************************************************************************* * This function is the entry point for PMETIS **************************************************************************/ void METIS_PartGraphRecursive(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, idxtype *options, idxtype *edgecut, idxtype *part) { idxtype i; float *tpwgts; tpwgts = gk_fmalloc(*nparts, "KMETIS: tpwgts"); for (i=0; i<*nparts; i++) tpwgts[i] = 1.0/(1.0*(*nparts)); METIS_WPartGraphRecursive(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, tpwgts, options, edgecut, part); gk_free((void **)&tpwgts, LTERM); } /************************************************************************* * This function is the entry point for PWMETIS that accepts exact weights * for the target partitions **************************************************************************/ void METIS_WPartGraphRecursive(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *tpwgts, idxtype *options, idxtype *edgecut, idxtype *part) { idxtype i, j; GraphType graph; CtrlType ctrl; float *mytpwgts; if (*numflag == 1) Change2CNumbering(*nvtxs, xadj, adjncy); SetUpGraph(&graph, OP_PMETIS, *nvtxs, 1, xadj, adjncy, vwgt, adjwgt, *wgtflag); if (options[0] == 0) { /* Use the default parameters */ ctrl.CType = PMETIS_CTYPE; ctrl.IType = PMETIS_ITYPE; ctrl.RType = PMETIS_RTYPE; ctrl.dbglvl = PMETIS_DBGLVL; } else { ctrl.CType = options[OPTION_CTYPE]; ctrl.IType = options[OPTION_ITYPE]; ctrl.RType = options[OPTION_RTYPE]; ctrl.dbglvl = options[OPTION_DBGLVL]; } ctrl.optype = OP_PMETIS; ctrl.CoarsenTo = 20; ctrl.maxvwgt = 1.5*(idxsum(*nvtxs, graph.vwgt, 1)/ctrl.CoarsenTo); mytpwgts = gk_fmalloc(*nparts, "PWMETIS: mytpwgts"); for (i=0; i<*nparts; i++) mytpwgts[i] = tpwgts[i]; InitRandom(-1); AllocateWorkSpace(&ctrl, &graph, *nparts); IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl)); IFSET(ctrl.dbglvl, DBG_TIME, gk_startcputimer(ctrl.TotalTmr)); *edgecut = MlevelRecursiveBisection(&ctrl, &graph, *nparts, part, mytpwgts, 1.000, 0); IFSET(ctrl.dbglvl, DBG_TIME, gk_stopcputimer(ctrl.TotalTmr)); IFSET(ctrl.dbglvl, DBG_TIME, PrintTimers(&ctrl)); FreeWorkSpace(&ctrl, &graph); gk_free((void **)&mytpwgts, LTERM); if (*numflag == 1) Change2FNumbering(*nvtxs, xadj, adjncy, part); } /************************************************************************* * This function takes a graph and produces a bisection of it **************************************************************************/ idxtype MlevelRecursiveBisection(CtrlType *ctrl, GraphType *graph, idxtype nparts, idxtype *part, float *tpwgts, float ubfactor, idxtype fpart) { idxtype i, j, nvtxs, cut, tvwgt, tpwgts2[2]; idxtype *label, *where; GraphType lgraph, rgraph; float wsum; nvtxs = graph->nvtxs; if (nvtxs == 0) { mprintf("\t***Cannot bisect a graph with 0 vertices!\n\t***You are trying to partition a graph into too many parts!\n"); return 0; } /* Determine the weights of the partitions */ tvwgt = idxsum(nvtxs, graph->vwgt, 1); tpwgts2[0] = tvwgt*gk_fsum(nparts/2, tpwgts, 1); tpwgts2[1] = tvwgt-tpwgts2[0]; MlevelEdgeBisection(ctrl, graph, tpwgts2, ubfactor); cut = graph->mincut; /* mprintf("%5D %5D %5D [%5D %f]\n", tpwgts2[0], tpwgts2[1], cut, tvwgt, gk_fsum(nparts/2, tpwgts, 1));*/ label = graph->label; where = graph->where; for (i=0; i 2) { SplitGraphPart(ctrl, graph, &lgraph, &rgraph); /* mprintf("%D %D\n", lgraph.nvtxs, rgraph.nvtxs); */ } /* Free the memory of the top level graph */ FreeGraph(graph, 0); /* Scale the fractions in the tpwgts according to the true weight */ wsum = gk_fsum(nparts/2, tpwgts, 1); gk_fscale(nparts/2, 1.0/wsum, tpwgts, 1); gk_fscale(nparts-nparts/2, 1.0/(1.0-wsum), tpwgts+nparts/2, 1); /* for (i=0; i 3) { cut += MlevelRecursiveBisection(ctrl, &lgraph, nparts/2, part, tpwgts, ubfactor, fpart); cut += MlevelRecursiveBisection(ctrl, &rgraph, nparts-nparts/2, part, tpwgts+nparts/2, ubfactor, fpart+nparts/2); } else if (nparts == 3) { cut += MlevelRecursiveBisection(ctrl, &rgraph, nparts-nparts/2, part, tpwgts+nparts/2, ubfactor, fpart+nparts/2); FreeGraph(&lgraph, 0); } return cut; } /************************************************************************* * This function performs multilevel bisection **************************************************************************/ void MlevelEdgeBisection(CtrlType *ctrl, GraphType *graph, idxtype *tpwgts, float ubfactor) { GraphType *cgraph; cgraph = Coarsen2Way(ctrl, graph); Init2WayPartition(ctrl, cgraph, tpwgts, ubfactor); Refine2Way(ctrl, graph, cgraph, tpwgts, ubfactor); /* IsConnectedSubdomain(ctrl, graph, 0); IsConnectedSubdomain(ctrl, graph, 1); */ } /************************************************************************* * This function takes a graph and a bisection and splits it into two graphs. **************************************************************************/ void SplitGraphPart(CtrlType *ctrl, GraphType *graph, GraphType *lgraph, GraphType *rgraph) { idxtype i, j, k, kk, l, istart, iend, mypart, nvtxs, ncon, snvtxs[2], snedges[2], sum; idxtype *xadj, *vwgt, *adjncy, *adjwgt, *adjwgtsum, *label, *where, *bndptr; idxtype *sxadj[2], *svwgt[2], *sadjncy[2], *sadjwgt[2], *sadjwgtsum[2], *slabel[2]; idxtype *rename; idxtype *auxadjncy, *auxadjwgt; float *nvwgt, *snvwgt[2], *npwgts; IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->SplitTmr)); nvtxs = graph->nvtxs; ncon = graph->ncon; xadj = graph->xadj; vwgt = graph->vwgt; nvwgt = graph->nvwgt; adjncy = graph->adjncy; adjwgt = graph->adjwgt; adjwgtsum = graph->adjwgtsum; label = graph->label; where = graph->where; bndptr = graph->bndptr; npwgts = graph->npwgts; ASSERT(bndptr != NULL); rename = idxwspacemalloc(ctrl, nvtxs); snvtxs[0] = snvtxs[1] = snedges[0] = snedges[1] = 0; for (i=0; ixadj; svwgt[0] = lgraph->vwgt; snvwgt[0] = lgraph->nvwgt; sadjwgtsum[0] = lgraph->adjwgtsum; sadjncy[0] = lgraph->adjncy; sadjwgt[0] = lgraph->adjwgt; slabel[0] = lgraph->label; SetUpSplitGraph(graph, rgraph, snvtxs[1], snedges[1]); sxadj[1] = rgraph->xadj; svwgt[1] = rgraph->vwgt; snvwgt[1] = rgraph->nvwgt; sadjwgtsum[1] = rgraph->adjwgtsum; sadjncy[1] = rgraph->adjncy; sadjwgt[1] = rgraph->adjwgt; slabel[1] = rgraph->label; snvtxs[0] = snvtxs[1] = snedges[0] = snedges[1] = 0; sxadj[0][0] = sxadj[1][0] = 0; for (i=0; inedges = snedges[0]; rgraph->nedges = snedges[1]; IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->SplitTmr)); idxwspacefree(ctrl, nvtxs); } /************************************************************************* * Setup the various arrays for the splitted graph **************************************************************************/ void SetUpSplitGraph(GraphType *graph, GraphType *sgraph, idxtype snvtxs, idxtype snedges) { InitGraph(sgraph); sgraph->nvtxs = snvtxs; sgraph->nedges = snedges; sgraph->ncon = graph->ncon; /* Allocate memory for the splitted graph */ sgraph->xadj = idxmalloc(snvtxs+1, "SetUpSplitGraph: xadj"); sgraph->adjwgtsum = idxmalloc(snvtxs, "SetUpSplitGraph: adjwgtsum"); sgraph->cmap = idxmalloc(snvtxs, "SetUpSplitGraph: cmap"); sgraph->adjncy = idxmalloc(snedges, "SetUpSplitGraph: adjncy"); sgraph->adjwgt = idxmalloc(snedges, "SetUpSplitGraph: adjwgt"); sgraph->label = idxmalloc(snvtxs, "SetUpSplitGraph: label"); if (graph->ncon == 1) sgraph->vwgt = idxmalloc(snvtxs, "SetUpSplitGraph: vwgt"); else sgraph->nvwgt = gk_fmalloc(graph->ncon*snvtxs, "SetUpSplitGraph: nvwgt"); } PyMetis-0.90/src/metis/pqueue.c0000640000175000017500000003530010662171744016235 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * pqueue.c * * This file contains functions for manipulating the bucket list * representation of the gains associated with each vertex in a graph. * These functions are used by the refinement algorithms * * Started 9/2/94 * George * * $Id: pqueue.c,v 1.2 2002/08/10 06:29:34 karypis Exp $ * */ #include /************************************************************************* * This function initializes the data structures of the priority queue **************************************************************************/ void PQueueInit(CtrlType *ctrl, PQueueType *queue, idxtype maxnodes, idxtype maxgain) { idxtype i, j, ncore; queue->nnodes = 0; queue->maxnodes = maxnodes; queue->buckets = NULL; queue->nodes = NULL; queue->heap = NULL; queue->locator = NULL; if (maxgain > PLUS_GAINSPAN || maxnodes < 500) queue->type = 2; else queue->type = 1; if (queue->type == 1) { queue->pgainspan = amin(PLUS_GAINSPAN, maxgain); queue->ngainspan = amin(NEG_GAINSPAN, maxgain); j = queue->ngainspan+queue->pgainspan+1; ncore = 2 + (sizeof(ListNodeType)/sizeof(idxtype))*maxnodes + (sizeof(ListNodeType *)/sizeof(idxtype))*j; if (WspaceAvail(ctrl) > ncore) { queue->nodes = (ListNodeType *)idxwspacemalloc(ctrl, (sizeof(ListNodeType)/sizeof(idxtype))*maxnodes); queue->buckets = (ListNodeType **)idxwspacemalloc(ctrl, (sizeof(ListNodeType *)/sizeof(idxtype))*j); queue->mustfree = 0; } else { /* Not enough memory in the wspace, allocate it */ queue->nodes = (ListNodeType *)gk_malloc(maxnodes*sizeof(ListNodeType), "PQueueInit: queue->nodes"); queue->buckets = (ListNodeType **)gk_malloc(j*sizeof(ListNodeType *), "PQueueInit: queue->buckets"); queue->mustfree = 1; } for (i=0; inodes[i].id = i; for (i=0; ibuckets[i] = NULL; queue->buckets += queue->ngainspan; /* Advance buckets by the ngainspan proper indexing */ queue->maxgain = -queue->ngainspan; } else { queue->heap = (KeyValueType *)idxwspacemalloc(ctrl, (sizeof(KeyValueType)/sizeof(idxtype))*maxnodes); queue->locator = idxwspacemalloc(ctrl, maxnodes); idxset(maxnodes, -1, queue->locator); } } /************************************************************************* * This function resets the buckets **************************************************************************/ void PQueueReset(PQueueType *queue) { idxtype i, j; queue->nnodes = 0; if (queue->type == 1) { queue->maxgain = -queue->ngainspan; j = queue->ngainspan+queue->pgainspan+1; queue->buckets -= queue->ngainspan; for (i=0; ibuckets[i] = NULL; queue->buckets += queue->ngainspan; } else { idxset(queue->maxnodes, -1, queue->locator); } } /************************************************************************* * This function frees the buckets **************************************************************************/ void PQueueFree(CtrlType *ctrl, PQueueType *queue) { if (queue->type == 1) { if (queue->mustfree) { queue->buckets -= queue->ngainspan; gk_free((void **)&queue->nodes, &queue->buckets, LTERM); } else { idxwspacefree(ctrl, sizeof(ListNodeType *)*(queue->ngainspan+queue->pgainspan+1)/sizeof(idxtype)); idxwspacefree(ctrl, sizeof(ListNodeType)*queue->maxnodes/sizeof(idxtype)); } } else { idxwspacefree(ctrl, sizeof(KeyValueType)*queue->maxnodes/sizeof(idxtype)); idxwspacefree(ctrl, queue->maxnodes); } queue->maxnodes = 0; } /************************************************************************* * This function returns the number of nodes in the queue **************************************************************************/ idxtype PQueueGetSize(PQueueType *queue) { return queue->nnodes; } /************************************************************************* * This function adds a node of certain gain into a partition **************************************************************************/ idxtype PQueueInsert(PQueueType *queue, idxtype node, idxtype gain) { idxtype i, j, k; idxtype *locator; ListNodeType *newnode; KeyValueType *heap; if (queue->type == 1) { ASSERT(gain >= -queue->ngainspan && gain <= queue->pgainspan); /* Allocate and add the node */ queue->nnodes++; newnode = queue->nodes + node; /* Attach this node in the doubly-linked list */ newnode->next = queue->buckets[gain]; newnode->prev = NULL; if (newnode->next != NULL) newnode->next->prev = newnode; queue->buckets[gain] = newnode; if (queue->maxgain < gain) queue->maxgain = gain; } else { ASSERT(CheckHeap(queue)); heap = queue->heap; locator = queue->locator; ASSERT(locator[node] == -1); i = queue->nnodes++; while (i > 0) { j = (i-1)/2; if (heap[j].key < gain) { heap[i] = heap[j]; locator[heap[i].val] = i; i = j; } else break; } ASSERT(i >= 0); heap[i].key = gain; heap[i].val = node; locator[node] = i; ASSERT(CheckHeap(queue)); } return 0; } /************************************************************************* * This function deletes a node from a partition and reinserts it with * an updated gain **************************************************************************/ idxtype PQueueDelete(PQueueType *queue, idxtype node, idxtype gain) { idxtype i, j, newgain, oldgain; idxtype *locator; ListNodeType *newnode, **buckets; KeyValueType *heap; if (queue->type == 1) { ASSERT(gain >= -queue->ngainspan && gain <= queue->pgainspan); ASSERT(queue->nnodes > 0); buckets = queue->buckets; queue->nnodes--; newnode = queue->nodes+node; /* Remove newnode from the doubly-linked list */ if (newnode->prev != NULL) newnode->prev->next = newnode->next; else buckets[gain] = newnode->next; if (newnode->next != NULL) newnode->next->prev = newnode->prev; if (buckets[gain] == NULL && gain == queue->maxgain) { if (queue->nnodes == 0) queue->maxgain = -queue->ngainspan; else for (; buckets[queue->maxgain]==NULL; queue->maxgain--); } } else { /* Heap Priority Queue */ heap = queue->heap; locator = queue->locator; ASSERT(locator[node] != -1); ASSERT(heap[locator[node]].val == node); ASSERT(CheckHeap(queue)); i = locator[node]; locator[node] = -1; if (--queue->nnodes > 0 && heap[queue->nnodes].val != node) { node = heap[queue->nnodes].val; newgain = heap[queue->nnodes].key; oldgain = heap[i].key; if (oldgain < newgain) { /* Filter-up */ while (i > 0) { j = (i-1)>>1; if (heap[j].key < newgain) { heap[i] = heap[j]; locator[heap[i].val] = i; i = j; } else break; } } else { /* Filter down */ while ((j=2*i+1) < queue->nnodes) { if (heap[j].key > newgain) { if (j+1 < queue->nnodes && heap[j+1].key > heap[j].key) j = j+1; heap[i] = heap[j]; locator[heap[i].val] = i; i = j; } else if (j+1 < queue->nnodes && heap[j+1].key > newgain) { j = j+1; heap[i] = heap[j]; locator[heap[i].val] = i; i = j; } else break; } } heap[i].key = newgain; heap[i].val = node; locator[node] = i; } ASSERT(CheckHeap(queue)); } return 0; } /************************************************************************* * This function deletes a node from a partition and reinserts it with * an updated gain **************************************************************************/ idxtype PQueueUpdate(PQueueType *queue, idxtype node, idxtype oldgain, idxtype newgain) { idxtype i, j; idxtype *locator; ListNodeType *newnode; KeyValueType *heap; if (oldgain == newgain) return 0; if (queue->type == 1) { /* First delete the node and then insert it */ PQueueDelete(queue, node, oldgain); return PQueueInsert(queue, node, newgain); } else { /* Heap Priority Queue */ heap = queue->heap; locator = queue->locator; ASSERT(locator[node] != -1); ASSERT(heap[locator[node]].val == node); ASSERT(heap[locator[node]].key == oldgain); ASSERT(CheckHeap(queue)); i = locator[node]; if (oldgain < newgain) { /* Filter-up */ while (i > 0) { j = (i-1)>>1; if (heap[j].key < newgain) { heap[i] = heap[j]; locator[heap[i].val] = i; i = j; } else break; } } else { /* Filter down */ while ((j=2*i+1) < queue->nnodes) { if (heap[j].key > newgain) { if (j+1 < queue->nnodes && heap[j+1].key > heap[j].key) j = j+1; heap[i] = heap[j]; locator[heap[i].val] = i; i = j; } else if (j+1 < queue->nnodes && heap[j+1].key > newgain) { j = j+1; heap[i] = heap[j]; locator[heap[i].val] = i; i = j; } else break; } } heap[i].key = newgain; heap[i].val = node; locator[node] = i; ASSERT(CheckHeap(queue)); } return 0; } /************************************************************************* * This function deletes a node from a partition and reinserts it with * an updated gain **************************************************************************/ void PQueueUpdateUp(PQueueType *queue, idxtype node, idxtype oldgain, idxtype newgain) { idxtype i, j; idxtype *locator; ListNodeType *newnode, **buckets; KeyValueType *heap; if (oldgain == newgain) return; if (queue->type == 1) { ASSERT(oldgain >= -queue->ngainspan && oldgain <= queue->pgainspan); ASSERT(newgain >= -queue->ngainspan && newgain <= queue->pgainspan); ASSERT(queue->nnodes > 0); buckets = queue->buckets; newnode = queue->nodes+node; /* First delete the node */ if (newnode->prev != NULL) newnode->prev->next = newnode->next; else buckets[oldgain] = newnode->next; if (newnode->next != NULL) newnode->next->prev = newnode->prev; /* Attach this node in the doubly-linked list */ newnode->next = buckets[newgain]; newnode->prev = NULL; if (newnode->next != NULL) newnode->next->prev = newnode; buckets[newgain] = newnode; if (queue->maxgain < newgain) queue->maxgain = newgain; } else { /* Heap Priority Queue */ heap = queue->heap; locator = queue->locator; ASSERT(locator[node] != -1); ASSERT(heap[locator[node]].val == node); ASSERT(heap[locator[node]].key == oldgain); ASSERT(CheckHeap(queue)); /* Here we are just filtering up since the newgain is greater than the oldgain */ i = locator[node]; while (i > 0) { j = (i-1)>>1; if (heap[j].key < newgain) { heap[i] = heap[j]; locator[heap[i].val] = i; i = j; } else break; } heap[i].key = newgain; heap[i].val = node; locator[node] = i; ASSERT(CheckHeap(queue)); } } /************************************************************************* * This function returns the vertex with the largest gain from a partition * and removes the node from the bucket list **************************************************************************/ idxtype PQueueGetMax(PQueueType *queue) { idxtype vtx, i, j, gain, node; idxtype *locator; ListNodeType *tptr; KeyValueType *heap; if (queue->nnodes == 0) return -1; queue->nnodes--; if (queue->type == 1) { tptr = queue->buckets[queue->maxgain]; queue->buckets[queue->maxgain] = tptr->next; if (tptr->next != NULL) { tptr->next->prev = NULL; } else { if (queue->nnodes == 0) { queue->maxgain = -queue->ngainspan; } else for (; queue->buckets[queue->maxgain]==NULL; queue->maxgain--); } return tptr->id; } else { heap = queue->heap; locator = queue->locator; vtx = heap[0].val; locator[vtx] = -1; if ((i = queue->nnodes) > 0) { gain = heap[i].key; node = heap[i].val; i = 0; while ((j=2*i+1) < queue->nnodes) { if (heap[j].key > gain) { if (j+1 < queue->nnodes && heap[j+1].key > heap[j].key) j = j+1; heap[i] = heap[j]; locator[heap[i].val] = i; i = j; } else if (j+1 < queue->nnodes && heap[j+1].key > gain) { j = j+1; heap[i] = heap[j]; locator[heap[i].val] = i; i = j; } else break; } heap[i].key = gain; heap[i].val = node; locator[node] = i; } ASSERT(CheckHeap(queue)); return vtx; } } /************************************************************************* * This function returns the vertex with the largest gain from a partition **************************************************************************/ idxtype PQueueSeeMax(PQueueType *queue) { idxtype vtx; if (queue->nnodes == 0) return -1; if (queue->type == 1) vtx = queue->buckets[queue->maxgain]->id; else vtx = queue->heap[0].val; return vtx; } /************************************************************************* * This function returns the vertex with the largest gain from a partition **************************************************************************/ idxtype PQueueGetKey(PQueueType *queue) { idxtype key; if (queue->nnodes == 0) return -1; if (queue->type == 1) key = queue->maxgain; else key = queue->heap[0].key; return key; } /************************************************************************* * This functions checks the consistency of the heap **************************************************************************/ idxtype CheckHeap(PQueueType *queue) { idxtype i, j, nnodes; idxtype *locator; KeyValueType *heap; heap = queue->heap; locator = queue->locator; nnodes = queue->nnodes; if (nnodes == 0) return 1; ASSERT(locator[heap[0].val] == 0); for (i=1; imaxnodes; i++) { if (locator[i] != -1) j++; } ASSERTP(j == nnodes, ("%d %d\n", j, nnodes)); return 1; } PyMetis-0.90/src/metis/proto.h0000640000175000017500000007245410662171744016114 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * proto.h * * This file contains header files * * Started 10/19/95 * George * * $Id: proto.h,v 1.27 2003/05/03 16:10:48 karypis Exp $ * */ #ifndef _LIBMETIS_PROTO_H_ #define _LIBMETIS_PROTO_H_ /* balance.c */ void Balance2Way(CtrlType *, GraphType *, idxtype *, float); void Bnd2WayBalance(CtrlType *, GraphType *, idxtype *); void General2WayBalance(CtrlType *, GraphType *, idxtype *); /* bucketsort.c */ void BucketSortKeysInc(idxtype, idxtype, idxtype *, idxtype *, idxtype *); /* ccgraph.c */ void CreateCoarseGraph(CtrlType *, GraphType *, idxtype, idxtype *, idxtype *); void CreateCoarseGraphNoMask(CtrlType *, GraphType *, idxtype, idxtype *, idxtype *); void CreateCoarseGraph_NVW(CtrlType *, GraphType *, idxtype, idxtype *, idxtype *); GraphType *SetUpCoarseGraph(GraphType *, idxtype, idxtype); void ReAdjustMemory(GraphType *, GraphType *, idxtype); /* coarsen.c */ GraphType *Coarsen2Way(CtrlType *, GraphType *); /* compress.c */ void CompressGraph(CtrlType *, GraphType *, idxtype, idxtype *, idxtype *, idxtype *, idxtype *); void PruneGraph(CtrlType *, GraphType *, idxtype, idxtype *, idxtype *, idxtype *, float); /* debug.c */ idxtype ComputeCut(GraphType *, idxtype *); idxtype ComputeMaxCut(GraphType *graph, idxtype nparts, idxtype *where); idxtype CheckBnd(GraphType *); idxtype CheckBnd2(GraphType *); idxtype CheckNodeBnd(GraphType *, idxtype); idxtype CheckRInfo(RInfoType *); idxtype CheckNodePartitionParams(GraphType *); idxtype IsSeparable(GraphType *); /* estmem.c */ void EstimateCFraction(idxtype, idxtype *, idxtype *, float *, float *); idxtype ComputeCoarseGraphSize(idxtype, idxtype *, idxtype *, idxtype, idxtype *, idxtype *, idxtype *); /* fm.c */ void FM_2WayEdgeRefine(CtrlType *, GraphType *, idxtype *, idxtype); /* fortran.c */ void Change2CNumbering(idxtype, idxtype *, idxtype *); void Change2FNumbering(idxtype, idxtype *, idxtype *, idxtype *); void Change2FNumbering2(idxtype, idxtype *, idxtype *); void Change2FNumberingOrder(idxtype, idxtype *, idxtype *, idxtype *, idxtype *); void ChangeMesh2CNumbering(idxtype, idxtype *); void ChangeMesh2FNumbering(idxtype, idxtype *, idxtype, idxtype *, idxtype *); void ChangeMesh2FNumbering2(idxtype, idxtype *, idxtype, idxtype, idxtype *, idxtype *); void ChangeMesh2FNumbering3(idxtype, idxtype *); /* frename.c */ void METIS_PARTGRAPHRECURSIVE(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void metis_partgraphrecursive(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void metis_partgraphrecursive_(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void metis_partgraphrecursive__(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void METIS_WPARTGRAPHRECURSIVE(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, float *, idxtype *, idxtype *, idxtype *); void metis_wpartgraphrecursive(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, float *, idxtype *, idxtype *, idxtype *); void metis_wpartgraphrecursive_(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, float *, idxtype *, idxtype *, idxtype *); void metis_wpartgraphrecursive__(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, float *, idxtype *, idxtype *, idxtype *); void METIS_PARTGRAPHKWAY(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void metis_partgraphkway(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void metis_partgraphkway_(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void metis_partgraphkway__(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void METIS_WPARTGRAPHKWAY(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, float *, idxtype *, idxtype *, idxtype *); void metis_wpartgraphkway(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, float *, idxtype *, idxtype *, idxtype *); void metis_wpartgraphkway_(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, float *, idxtype *, idxtype *, idxtype *); void metis_wpartgraphkway__(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, float *, idxtype *, idxtype *, idxtype *); void METIS_EDGEND(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void metis_edgend(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void metis_edgend_(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void metis_edgend__(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void METIS_NODEND(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void metis_nodend(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void metis_nodend_(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void metis_nodend__(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void METIS_NODEWND(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void metis_nodewnd(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void metis_nodewnd_(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void metis_nodewnd__(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void METIS_PARTMESHNODAL(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void metis_partmeshnodal(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void metis_partmeshnodal_(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void metis_partmeshnodal__(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void METIS_PARTMESHDUAL(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype, idxtype *); void metis_partmeshdual(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype, idxtype *); void metis_partmeshdual_(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype, idxtype *); void metis_partmeshdual__(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype, idxtype *); void METIS_MESHTONODAL(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void metis_meshtonodal(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void metis_meshtonodal_(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void metis_meshtonodal__(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void METIS_MESHTODUAL(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void metis_meshtodual(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void metis_meshtodual_(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void metis_meshtodual__(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void METIS_ESTIMATEMEMORY(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void metis_estimatememory(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void metis_estimatememory_(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void metis_estimatememory__(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void METIS_MCPARTGRAPHRECURSIVE(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void metis_mcpartgraphrecursive(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void metis_mcpartgraphrecursive_(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void metis_mcpartgraphrecursive__(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void METIS_MCPARTGRAPHKWAY(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, float *, idxtype *, idxtype *, idxtype *); void metis_mcpartgraphkway(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, float *, idxtype *, idxtype *, idxtype *); void metis_mcpartgraphkway_(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, float *, idxtype *, idxtype *, idxtype *); void metis_mcpartgraphkway__(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, float *, idxtype *, idxtype *, idxtype *); void METIS_PARTGRAPHVKWAY(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void metis_partgraphvkway(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void metis_partgraphvkway_(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void metis_partgraphvkway__(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void METIS_WPARTGRAPHVKWAY(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, float *, idxtype *, idxtype *, idxtype *); void metis_wpartgraphvkway(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, float *, idxtype *, idxtype *, idxtype *); void metis_wpartgraphvkway_(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, float *, idxtype *, idxtype *, idxtype *); void metis_wpartgraphvkway__(idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, float *, idxtype *, idxtype *, idxtype *); /* graph.c */ void SetUpGraph(GraphType *, idxtype, idxtype, idxtype, idxtype *, idxtype *, idxtype *, idxtype *, idxtype); void SetUpGraph2(GraphType *, idxtype, idxtype, idxtype *, idxtype *, float *, idxtype *); void VolSetUpGraph(GraphType *, idxtype, idxtype, idxtype, idxtype *, idxtype *, idxtype *, idxtype *, idxtype); void RandomizeGraph(GraphType *); idxtype IsConnectedSubdomain(CtrlType *, GraphType *, idxtype, idxtype); idxtype IsConnected(CtrlType *, GraphType *, idxtype); idxtype IsConnected2(GraphType *, idxtype); idxtype FindComponents(CtrlType *, GraphType *, idxtype *, idxtype *); /* initpart.c */ void Init2WayPartition(CtrlType *, GraphType *, idxtype *, float); void InitSeparator(CtrlType *, GraphType *, float); void GrowBisection(CtrlType *, GraphType *, idxtype *, float); void GrowBisectionNode(CtrlType *, GraphType *, float); void RandomBisection(CtrlType *, GraphType *, idxtype *, float); /* kmetis.c */ idxtype MlevelKWayPartitioning(CtrlType *, GraphType *, idxtype, idxtype *, float *, float); /* kvmetis.c */ idxtype MlevelVolKWayPartitioning(CtrlType *, GraphType *, idxtype, idxtype *, float *, float); /* kwayfm.c */ void Random_KWayEdgeRefine(CtrlType *, GraphType *, idxtype, float *, float, idxtype, idxtype); void Greedy_KWayEdgeRefine(CtrlType *, GraphType *, idxtype, float *, float, idxtype); void Greedy_KWayEdgeBalance(CtrlType *, GraphType *, idxtype, float *, float, idxtype); /* kwayrefine.c */ void RefineKWay(CtrlType *, GraphType *, GraphType *, idxtype, float *, float); void RefineKWayRefinement(CtrlType *, GraphType *, GraphType *, idxtype, float *, float); void AllocateKWayPartitionMemory(CtrlType *, GraphType *, idxtype); void ComputeKWayPartitionParams(CtrlType *, GraphType *, idxtype); void ProjectKWayPartition(CtrlType *, GraphType *, idxtype); idxtype IsBalanced(idxtype *, idxtype, float *, float); void ComputeKWayBoundary(CtrlType *, GraphType *, idxtype); void ComputeKWayBalanceBoundary(CtrlType *, GraphType *, idxtype); /* kwayvolfm.c */ void Random_KWayVolRefine(CtrlType *, GraphType *, idxtype, float *, float, idxtype, idxtype); void Random_KWayVolRefineMConn(CtrlType *, GraphType *, idxtype, float *, float, idxtype, idxtype); void Greedy_KWayVolBalance(CtrlType *, GraphType *, idxtype, float *, float, idxtype); void Greedy_KWayVolBalanceMConn(CtrlType *, GraphType *, idxtype, float *, float, idxtype); void KWayVolUpdate(CtrlType *, GraphType *, idxtype, idxtype, idxtype, idxtype *, idxtype *, idxtype *); void ComputeKWayVolume(GraphType *, idxtype, idxtype *, idxtype *, idxtype *); idxtype ComputeVolume(GraphType *, idxtype *); void CheckVolKWayPartitionParams(CtrlType *, GraphType *, idxtype); void ComputeVolSubDomainGraph(GraphType *, idxtype, idxtype *, idxtype *); void EliminateVolSubDomainEdges(CtrlType *, GraphType *, idxtype, float *); void EliminateVolComponents(CtrlType *, GraphType *, idxtype, float *, float); /* kwayvolrefine.c */ void RefineVolKWay(CtrlType *, GraphType *, GraphType *, idxtype, float *, float); void AllocateVolKWayPartitionMemory(CtrlType *, GraphType *, idxtype); void ComputeVolKWayPartitionParams(CtrlType *, GraphType *, idxtype); void ComputeKWayVolGains(CtrlType *, GraphType *, idxtype); void ProjectVolKWayPartition(CtrlType *, GraphType *, idxtype); void ComputeVolKWayBoundary(CtrlType *, GraphType *, idxtype); void ComputeVolKWayBalanceBoundary(CtrlType *, GraphType *, idxtype); /* match.c */ void Match_RM(CtrlType *, GraphType *); void Match_RM_NVW(CtrlType *, GraphType *); void Match_HEM(CtrlType *, GraphType *); void Match_SHEM(CtrlType *, GraphType *); /* mbalance.c */ void MocBalance2Way(CtrlType *, GraphType *, float *, float); void MocGeneral2WayBalance(CtrlType *, GraphType *, float *, float); /* mbalance2.c */ void MocBalance2Way2(CtrlType *, GraphType *, float *, float *); void MocGeneral2WayBalance2(CtrlType *, GraphType *, float *, float *); void SelectQueue3(idxtype, float *, float *, idxtype *, idxtype *, PQueueType [MAXNCON][2], float *); /* mcoarsen.c */ GraphType *MCCoarsen2Way(CtrlType *, GraphType *); /* memory.c */ void AllocateWorkSpace(CtrlType *, GraphType *, idxtype); void FreeWorkSpace(CtrlType *, GraphType *); idxtype WspaceAvail(CtrlType *); idxtype *idxwspacemalloc(CtrlType *, idxtype); void idxwspacefree(CtrlType *, idxtype); float *fwspacemalloc(CtrlType *, idxtype); void fwspacefree(CtrlType *, idxtype); GraphType *CreateGraph(void); void InitGraph(GraphType *); void FreeRData(GraphType *); void FreeGraph(GraphType *, int flag); /* mesh.c */ idxtype GENDUALMETIS_COUNT(idxtype , idxtype , idxtype , idxtype *, idxtype *); void GENDUALMETIS(idxtype, idxtype, idxtype, idxtype *, idxtype *, idxtype *, idxtype *adjncy); void TRINODALMETIS(idxtype, idxtype, idxtype *, idxtype *, idxtype *adjncy); void TETNODALMETIS(idxtype, idxtype, idxtype *, idxtype *, idxtype *adjncy); void HEXNODALMETIS(idxtype, idxtype, idxtype *, idxtype *, idxtype *adjncy); void QUADNODALMETIS(idxtype, idxtype, idxtype *, idxtype *, idxtype *adjncy); void LINENODALMETIS(idxtype, idxtype, idxtype *, idxtype *, idxtype *adjncy); /* meshpart.c */ /* mfm.c */ void MocFM_2WayEdgeRefine(CtrlType *, GraphType *, float *, idxtype); void SelectQueue(idxtype, float *, float *, idxtype *, idxtype *, PQueueType [MAXNCON][2]); idxtype BetterBalance(idxtype, float *, float *, float *); float Compute2WayHLoadImbalance(idxtype, float *, float *); void Compute2WayHLoadImbalanceVec(idxtype, float *, float *, float *); /* mfm2.c */ void MocFM_2WayEdgeRefine2(CtrlType *, GraphType *, float *, float *, idxtype); void SelectQueue2(idxtype, float *, float *, idxtype *, idxtype *, PQueueType [MAXNCON][2], float *); idxtype IsBetter2wayBalance(idxtype, float *, float *, float *); /* mincover.o */ void MinCover(idxtype *, idxtype *, idxtype, idxtype, idxtype *, idxtype *); idxtype MinCover_Augment(idxtype *, idxtype *, idxtype, idxtype *, idxtype *, idxtype *, idxtype); void MinCover_Decompose(idxtype *, idxtype *, idxtype, idxtype, idxtype *, idxtype *, idxtype *); void MinCover_ColDFS(idxtype *, idxtype *, idxtype, idxtype *, idxtype *, idxtype); void MinCover_RowDFS(idxtype *, idxtype *, idxtype, idxtype *, idxtype *, idxtype); /* minitpart.c */ void MocInit2WayPartition(CtrlType *, GraphType *, float *, float); void MocGrowBisection(CtrlType *, GraphType *, float *, float); void MocRandomBisection(CtrlType *, GraphType *, float *, float); void MocInit2WayBalance(CtrlType *, GraphType *, float *); idxtype SelectQueueOneWay(idxtype ncon, float *npwgts, float *tpwgts, idxtype from, PQueueType queues[MAXNCON][2]); /* minitpart2.c */ void MocInit2WayPartition2(CtrlType *, GraphType *, float *, float *); void MocGrowBisection2(CtrlType *, GraphType *, float *, float *); void MocGrowBisectionNew2(CtrlType *, GraphType *, float *, float *); void MocInit2WayBalance2(CtrlType *, GraphType *, float *, float *); idxtype SelectQueueOneWay2(idxtype ncon, float *pto, PQueueType queues[MAXNCON][2], float *ubvec); /* mkmetis.c */ idxtype MCMlevelKWayPartitioning(CtrlType *, GraphType *, idxtype, idxtype *, float *); /* mkwayfmh.c */ void MCRandom_KWayEdgeRefineHorizontal(CtrlType *, GraphType *, idxtype, float *, idxtype); void MCGreedy_KWayEdgeBalanceHorizontal(CtrlType *, GraphType *, idxtype, float *, idxtype); idxtype AreAllHVwgtsBelow(idxtype, float, float *, float, float *, float *); idxtype AreAllHVwgtsAbove(idxtype, float, float *, float, float *, float *); void ComputeHKWayLoadImbalance(idxtype, idxtype, float *, float *); idxtype MocIsHBalanced(idxtype, idxtype, float *, float *); idxtype IsHBalanceBetterFT(idxtype, idxtype, float *, float *, float *, float *); idxtype IsHBalanceBetterTT(idxtype, idxtype, float *, float *, float *, float *); /* mkwayrefine.c */ void MocRefineKWayHorizontal(CtrlType *, GraphType *, GraphType *, idxtype, float *); void MocAllocateKWayPartitionMemory(CtrlType *, GraphType *, idxtype); void MocComputeKWayPartitionParams(CtrlType *, GraphType *, idxtype); void MocProjectKWayPartition(CtrlType *, GraphType *, idxtype); void MocComputeKWayBalanceBoundary(CtrlType *, GraphType *, idxtype); /* mmatch.c */ void MCMatch_RM(CtrlType *, GraphType *); void MCMatch_HEM(CtrlType *, GraphType *); void MCMatch_SHEM(CtrlType *, GraphType *); void MCMatch_SHEBM(CtrlType *, GraphType *, idxtype); void MCMatch_SBHEM(CtrlType *, GraphType *, idxtype); float BetterVBalance(idxtype, idxtype, float *, float *, float *); idxtype AreAllVwgtsBelowFast(idxtype, float *, float *, float); /* mmd.c */ void genmmd(idxtype, idxtype *, idxtype *, idxtype *, idxtype *, idxtype , idxtype *, idxtype *, idxtype *, idxtype *, idxtype, idxtype *); void mmdelm(idxtype, idxtype *xadj, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype, idxtype); idxtype mmdint(idxtype, idxtype *xadj, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); void mmdnum(idxtype, idxtype *, idxtype *, idxtype *); void mmdupd(idxtype, idxtype, idxtype *, idxtype *, idxtype, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype, idxtype *tag); /* mpmetis.c */ idxtype MCMlevelRecursiveBisection(CtrlType *, GraphType *, idxtype, idxtype *, float, idxtype); idxtype MCHMlevelRecursiveBisection(CtrlType *, GraphType *, idxtype, idxtype *, float *, idxtype); void MCMlevelEdgeBisection(CtrlType *, GraphType *, float *, float); void MCHMlevelEdgeBisection(CtrlType *, GraphType *, float *, float *); /* mrefine.c */ void MocRefine2Way(CtrlType *, GraphType *, GraphType *, float *, float); void MocAllocate2WayPartitionMemory(CtrlType *, GraphType *); void MocCompute2WayPartitionParams(CtrlType *, GraphType *); void MocProject2WayPartition(CtrlType *, GraphType *); /* mrefine2.c */ void MocRefine2Way2(CtrlType *, GraphType *, GraphType *, float *, float *); /* mutil.c */ idxtype AreAllVwgtsBelow(idxtype, float, float *, float, float *, float); idxtype AreAnyVwgtsBelow(idxtype, float, float *, float, float *, float); idxtype AreAllVwgtsAbove(idxtype, float, float *, float, float *, float); float ComputeLoadImbalance(idxtype, idxtype, float *, float *); idxtype AreAllBelow(idxtype, float *, float *); /* myqsort.c */ void iidxsort(size_t, idxtype *); void ikeysort(size_t, KeyValueType *); void ikeyvalsort(size_t, KeyValueType *); void idkeysort(size_t, DKeyValueType *); /* ometis.c */ void MlevelNestedDissection(CtrlType *, GraphType *, idxtype *, float, idxtype); void MlevelNestedDissectionCC(CtrlType *, GraphType *, idxtype *, float, idxtype); void MlevelNodeBisectionMultiple(CtrlType *, GraphType *, idxtype *, float); void MlevelNodeBisection(CtrlType *, GraphType *, idxtype *, float); void SplitGraphOrder(CtrlType *, GraphType *, GraphType *, GraphType *); void MMDOrder(CtrlType *, GraphType *, idxtype *, idxtype); idxtype SplitGraphOrderCC(CtrlType *, GraphType *, GraphType *, idxtype, idxtype *, idxtype *); /* parmetis.c */ void MlevelNestedDissectionP(CtrlType *, GraphType *, idxtype *, idxtype, idxtype, idxtype, idxtype *); /* pmetis.c */ idxtype MlevelRecursiveBisection(CtrlType *, GraphType *, idxtype, idxtype *, float *, float, idxtype); void MlevelEdgeBisection(CtrlType *, GraphType *, idxtype *, float); void SplitGraphPart(CtrlType *, GraphType *, GraphType *, GraphType *); void SetUpSplitGraph(GraphType *, GraphType *, idxtype, idxtype); /* pqueue.c */ void PQueueInit(CtrlType *ctrl, PQueueType *, idxtype, idxtype); void PQueueReset(PQueueType *); void PQueueFree(CtrlType *ctrl, PQueueType *); idxtype PQueueGetSize(PQueueType *); idxtype PQueueInsert(PQueueType *, idxtype, idxtype); idxtype PQueueDelete(PQueueType *, idxtype, idxtype); idxtype PQueueUpdate(PQueueType *, idxtype, idxtype, idxtype); void PQueueUpdateUp(PQueueType *, idxtype, idxtype, idxtype); idxtype PQueueGetMax(PQueueType *); idxtype PQueueSeeMax(PQueueType *); idxtype PQueueGetKey(PQueueType *); idxtype CheckHeap(PQueueType *); /* refine.c */ void Refine2Way(CtrlType *, GraphType *, GraphType *, idxtype *, float ubfactor); void Allocate2WayPartitionMemory(CtrlType *, GraphType *); void Compute2WayPartitionParams(CtrlType *, GraphType *); void Project2WayPartition(CtrlType *, GraphType *); /* separator.c */ void ConstructSeparator(CtrlType *, GraphType *, float); void ConstructMinCoverSeparator0(CtrlType *, GraphType *, float); void ConstructMinCoverSeparator(CtrlType *, GraphType *, float); /* sfm.c */ void FM_2WayNodeRefine(CtrlType *, GraphType *, float, idxtype); void FM_2WayNodeRefineEqWgt(CtrlType *, GraphType *, idxtype); void FM_2WayNodeRefine_OneSided(CtrlType *, GraphType *, float, idxtype); void FM_2WayNodeBalance(CtrlType *, GraphType *, float); idxtype ComputeMaxNodeGain(idxtype, idxtype *, idxtype *, idxtype *); /* srefine.c */ void Refine2WayNode(CtrlType *, GraphType *, GraphType *, float); void Allocate2WayNodePartitionMemory(CtrlType *, GraphType *); void Compute2WayNodePartitionParams(CtrlType *, GraphType *); void Project2WayNodePartition(CtrlType *, GraphType *); /* stat.c */ void ComputePartitionInfo(GraphType *, idxtype, idxtype *); void ComputePartitionInfoBipartite(GraphType *, idxtype, idxtype *); void ComputePartitionBalance(GraphType *, idxtype, idxtype *, float *); float ComputeElementBalance(idxtype, idxtype, idxtype *); /* subdomains.c */ void Random_KWayEdgeRefineMConn(CtrlType *, GraphType *, idxtype, float *, float, idxtype, idxtype); void Greedy_KWayEdgeBalanceMConn(CtrlType *, GraphType *, idxtype, float *, float, idxtype); void PrintSubDomainGraph(GraphType *, idxtype, idxtype *); void ComputeSubDomainGraph(GraphType *, idxtype, idxtype *, idxtype *); void EliminateSubDomainEdges(CtrlType *, GraphType *, idxtype, float *); void MoveGroupMConn(CtrlType *, GraphType *, idxtype *, idxtype *, idxtype, idxtype, idxtype, idxtype *); void EliminateComponents(CtrlType *, GraphType *, idxtype, float *, float); void MoveGroup(CtrlType *, GraphType *, idxtype, idxtype, idxtype, idxtype *, idxtype *); /* timing.c */ void InitTimers(CtrlType *); void PrintTimers(CtrlType *); /* util.c */ GK_XMALLOC_PROTO(idxmalloc, idxtype) GK_XREALLOC_PROTO(idxrealloc, idxtype) GK_XSMALLOC_PROTO(idxsmalloc, idxtype) GK_SET_PROTO(idxset, idxtype) GK_ARGMAX_PROTO(idxargmax, idxtype) GK_ARGMIN_PROTO(idxargmin, idxtype) GK_SUM_PROTO(idxsum, idxtype, idxtype) GK_AXPY_PROTO(idxaxpy, idxtype) idxtype idxargmax_strd(size_t, idxtype *, idxtype); idxtype famax2(size_t, float *); void RandomPermute(size_t, idxtype *, idxtype); void InitRandom(idxtype); idxtype strtoidx(const char *nptr, char **endptr, int base); /*************************************************************** * Programs Directory ****************************************************************/ /* smbfactor.c */ void ComputeFillIn(GraphType *, idxtype *); idxtype ComputeFillIn2(GraphType *, idxtype *); idxtype smbfct(idxtype, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *, idxtype *); /* kfmetis.c */ void BalanceFillIn(CtrlType *ctrl, GraphType *graph, idxtype nparts, idxtype *part); GraphType *ExtractPartitionGraph(GraphType *graph, idxtype *part, idxtype pid, idxtype *vmap, idxtype *vimap); void ComputePartitionFillIn(CtrlType *ctrl, GraphType *graph, idxtype nparts, idxtype *part, idxtype *spart, idxtype pid, idxtype *r_fill, idxtype *r_subfill); void RefineTopLevelSeparators(CtrlType *ctrl, GraphType *graph, idxtype nparts, idxtype *part, idxtype *spart, idxtype *, idxtype *, idxtype *, idxtype *); /* rkmetis.c */ void METIS_RefineGraphKway(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, idxtype *options, idxtype *edgecut, idxtype *part); void METIS_WRefineGraphKway(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *tpwgts, idxtype *options, idxtype *edgecut, idxtype *part); idxtype MlevelKWayRefinement(CtrlType *ctrl, GraphType *graph, idxtype nparts, idxtype *part, float *tpwgts, float ubfactor); /* cmetis.c */ void *METIS_PartGraphForContact(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, double *xyzcoords, idxtype *sflag, idxtype *numflag, idxtype *nparts, idxtype *options, idxtype *edgecut, idxtype *part); void METIS_UpdateContactInfo(void *raw_cinfo, idxtype *nvtxs, double *xyzcoords, idxtype *sflag); void *METIS_SetupContact0(idxtype *nvtxs, double *xyzcoords, idxtype *sflag, idxtype *nparts, idxtype *part); void *METIS_SetupContact(idxtype *nvtxs, double *xyzcoords, idxtype *sflag, idxtype *nparts, idxtype *part); void METIS_FindContacts(void *raw_cinfo, idxtype *nboxes, double *boxcoords, idxtype *nparts, idxtype **r_cntptr, idxtype **r_cntind); void METIS_FreeContactInfo(void *raw_cinfo); GraphType *CreatePartitionGraphForContact(idxtype nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype cnvtxs, idxtype *part); idxtype InduceDecissionTree(idxtype nvtxs, DKeyValueType **xyzcand, idxtype *sflag, idxtype nparts, idxtype *part, idxtype maxnvtxs, idxtype minnvtxs, float minfrac, idxtype *r_nnodes, idxtype *r_nlnodes, DTreeNodeType *dtree, idxtype *dtpart, idxtype *dtipart, idxtype *r_nclean, idxtype *r_naclean, idxtype *r_ndirty, idxtype *r_maxdepth, idxtype *marker); idxtype FindBoxContacts(ContactInfoType *cinfo, double *coords, idxtype *stack, idxtype *cntind, idxtype *marker); void BuildDTLeafContents(ContactInfoType *cinfo, idxtype *sflag); void CheckDTree(idxtype nvtxs, double *xyzcoords, idxtype *part, ContactInfoType *cinfo); void CheckDTreeSurface(idxtype nvtxs, double *xyzcoords, idxtype *part, ContactInfoType *cinfo, idxtype *sflag); void *METIS_PartSurfForContactRCB(idxtype *nvtxs, double *xyzcoords, idxtype *sflag, idxtype *nparts, idxtype *part, idxtype *bestdims); idxtype InduceRCBTree(idxtype nvtxs, DKeyValueType **xyzcand, idxtype firstPID, idxtype nparts, idxtype *r_nnodes, idxtype *r_nlnodes, DTreeNodeType *dtree, idxtype *leafpart, idxtype *part, idxtype *marker, idxtype *oldBestDims); /* mrkmetis.c */ void METIS_mCRefineGraphKway(idxtype *nvtxs, idxtype *ncon, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *rubvec, idxtype *options, idxtype *edgecut, idxtype *part); idxtype MCMlevelKWayRefinement(CtrlType *ctrl, GraphType *graph, idxtype nparts, idxtype *part, float *rubvec); /* streamio.c */ int mprintf(char *format,...); int msprintf(char *str, char *format,...); int mfprintf(FILE *stream, char *format,...); int mscanf(char *format,...); int msscanf(char *str, char *format,...); int mfscanf(FILE *stream, char *format,...); #endif PyMetis-0.90/src/metis/refine.c0000640000175000017500000001275110662171744016206 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * refine.c * * This file contains the driving routines for multilevel refinement * * Started 7/24/97 * George * * $Id: refine.c,v 1.2 2002/08/10 06:29:34 karypis Exp $ */ #include /************************************************************************* * This function is the entry point of refinement **************************************************************************/ void Refine2Way(CtrlType *ctrl, GraphType *orggraph, GraphType *graph, idxtype *tpwgts, float ubfactor) { IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->UncoarsenTmr)); /* Compute the parameters of the coarsest graph */ Compute2WayPartitionParams(ctrl, graph); for (;;) { ASSERT(CheckBnd(graph)); IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->RefTmr)); switch (ctrl->RType) { case 1: Balance2Way(ctrl, graph, tpwgts, ubfactor); FM_2WayEdgeRefine(ctrl, graph, tpwgts, 8); break; default: errexit("Unknown refinement type: %d\n", ctrl->RType); } IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->RefTmr)); if (graph == orggraph) break; graph = graph->finer; IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->ProjectTmr)); Project2WayPartition(ctrl, graph); IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->ProjectTmr)); } IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->UncoarsenTmr)); } /************************************************************************* * This function allocates memory for 2-way edge refinement **************************************************************************/ void Allocate2WayPartitionMemory(CtrlType *ctrl, GraphType *graph) { idxtype nvtxs; nvtxs = graph->nvtxs; graph->pwgts = idxmalloc(2, "Allocate2WayPartitionMemory: pwgts"); graph->where = idxmalloc(nvtxs, "Allocate2WayPartitionMemory: where"); graph->id = idxmalloc(nvtxs, "Allocate2WayPartitionMemory: id"); graph->ed = idxmalloc(nvtxs, "Allocate2WayPartitionMemory: ed"); graph->bndptr = idxmalloc(nvtxs, "Allocate2WayPartitionMemory: bndptr"); graph->bndind = idxmalloc(nvtxs, "Allocate2WayPartitionMemory: bndind"); } /************************************************************************* * This function computes the initial id/ed **************************************************************************/ void Compute2WayPartitionParams(CtrlType *ctrl, GraphType *graph) { idxtype i, j, k, l, nvtxs, nbnd, mincut; idxtype *xadj, *vwgt, *adjncy, *adjwgt, *pwgts; idxtype *id, *ed, *where; idxtype *bndptr, *bndind; idxtype me, other; nvtxs = graph->nvtxs; xadj = graph->xadj; vwgt = graph->vwgt; adjncy = graph->adjncy; adjwgt = graph->adjwgt; where = graph->where; pwgts = idxset(2, 0, graph->pwgts); id = idxset(nvtxs, 0, graph->id); ed = idxset(nvtxs, 0, graph->ed); bndptr = idxset(nvtxs, -1, graph->bndptr); bndind = graph->bndind; /*------------------------------------------------------------ / Compute now the id/ed degrees /------------------------------------------------------------*/ nbnd = mincut = 0; for (i=0; i= 0 && where[i] <= 1); me = where[i]; pwgts[me] += vwgt[i]; for (j=xadj[i]; j 0 || xadj[i] == xadj[i+1]) { mincut += ed[i]; bndptr[i] = nbnd; bndind[nbnd++] = i; } } graph->mincut = mincut/2; graph->nbnd = nbnd; ASSERT(pwgts[0]+pwgts[1] == idxsum(nvtxs, vwgt)); } /************************************************************************* * This function projects a partition, and at the same time computes the * parameters for refinement. **************************************************************************/ void Project2WayPartition(CtrlType *ctrl, GraphType *graph) { idxtype i, j, k, nvtxs, nbnd, me; idxtype *xadj, *adjncy, *adjwgt, *adjwgtsum; idxtype *cmap, *where, *id, *ed, *bndptr, *bndind; idxtype *cwhere, *cid, *ced, *cbndptr; GraphType *cgraph; cgraph = graph->coarser; cwhere = cgraph->where; cid = cgraph->id; ced = cgraph->ed; cbndptr = cgraph->bndptr; nvtxs = graph->nvtxs; cmap = graph->cmap; xadj = graph->xadj; adjncy = graph->adjncy; adjwgt = graph->adjwgt; adjwgtsum = graph->adjwgtsum; Allocate2WayPartitionMemory(ctrl, graph); where = graph->where; id = idxset(nvtxs, 0, graph->id); ed = idxset(nvtxs, 0, graph->ed); bndptr = idxset(nvtxs, -1, graph->bndptr); bndind = graph->bndind; /* Go through and project partition and compute id/ed for the nodes */ for (i=0; i 0 || xadj[i] == xadj[i+1]) { bndptr[i] = nbnd; bndind[nbnd++] = i; } } } } graph->mincut = cgraph->mincut; graph->nbnd = nbnd; idxcopy(2, cgraph->pwgts, graph->pwgts); FreeGraph(graph->coarser, 1); graph->coarser = NULL; } PyMetis-0.90/src/metis/rename.h0000640000175000017500000003252310662171744016211 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * rename.h * * This file contains header files * * Started 10/2/97 * George * * $Id: rename.h,v 1.1 2002/08/10 04:34:09 karypis Exp $ * */ /*#define _RENAME_H_*/ #ifndef _RENAME_H_ #define _RENAME_H_ /* balance.c */ #define Balance2Way libmetis__Balance2Way #define Bnd2WayBalance libmetis__Bnd2WayBalance #define General2WayBalance libmetis__General2WayBalance /* bucketsort.c */ #define BucketSortKeysInc libmetis__BucketSortKeysInc /* ccgraph.c */ #define CreateCoarseGraph libmetis__CreateCoarseGraph #define CreateCoarseGraphNoMask libmetis__CreateCoarseGraphNoMask #define CreateCoarseGraph_NVW libmetis__CreateCoarseGraph_NVW #define SetUpCoarseGraph libmetis__SetUpCoarseGraph #define ReAdjustMemory libmetis__ReAdjustMemory /* coarsen.c */ #define Coarsen2Way libmetis__Coarsen2Way /* compress.c */ #define CompressGraph libmetis__CompressGraph #define PruneGraph libmetis__PruneGraph /* debug.c */ #define ComputeCut libmetis__ComputeCut #define CheckBnd libmetis__CheckBnd #define CheckBnd2 libmetis__CheckBnd2 #define CheckNodeBnd libmetis__CheckNodeBnd #define CheckRInfo libmetis__CheckRInfo #define CheckNodePartitionParams libmetis__CheckNodePartitionParams #define IsSeparable libmetis__IsSeparable /* estmem.c */ #define EstimateCFraction libmetis__EstimateCFraction #define ComputeCoarseGraphSize libmetis__ComputeCoarseGraphSize /* fm.c */ #define FM_2WayEdgeRefine libmetis__FM_2WayEdgeRefine /* fortran.c */ #define Change2CNumbering libmetis__Change2CNumbering #define Change2FNumbering libmetis__Change2FNumbering #define Change2FNumbering2 libmetis__Change2FNumbering2 #define Change2FNumberingOrder libmetis__Change2FNumberingOrder #define ChangeMesh2CNumbering libmetis__ChangeMesh2CNumbering #define ChangeMesh2FNumbering libmetis__ChangeMesh2FNumbering #define ChangeMesh2FNumbering2 libmetis__ChangeMesh2FNumbering2 /* graph.c */ #define SetUpGraph libmetis__SetUpGraph #define SetUpGraph2 libmetis__SetUpGraph2 #define VolSetUpGraph libmetis__VolSetUpGraph #define RandomizeGraph libmetis__RandomizeGraph #define IsConnectedSubdomain libmetis__IsConnectedSubdomain #define IsConnected libmetis__IsConnected #define IsConnected2 libmetis__IsConnected2 #define FindComponents libmetis__FindComponents /* initpart.c */ #define Init2WayPartition libmetis__Init2WayPartition #define InitSeparator libmetis__InitSeparator #define GrowBisection libmetis__GrowBisection #define GrowBisectionNode libmetis__GrowBisectionNode #define RandomBisection libmetis__RandomBisection /* kmetis.c */ #define MlevelKWayPartitioning libmetis__MlevelKWayPartitioning /* kvmetis.c */ #define MlevelVolKWayPartitioning libmetis__MlevelVolKWayPartitioning /* kwayfm.c */ #define Random_KWayEdgeRefine libmetis__Random_KWayEdgeRefine #define Greedy_KWayEdgeRefine libmetis__Greedy_KWayEdgeRefine #define Greedy_KWayEdgeBalance libmetis__Greedy_KWayEdgeBalance /* kwayrefine.c */ #define RefineKWay libmetis__RefineKWay #define AllocateKWayPartitionMemory libmetis__AllocateKWayPartitionMemory #define ComputeKWayPartitionParams libmetis__ComputeKWayPartitionParams #define ProjectKWayPartition libmetis__ProjectKWayPartition #define IsBalanced libmetis__IsBalanced #define ComputeKWayBoundary libmetis__ComputeKWayBoundary #define ComputeKWayBalanceBoundary libmetis__ComputeKWayBalanceBoundary /* kwayvolfm.c */ #define Random_KWayVolRefine libmetis__Random_KWayVolRefine #define Random_KWayVolRefineMConn libmetis__Random_KWayVolRefineMConn #define Greedy_KWayVolBalance libmetis__Greedy_KWayVolBalance #define Greedy_KWayVolBalanceMConn libmetis__Greedy_KWayVolBalanceMConn #define KWayVolUpdate libmetis__KWayVolUpdate #define ComputeKWayVolume libmetis__ComputeKWayVolume #define ComputeVolume libmetis__ComputeVolume #define CheckVolKWayPartitionParams libmetis__CheckVolKWayPartitionParams #define ComputeVolSubDomainGraph libmetis__ComputeVolSubDomainGraph #define EliminateVolSubDomainEdges libmetis__EliminateVolSubDomainEdges /* kwayvolrefine.c */ #define RefineVolKWay libmetis__RefineVolKWay #define AllocateVolKWayPartitionMemory libmetis__AllocateVolKWayPartitionMemory #define ComputeVolKWayPartitionParams libmetis__ComputeVolKWayPartitionParams #define ComputeKWayVolGains libmetis__ComputeKWayVolGains #define ProjectVolKWayPartition libmetis__ProjectVolKWayPartition #define ComputeVolKWayBoundary libmetis__ComputeVolKWayBoundary #define ComputeVolKWayBalanceBoundary libmetis__ComputeVolKWayBalanceBoundary /* match.c */ #define Match_RM libmetis__Match_RM #define Match_RM_NVW libmetis__Match_RM_NVW #define Match_HEM libmetis__Match_HEM #define Match_SHEM libmetis__Match_SHEM /* mbalance.c */ #define MocBalance2Way libmetis__MocBalance2Way #define MocGeneral2WayBalance libmetis__MocGeneral2WayBalance /* mbalance2.c */ #define MocBalance2Way2 libmetis__MocBalance2Way2 #define MocGeneral2WayBalance2 libmetis__MocGeneral2WayBalance2 #define SelectQueue3 libmetis__SelectQueue3 /* mcoarsen.c */ #define MCCoarsen2Way libmetis__MCCoarsen2Way /* memory.c */ #define AllocateWorkSpace libmetis__AllocateWorkSpace #define FreeWorkSpace libmetis__FreeWorkSpace #define WspaceAvail libmetis__WspaceAvail #define idxwspacemalloc libmetis__idxwspacemalloc #define idxwspacefree libmetis__idxwspacefree #define fwspacemalloc libmetis__fwspacemalloc #define CreateGraph libmetis__CreateGraph #define InitGraph libmetis__InitGraph #define FreeRData libmetis__FreeRData #define FreeGraph libmetis__FreeGraph /* mesh.c */ #define TRIDUALMETIS libmetis__TRIDUALMETIS #define TETDUALMETIS libmetis__TETDUALMETIS #define HEXDUALMETIS libmetis__HEXDUALMETIS #define TRINODALMETIS libmetis__TRINODALMETIS #define TETNODALMETIS libmetis__TETNODALMETIS #define HEXNODALMETIS libmetis__HEXNODALMETIS /* mfm.c */ #define MocFM_2WayEdgeRefine libmetis__MocFM_2WayEdgeRefine #define SelectQueue libmetis__SelectQueue #define BetterBalance libmetis__BetterBalance #define Compute2WayHLoadImbalance libmetis__Compute2WayHLoadImbalance #define Compute2WayHLoadImbalanceVec libmetis__Compute2WayHLoadImbalanceVec /* mfm2.c */ #define MocFM_2WayEdgeRefine2 libmetis__MocFM_2WayEdgeRefine2 #define SelectQueue2 libmetis__SelectQueue2 #define IsBetter2wayBalance libmetis__IsBetter2wayBalance /* mincover.c */ #define MinCover libmetis__MinCover #define MinCover_Augment libmetis__MinCover_Augment #define MinCover_Decompose libmetis__MinCover_Decompose #define MinCover_ColDFS libmetis__MinCover_ColDFS #define MinCover_RowDFS libmetis__MinCover_RowDFS /* minitpart.c */ #define MocInit2WayPartition libmetis__MocInit2WayPartition #define MocGrowBisection libmetis__MocGrowBisection #define MocRandomBisection libmetis__MocRandomBisection #define MocInit2WayBalance libmetis__MocInit2WayBalance #define SelectQueueoneWay libmetis__SelectQueueoneWay /* minitpart2.c */ #define MocInit2WayPartition2 libmetis__MocInit2WayPartition2 #define MocGrowBisection2 libmetis__MocGrowBisection2 #define MocGrowBisectionNew2 libmetis__MocGrowBisectionNew2 #define MocInit2WayBalance2 libmetis__MocInit2WayBalance2 #define SelectQueueOneWay2 libmetis__SelectQueueOneWay2 /* mkmetis.c */ #define MCMlevelKWayPartitioning libmetis__MCMlevelKWayPartitioning /* mkwayfmh.c */ #define MCRandom_KWayEdgeRefineHorizontal libmetis__MCRandom_KWayEdgeRefineHorizontal #define MCGreedy_KWayEdgeBalanceHorizontal libmetis__MCGreedy_KWayEdgeBalanceHorizontal #define AreAllHVwgtsBelow libmetis__AreAllHVwgtsBelow #define AreAllHVwgtsAbove libmetis__AreAllHVwgtsAbove #define ComputeHKWayLoadImbalance libmetis__ComputeHKWayLoadImbalance #define MocIsHBalanced libmetis__MocIsHBalanced #define IsHBalanceBetterFT libmetis__IsHBalanceBetterFT #define IsHBalanceBetterTT libmetis__IsHBalanceBetterTT /* mkwayrefine.c */ #define MocRefineKWayHorizontal libmetis__MocRefineKWayHorizontal #define MocAllocateKWayPartitionMemory libmetis__MocAllocateKWayPartitionMemory #define MocComputeKWayPartitionParams libmetis__MocComputeKWayPartitionParams #define MocProjectKWayPartition libmetis__MocProjectKWayPartition #define MocComputeKWayBalanceBoundary libmetis__MocComputeKWayBalanceBoundary /* mmatch.c */ #define MCMatch_RM libmetis__MCMatch_RM #define MCMatch_HEM libmetis__MCMatch_HEM #define MCMatch_SHEM libmetis__MCMatch_SHEM #define MCMatch_SHEBM libmetis__MCMatch_SHEBM #define MCMatch_SBHEM libmetis__MCMatch_SBHEM #define BetterVBalance libmetis__BetterVBalance #define AreAllVwgtsBelowFast libmetis__AreAllVwgtsBelowFast /* mmd.c */ #define genmmd libmetis__genmmd #define mmdelm libmetis__mmdelm #define mmdint libmetis__mmdint #define mmdnum libmetis__mmdnum #define mmdupd libmetis__mmdupd /* mpmetis.c */ #define MCMlevelRecursiveBisection libmetis__MCMlevelRecursiveBisection #define MCHMlevelRecursiveBisection libmetis__MCHMlevelRecursiveBisection #define MCMlevelEdgeBisection libmetis__MCMlevelEdgeBisection #define MCHMlevelEdgeBisection libmetis__MCHMlevelEdgeBisection /* mrefine.c */ #define MocRefine2Way libmetis__MocRefine2Way #define MocAllocate2WayPartitionMemory libmetis__MocAllocate2WayPartitionMemory #define MocCompute2WayPartitionParams libmetis__MocCompute2WayPartitionParams #define MocProject2WayPartition libmetis__MocProject2WayPartition /* mrefine2.c */ #define MocRefine2Way2 libmetis__MocRefine2Way2 /* mutil.c */ #define AreAllVwgtsBelow libmetis__AreAllVwgtsBelow #define AreAnyVwgtsBelow libmetis__AreAnyVwgtsBelow #define AreAllVwgtsAbove libmetis__AreAllVwgtsAbove #define ComputeLoadImbalance libmetis__ComputeLoadImbalance #define AreAllBelow libmetis__AreAllBelow /* myqsort.c */ #define iidxsort libmetis__iidxsort #define ikeysort libmetis__ikeysort #define ikeyvalsort libmetis__ikeyvalsort #define idkeysort libmetis__idkeysort /* ometis.c */ #define MlevelNestedDissection libmetis__MlevelNestedDissection #define MlevelNestedDissectionCC libmetis__MlevelNestedDissectionCC #define MlevelNodeBisectionMultiple libmetis__MlevelNodeBisectionMultiple #define MlevelNodeBisection libmetis__MlevelNodeBisection #define SplitGraphOrder libmetis__SplitGraphOrder #define MMDOrder libmetis__MMDOrder #define SplitGraphOrderCC libmetis__SplitGraphOrderCC /* parmetis.c */ #define MlevelNestedDissectionP libmetis__MlevelNestedDissectionP /* pmetis.c */ #define MlevelRecursiveBisection libmetis__MlevelRecursiveBisection #define MlevelEdgeBisection libmetis__MlevelEdgeBisection #define SplitGraphPart libmetis__SplitGraphPart #define SetUpSplitGraph libmetis__SetUpSplitGraph /* pqueue.c */ #define PQueueInit libmetis__PQueueInit #define PQueueReset libmetis__PQueueReset #define PQueueFree libmetis__PQueueFree #define PQueueInsert libmetis__PQueueInsert #define PQueueDelete libmetis__PQueueDelete #define PQueueUpdate libmetis__PQueueUpdate #define PQueueUpdateUp libmetis__PQueueUpdateUp #define PQueueGetMax libmetis__PQueueGetMax #define PQueueSeeMax libmetis__PQueueSeeMax #define CheckHeap libmetis__CheckHeap /* refine.c */ #define Refine2Way libmetis__Refine2Way #define Allocate2WayPartitionMemory libmetis__Allocate2WayPartitionMemory #define Compute2WayPartitionParams libmetis__Compute2WayPartitionParams #define Project2WayPartition libmetis__Project2WayPartition /* separator.c */ #define ConstructSeparator libmetis__ConstructSeparator #define ConstructMinCoverSeparator0 libmetis__ConstructMinCoverSeparator0 #define ConstructMinCoverSeparator libmetis__ConstructMinCoverSeparator /* sfm.c */ #define FM_2WayNodeRefine libmetis__FM_2WayNodeRefine #define FM_2WayNodeRefineEqWgt libmetis__FM_2WayNodeRefineEqWgt #define FM_2WayNodeRefine_OneSided libmetis__FM_2WayNodeRefine_OneSided #define FM_2WayNodeBalance libmetis__FM_2WayNodeBalance #define ComputeMaxNodeGain libmetis__ComputeMaxNodeGain /* srefine.c */ #define Refine2WayNode libmetis__Refine2WayNode #define Allocate2WayNodePartitionMemory libmetis__Allocate2WayNodePartitionMemory #define Compute2WayNodePartitionParams libmetis__Compute2WayNodePartitionParams #define Project2WayNodePartition libmetis__Project2WayNodePartition /* stat.c */ #define ComputePartitionInfo libmetis__ComputePartitionInfo #define ComputePartitionBalance libmetis__ComputePartitionBalance #define ComputeElementBalance libmetis__ComputeElementBalance /* subdomains.c */ #define Random_KWayEdgeRefineMConn libmetis__Random_KWayEdgeRefineMConn #define Greedy_KWayEdgeBalanceMConn libmetis__Greedy_KWayEdgeBalanceMConn #define PrintSubDomainGraph libmetis__PrintSubDomainGraph #define ComputeSubDomainGraph libmetis__ComputeSubDomainGraph #define EliminateSubDomainEdges libmetis__EliminateSubDomainEdges #define MoveGroupMConn libmetis__MoveGroupMConn #define EliminateComponents libmetis__EliminateComponents #define MoveGroup libmetis__MoveGroup /* timing.c */ #define InitTimers libmetis__InitTimers #define PrintTimers libmetis__PrintTimers /* util.c */ #define idxmalloc libmetis__idxmalloc #define idxsmalloc libmetis__idxsmalloc #define idxset libmetis__idxset #define idxargmax libmetis__idxargmax #define idxargmin libmetis__idxargmin #define idxsum libmetis__idxsum #define idxaxpy libmetis__idxaxpy #define idxargmax_strd libmetis__idxargmax_strd #define famax2 libmetis__famax2 #define RandomPermute libmetis__RandomPermute #define InitRandom libmetis__InitRandom #endif PyMetis-0.90/src/metis/rkmetis.c0000640000175000017500000000737610662171744016423 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * kmetis.c * * This file contains the top level routines for the multilevel k-way partitioning * algorithm KMETIS. * * Started 7/28/97 * George * * $Id: rkmetis.c,v 1.3 2003/04/01 05:09:37 karypis Exp $ * */ #include /************************************************************************* * This function is the entry point for KMETIS **************************************************************************/ void METIS_RefineGraphKway(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, idxtype *options, idxtype *edgecut, idxtype *part) { idxtype i; float *tpwgts; tpwgts = gk_fmalloc(*nparts, "KMETIS: tpwgts"); for (i=0; i<*nparts; i++) tpwgts[i] = 1.0/(1.0*(*nparts)); METIS_WRefineGraphKway(nvtxs, xadj, adjncy, vwgt, adjwgt, wgtflag, numflag, nparts, tpwgts, options, edgecut, part); gk_free((void **)&tpwgts, LTERM); } /************************************************************************* * This function is the entry point for KWMETIS **************************************************************************/ void METIS_WRefineGraphKway(idxtype *nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt, idxtype *adjwgt, idxtype *wgtflag, idxtype *numflag, idxtype *nparts, float *tpwgts, idxtype *options, idxtype *edgecut, idxtype *part) { idxtype i, j; GraphType graph; CtrlType ctrl; if (*numflag == 1) Change2CNumbering(*nvtxs, xadj, adjncy); SetUpGraph(&graph, OP_KMETIS, *nvtxs, 1, xadj, adjncy, vwgt, adjwgt, *wgtflag); if (options[0] == 0) { /* Use the default parameters */ ctrl.CType = KMETIS_CTYPE; ctrl.IType = KMETIS_ITYPE; ctrl.RType = KMETIS_RTYPE; ctrl.dbglvl = DBG_REFINE; ctrl.dbglvl = KMETIS_DBGLVL; } else { ctrl.CType = options[OPTION_CTYPE]; ctrl.IType = options[OPTION_ITYPE]; ctrl.RType = options[OPTION_RTYPE]; ctrl.dbglvl = options[OPTION_DBGLVL]; } ctrl.optype = OP_KMETIS; ctrl.CoarsenTo = amax((*nvtxs)/(40*gk_log2(*nparts)), 20*(*nparts)); ctrl.maxvwgt = 0; /* GK-MOD: Ensure that no coarsening will take place */ InitRandom(-1); AllocateWorkSpace(&ctrl, &graph, *nparts); IFSET(ctrl.dbglvl, DBG_TIME, InitTimers(&ctrl)); IFSET(ctrl.dbglvl, DBG_TIME, gk_startcputimer(ctrl.TotalTmr)); *edgecut = MlevelKWayRefinement(&ctrl, &graph, *nparts, part, tpwgts, 1.03); IFSET(ctrl.dbglvl, DBG_TIME, gk_stopcputimer(ctrl.TotalTmr)); IFSET(ctrl.dbglvl, DBG_TIME, PrintTimers(&ctrl)); FreeWorkSpace(&ctrl, &graph); if (*numflag == 1) Change2FNumbering(*nvtxs, xadj, adjncy, part); } /************************************************************************* * This function takes a graph and produces a bisection of it **************************************************************************/ idxtype MlevelKWayRefinement(CtrlType *ctrl, GraphType *graph, idxtype nparts, idxtype *part, float *tpwgts, float ubfactor) { idxtype i, j, nvtxs, tvwgt, tpwgts2[2]; GraphType *cgraph; idxtype wgtflag=3, numflag=0, options[10], edgecut; cgraph = Coarsen2Way(ctrl, graph); IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->InitPartTmr)); AllocateKWayPartitionMemory(ctrl, cgraph, nparts); if (cgraph->nvtxs != graph->nvtxs) errexit("GK-MOD Failed: %d %d\n", cgraph->nvtxs, graph->nvtxs); for (i=0; invtxs; i++) cgraph->where[graph->cmap[i]] = part[i]; RefineKWayRefinement(ctrl, graph, cgraph, nparts, tpwgts, ubfactor); idxcopy(graph->nvtxs, graph->where, part); FreeGraph(graph, 0); return graph->mincut; } PyMetis-0.90/src/metis/separator.c0000640000175000017500000002005610662171744016733 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * separator.c * * This file contains code for separator extraction * * Started 8/1/97 * George * * $Id: separator.c,v 1.2 2002/08/10 06:29:34 karypis Exp $ * */ #include /************************************************************************* * This function takes a bisection and constructs a minimum weight vertex * separator out of it. It uses the node-based separator refinement for it. **************************************************************************/ void ConstructSeparator(CtrlType *ctrl, GraphType *graph, float ubfactor) { idxtype i, j, k, nvtxs, nbnd; idxtype *xadj, *where, *bndind; nvtxs = graph->nvtxs; xadj = graph->xadj; nbnd = graph->nbnd; bndind = graph->bndind; where = idxcopy(nvtxs, graph->where, idxwspacemalloc(ctrl, nvtxs)); /* Put the nodes in the boundary into the separator */ for (i=0; i 0) /* Ignore islands */ where[j] = 2; } FreeRData(graph); Allocate2WayNodePartitionMemory(ctrl, graph); idxcopy(nvtxs, where, graph->where); idxwspacefree(ctrl, nvtxs); ASSERT(IsSeparable(graph)); Compute2WayNodePartitionParams(ctrl, graph); ASSERT(CheckNodePartitionParams(graph)); FM_2WayNodeRefine(ctrl, graph, ubfactor, 8); ASSERT(IsSeparable(graph)); } /************************************************************************* * This function takes a bisection and constructs a minimum weight vertex * separator out of it. It uses an unweighted minimum-cover algorithm * followed by node-based separator refinement. **************************************************************************/ void ConstructMinCoverSeparator0(CtrlType *ctrl, GraphType *graph, float ubfactor) { idxtype i, ii, j, jj, k, l, nvtxs, nbnd, bnvtxs[3], bnedges[2], csize; idxtype *xadj, *adjncy, *bxadj, *badjncy; idxtype *where, *bndind, *bndptr, *vmap, *ivmap, *cover; nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; nbnd = graph->nbnd; bndind = graph->bndind; bndptr = graph->bndptr; where = graph->where; vmap = idxwspacemalloc(ctrl, nvtxs); ivmap = idxwspacemalloc(ctrl, nbnd); cover = idxwspacemalloc(ctrl, nbnd); if (nbnd > 0) { /* Go through the boundary and determine the sizes of the bipartite graph */ bnvtxs[0] = bnvtxs[1] = bnedges[0] = bnedges[1] = 0; for (i=0; i 0) { bnvtxs[k]++; bnedges[k] += xadj[j+1]-xadj[j]; } } bnvtxs[2] = bnvtxs[0]+bnvtxs[1]; bnvtxs[1] = bnvtxs[0]; bnvtxs[0] = 0; bxadj = idxmalloc(bnvtxs[2]+1, "ConstructMinCoverSeparator: bxadj"); badjncy = idxmalloc(bnedges[0]+bnedges[1]+1, "ConstructMinCoverSeparator: badjncy"); /* Construct the ivmap and vmap */ ASSERT(idxset(nvtxs, -1, vmap) == vmap); for (i=0; i 0) { vmap[j] = bnvtxs[k]; ivmap[bnvtxs[k]++] = j; } } /* OK, go through and put the vertices of each part starting from 0 */ bnvtxs[1] = bnvtxs[0]; bnvtxs[0] = 0; bxadj[0] = l = 0; for (k=0; k<2; k++) { for (ii=0; iibndptr[jj])); badjncy[l++] = vmap[jj]; } } bxadj[++bnvtxs[k]] = l; } } } ASSERT(l <= bnedges[0]+bnedges[1]); MinCover(bxadj, badjncy, bnvtxs[0], bnvtxs[1], cover, &csize); IFSET(ctrl->dbglvl, DBG_SEPINFO, mprintf("Nvtxs: %6D, [%5D %5D], Cut: %6D, SS: [%6D %6D], Cover: %6D\n", nvtxs, graph->pwgts[0], graph->pwgts[1], graph->mincut, bnvtxs[0], bnvtxs[1]-bnvtxs[0], csize)); for (i=0; idbglvl, DBG_SEPINFO, mprintf("Nvtxs: %6D, [%5D %5D], Cut: %6D, SS: [%6D %6D], Cover: %6D\n", nvtxs, graph->pwgts[0], graph->pwgts[1], graph->mincut, 0, 0, 0)); } idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, graph->nbnd); idxwspacefree(ctrl, graph->nbnd); graph->nbnd = nbnd; ASSERT(IsSeparable(graph)); } /************************************************************************* * This function takes a bisection and constructs a minimum weight vertex * separator out of it. It uses an unweighted minimum-cover algorithm * followed by node-based separator refinement. **************************************************************************/ void ConstructMinCoverSeparator(CtrlType *ctrl, GraphType *graph, float ubfactor) { idxtype i, ii, j, jj, k, l, nvtxs, nbnd, bnvtxs[3], bnedges[2], csize; idxtype *xadj, *adjncy, *bxadj, *badjncy; idxtype *where, *bndind, *bndptr, *vmap, *ivmap, *cover; nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; nbnd = graph->nbnd; bndind = graph->bndind; bndptr = graph->bndptr; where = graph->where; vmap = idxwspacemalloc(ctrl, nvtxs); ivmap = idxwspacemalloc(ctrl, nbnd); cover = idxwspacemalloc(ctrl, nbnd); if (nbnd > 0) { /* Go through the boundary and determine the sizes of the bipartite graph */ bnvtxs[0] = bnvtxs[1] = bnedges[0] = bnedges[1] = 0; for (i=0; i 0) { bnvtxs[k]++; bnedges[k] += xadj[j+1]-xadj[j]; } } bnvtxs[2] = bnvtxs[0]+bnvtxs[1]; bnvtxs[1] = bnvtxs[0]; bnvtxs[0] = 0; bxadj = idxmalloc(bnvtxs[2]+1, "ConstructMinCoverSeparator: bxadj"); badjncy = idxmalloc(bnedges[0]+bnedges[1]+1, "ConstructMinCoverSeparator: badjncy"); /* Construct the ivmap and vmap */ ASSERT(idxset(nvtxs, -1, vmap) == vmap); for (i=0; i 0) { vmap[j] = bnvtxs[k]; ivmap[bnvtxs[k]++] = j; } } /* OK, go through and put the vertices of each part starting from 0 */ bnvtxs[1] = bnvtxs[0]; bnvtxs[0] = 0; bxadj[0] = l = 0; for (k=0; k<2; k++) { for (ii=0; iibndptr[jj])); badjncy[l++] = vmap[jj]; } } bxadj[++bnvtxs[k]] = l; } } } ASSERT(l <= bnedges[0]+bnedges[1]); MinCover(bxadj, badjncy, bnvtxs[0], bnvtxs[1], cover, &csize); IFSET(ctrl->dbglvl, DBG_SEPINFO, mprintf("Nvtxs: %6D, [%5D %5D], Cut: %6D, SS: [%6D %6D], Cover: %6D\n", nvtxs, graph->pwgts[0], graph->pwgts[1], graph->mincut, bnvtxs[0], bnvtxs[1]-bnvtxs[0], csize)); for (i=0; idbglvl, DBG_SEPINFO, mprintf("Nvtxs: %6D, [%5D %5D], Cut: %6D, SS: [%6D %6D], Cover: %6D\n", nvtxs, graph->pwgts[0], graph->pwgts[1], graph->mincut, 0, 0, 0)); } /* Prepare to refine the vertex separator */ idxcopy(nvtxs, graph->where, vmap); FreeRData(graph); Allocate2WayNodePartitionMemory(ctrl, graph); idxcopy(nvtxs, vmap, graph->where); idxwspacefree(ctrl, nvtxs+2*graph->nbnd); Compute2WayNodePartitionParams(ctrl, graph); ASSERT(CheckNodePartitionParams(graph)); FM_2WayNodeRefine_OneSided(ctrl, graph, ubfactor, 6); ASSERT(IsSeparable(graph)); } PyMetis-0.90/src/metis/sfm.c0000640000175000017500000010350110662171744015515 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * sfm.c * * This file contains code that implementes an FM-based separator refinement * * Started 8/1/97 * George * * $Id: sfm.c,v 1.3 2003/07/31 06:11:13 karypis Exp $ * */ #include /************************************************************************* * This function performs a node-based FM refinement **************************************************************************/ void FM_2WayNodeRefine(CtrlType *ctrl, GraphType *graph, float ubfactor, idxtype npasses) { idxtype i, ii, j, k, jj, kk, nvtxs, nbnd, nswaps, nmind; idxtype *xadj, *vwgt, *adjncy, *where, *pwgts, *edegrees, *bndind, *bndptr; idxtype *mptr, *mind, *moved, *swaps, *perm; PQueueType parts[2]; NRInfoType *rinfo; idxtype higain, oldgain, mincut, initcut, mincutorder; idxtype pass, to, other, limit; idxtype badmaxpwgt, mindiff, newdiff; idxtype u[2], g[2]; nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; vwgt = graph->vwgt; bndind = graph->bndind; bndptr = graph->bndptr; where = graph->where; pwgts = graph->pwgts; rinfo = graph->nrinfo; i = ComputeMaxNodeGain(nvtxs, xadj, adjncy, vwgt); PQueueInit(ctrl, &parts[0], nvtxs, i); PQueueInit(ctrl, &parts[1], nvtxs, i); moved = idxwspacemalloc(ctrl, nvtxs); swaps = idxwspacemalloc(ctrl, nvtxs); mptr = idxwspacemalloc(ctrl, nvtxs+1); mind = idxwspacemalloc(ctrl, nvtxs); perm = idxwspacemalloc(ctrl, nvtxs); IFSET(ctrl->dbglvl, DBG_REFINE, mprintf("Partitions: [%6D %6D] Nv-Nb[%6D %6D]. ISep: %6D\n", pwgts[0], pwgts[1], graph->nvtxs, graph->nbnd, graph->mincut)); badmaxpwgt = (int)(ubfactor*(pwgts[0]+pwgts[1]+pwgts[2])/2); for (pass=0; passmincut; nbnd = graph->nbnd; RandomPermute(nbnd, perm, 1); for (ii=0; iioflags&OFLAG_COMPRESS ? amin(5*nbnd, 400) : amin(2*nbnd, 300)); /****************************************************** * Get into the FM loop *******************************************************/ mptr[0] = nmind = 0; mindiff = idxtype_abs(pwgts[0]-pwgts[1]); to = (pwgts[0] < pwgts[1] ? 0 : 1); for (nswaps=0; nswaps g[1] ? 0 : (g[0] < g[1] ? 1 : pass%2)); /* to = (g[0] > g[1] ? 0 : (g[0] < g[1] ? 1 : (pwgts[0] < pwgts[1] ? 0 : 1))); */ if (pwgts[to]+vwgt[u[to]] > badmaxpwgt) to = (to+1)%2; } else if (u[0] == -1 && u[1] == -1) { break; } else if (u[0] != -1 && pwgts[0]+vwgt[u[0]] <= badmaxpwgt) { to = 0; } else if (u[1] != -1 && pwgts[1]+vwgt[u[1]] <= badmaxpwgt) { to = 1; } else break; other = (to+1)%2; higain = PQueueGetMax(&parts[to]); if (moved[higain] == -1) /* Delete if it was in the separator originally */ PQueueDelete(&parts[other], higain, vwgt[higain]-rinfo[higain].edegrees[to]); ASSERT(bndptr[higain] != -1); pwgts[2] -= (vwgt[higain]-rinfo[higain].edegrees[other]); newdiff = idxtype_abs(pwgts[to]+vwgt[higain] - (pwgts[other]-rinfo[higain].edegrees[other])); if (pwgts[2] < mincut || (pwgts[2] == mincut && newdiff < mindiff)) { mincut = pwgts[2]; mincutorder = nswaps; mindiff = newdiff; } else { if (nswaps - mincutorder > limit) { pwgts[2] += (vwgt[higain]-rinfo[higain].edegrees[other]); break; /* No further improvement, break out */ } } BNDDelete(nbnd, bndind, bndptr, higain); pwgts[to] += vwgt[higain]; where[higain] = to; moved[higain] = nswaps; swaps[nswaps] = higain; /********************************************************** * Update the degrees of the affected nodes ***********************************************************/ for (j=xadj[higain]; jdbglvl, DBG_MOVEINFO, mprintf("Moved %6D to %3D, Gain: %5D [%5D] [%4D %4D] \t[%5D %5D %5D]\n", higain, to, g[to], g[other], vwgt[u[to]], vwgt[u[other]], pwgts[0], pwgts[1], pwgts[2])); } /**************************************************************** * Roll back computation *****************************************************************/ for (nswaps--; nswaps>mincutorder; nswaps--) { higain = swaps[nswaps]; ASSERT(CheckNodePartitionParams(graph)); to = where[higain]; other = (to+1)%2; INC_DEC(pwgts[2], pwgts[to], vwgt[higain]); where[higain] = 2; BNDInsert(nbnd, bndind, bndptr, higain); edegrees = rinfo[higain].edegrees; edegrees[0] = edegrees[1] = 0; for (j=xadj[higain]; jdbglvl, DBG_REFINE, mprintf("\tMinimum sep: %6D at %5D, PWGTS: [%6D %6D], NBND: %6D\n", mincut, mincutorder, pwgts[0], pwgts[1], nbnd)); graph->mincut = mincut; graph->nbnd = nbnd; if (mincutorder == -1 || mincut >= initcut) break; } PQueueFree(ctrl, &parts[0]); PQueueFree(ctrl, &parts[1]); idxwspacefree(ctrl, nvtxs+1); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); } /************************************************************************* * This function performs a node-based FM refinement **************************************************************************/ void FM_2WayNodeRefine2(CtrlType *ctrl, GraphType *graph, float ubfactor, idxtype npasses) { idxtype i, ii, j, k, jj, kk, nvtxs, nbnd, nswaps, nmind; idxtype *xadj, *vwgt, *adjncy, *where, *pwgts, *edegrees, *bndind, *bndptr; idxtype *mptr, *mind, *moved, *swaps, *perm; PQueueType parts[2]; NRInfoType *rinfo; idxtype higain, oldgain, mincut, initcut, mincutorder; idxtype pass, to, other, limit; idxtype badmaxpwgt, mindiff, newdiff; idxtype u[2], g[2]; nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; vwgt = graph->vwgt; bndind = graph->bndind; bndptr = graph->bndptr; where = graph->where; pwgts = graph->pwgts; rinfo = graph->nrinfo; i = ComputeMaxNodeGain(nvtxs, xadj, adjncy, vwgt); PQueueInit(ctrl, &parts[0], nvtxs, i); PQueueInit(ctrl, &parts[1], nvtxs, i); moved = idxwspacemalloc(ctrl, nvtxs); swaps = idxwspacemalloc(ctrl, nvtxs); mptr = idxwspacemalloc(ctrl, nvtxs+1); mind = idxwspacemalloc(ctrl, nvtxs); perm = idxwspacemalloc(ctrl, nvtxs); IFSET(ctrl->dbglvl, DBG_REFINE, mprintf("Partitions: [%6D %6D] Nv-Nb[%6D %6D]. ISep: %6D\n", pwgts[0], pwgts[1], graph->nvtxs, graph->nbnd, graph->mincut)); badmaxpwgt = (int)(ubfactor*(pwgts[0]+pwgts[1]+pwgts[2])/2); for (pass=0; passmincut; nbnd = graph->nbnd; RandomPermute(nbnd, perm, 1); for (ii=0; iioflags&OFLAG_COMPRESS ? amin(5*nbnd, 400) : amin(2*nbnd, 300)); /****************************************************** * Get into the FM loop *******************************************************/ mptr[0] = nmind = 0; mindiff = idxtype_abs(pwgts[0]-pwgts[1]); to = (pwgts[0] < pwgts[1] ? 0 : 1); for (nswaps=0; nswaps g[1] ? 0 : (g[0] < g[1] ? 1 : pass%2)); /* to = (g[0] > g[1] ? 0 : (g[0] < g[1] ? 1 : (pwgts[0] < pwgts[1] ? 0 : 1))); */ if (pwgts[to]+vwgt[u[to]] > badmaxpwgt) to = (to+1)%2; } else if (u[0] == -1 && u[1] == -1) { break; } else if (u[0] != -1 && pwgts[0]+vwgt[u[0]] <= badmaxpwgt) { to = 0; } else if (u[1] != -1 && pwgts[1]+vwgt[u[1]] <= badmaxpwgt) { to = 1; } else break; other = (to+1)%2; higain = PQueueGetMax(&parts[to]); if (moved[higain] == -1) /* Delete if it was in the separator originally */ PQueueDelete(&parts[other], higain, vwgt[higain]-rinfo[higain].edegrees[to]); ASSERT(bndptr[higain] != -1); pwgts[2] -= (vwgt[higain]-rinfo[higain].edegrees[other]); newdiff = idxtype_abs(pwgts[to]+vwgt[higain] - (pwgts[other]-rinfo[higain].edegrees[other])); if (pwgts[2] < mincut || (pwgts[2] == mincut && newdiff < mindiff)) { mincut = pwgts[2]; mincutorder = nswaps; mindiff = newdiff; } else { if (nswaps - mincutorder > limit) { pwgts[2] += (vwgt[higain]-rinfo[higain].edegrees[other]); break; /* No further improvement, break out */ } } BNDDelete(nbnd, bndind, bndptr, higain); pwgts[to] += vwgt[higain]; where[higain] = to; moved[higain] = nswaps; swaps[nswaps] = higain; /********************************************************** * Update the degrees of the affected nodes ***********************************************************/ for (j=xadj[higain]; jdbglvl, DBG_MOVEINFO, mprintf("Moved %6D to %3D, Gain: %5D [%5D] [%4D %4D] \t[%5D %5D %5D]\n", higain, to, g[to], g[other], vwgt[u[to]], vwgt[u[other]], pwgts[0], pwgts[1], pwgts[2])); } /**************************************************************** * Roll back computation *****************************************************************/ for (nswaps--; nswaps>mincutorder; nswaps--) { higain = swaps[nswaps]; ASSERT(CheckNodePartitionParams(graph)); to = where[higain]; other = (to+1)%2; INC_DEC(pwgts[2], pwgts[to], vwgt[higain]); where[higain] = 2; BNDInsert(nbnd, bndind, bndptr, higain); edegrees = rinfo[higain].edegrees; edegrees[0] = edegrees[1] = 0; for (j=xadj[higain]; jdbglvl, DBG_REFINE, mprintf("\tMinimum sep: %6D at %5D, PWGTS: [%6D %6D], NBND: %6D\n", mincut, mincutorder, pwgts[0], pwgts[1], nbnd)); graph->mincut = mincut; graph->nbnd = nbnd; if (mincutorder == -1 || mincut >= initcut) break; } PQueueFree(ctrl, &parts[0]); PQueueFree(ctrl, &parts[1]); idxwspacefree(ctrl, nvtxs+1); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); } /************************************************************************* * This function performs a node-based FM refinement **************************************************************************/ void FM_2WayNodeRefineEqWgt(CtrlType *ctrl, GraphType *graph, idxtype npasses) { idxtype i, ii, j, k, jj, kk, nvtxs, nbnd, nswaps, nmind; idxtype *xadj, *vwgt, *adjncy, *where, *pwgts, *edegrees, *bndind, *bndptr; idxtype *mptr, *mind, *moved, *swaps, *perm; PQueueType parts[2]; NRInfoType *rinfo; idxtype higain, oldgain, mincut, initcut, mincutorder; idxtype pass, to, other, limit; idxtype mindiff, newdiff; idxtype u[2], g[2]; nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; vwgt = graph->vwgt; bndind = graph->bndind; bndptr = graph->bndptr; where = graph->where; pwgts = graph->pwgts; rinfo = graph->nrinfo; i = ComputeMaxNodeGain(nvtxs, xadj, adjncy, vwgt); PQueueInit(ctrl, &parts[0], nvtxs, i); PQueueInit(ctrl, &parts[1], nvtxs, i); moved = idxwspacemalloc(ctrl, nvtxs); swaps = idxwspacemalloc(ctrl, nvtxs); mptr = idxwspacemalloc(ctrl, nvtxs+1); mind = idxwspacemalloc(ctrl, nvtxs); perm = idxwspacemalloc(ctrl, nvtxs); IFSET(ctrl->dbglvl, DBG_REFINE, mprintf("Partitions: [%6D %6D] Nv-Nb[%6D %6D]. ISep: %6D\n", pwgts[0], pwgts[1], graph->nvtxs, graph->nbnd, graph->mincut)); for (pass=0; passmincut; nbnd = graph->nbnd; RandomPermute(nbnd, perm, 1); for (ii=0; iioflags&OFLAG_COMPRESS ? amin(5*nbnd, 400) : amin(2*nbnd, 300)); /****************************************************** * Get into the FM loop *******************************************************/ mptr[0] = nmind = 0; mindiff = idxtype_abs(pwgts[0]-pwgts[1]); to = (pwgts[0] < pwgts[1] ? 0 : 1); for (nswaps=0; nswaps g[1] ? 0 : (g[0] < g[1] ? 1 : pass%2)); } } other = (to+1)%2; if ((higain = PQueueGetMax(&parts[to])) == -1) break; if (moved[higain] == -1) /* Delete if it was in the separator originally */ PQueueDelete(&parts[other], higain, vwgt[higain]-rinfo[higain].edegrees[to]); ASSERT(bndptr[higain] != -1); pwgts[2] -= (vwgt[higain]-rinfo[higain].edegrees[other]); newdiff = idxtype_abs(pwgts[to]+vwgt[higain] - (pwgts[other]-rinfo[higain].edegrees[other])); if (pwgts[2] < mincut || (pwgts[2] == mincut && newdiff < mindiff)) { mincut = pwgts[2]; mincutorder = nswaps; mindiff = newdiff; } else { if (nswaps - mincutorder > limit) { pwgts[2] += (vwgt[higain]-rinfo[higain].edegrees[other]); break; /* No further improvement, break out */ } } BNDDelete(nbnd, bndind, bndptr, higain); pwgts[to] += vwgt[higain]; where[higain] = to; moved[higain] = nswaps; swaps[nswaps] = higain; /********************************************************** * Update the degrees of the affected nodes ***********************************************************/ for (j=xadj[higain]; jdbglvl, DBG_MOVEINFO, mprintf("Moved %6D to %3D, Gain: %5D [%5D] [%4D %4D] \t[%5D %5D %5D]\n", higain, to, g[to], g[other], vwgt[u[to]], vwgt[u[other]], pwgts[0], pwgts[1], pwgts[2])); } /**************************************************************** * Roll back computation *****************************************************************/ for (nswaps--; nswaps>mincutorder; nswaps--) { higain = swaps[nswaps]; ASSERT(CheckNodePartitionParams(graph)); to = where[higain]; other = (to+1)%2; INC_DEC(pwgts[2], pwgts[to], vwgt[higain]); where[higain] = 2; BNDInsert(nbnd, bndind, bndptr, higain); edegrees = rinfo[higain].edegrees; edegrees[0] = edegrees[1] = 0; for (j=xadj[higain]; jdbglvl, DBG_REFINE, mprintf("\tMinimum sep: %6D at %5D, PWGTS: [%6D %6D], NBND: %6D\n", mincut, mincutorder, pwgts[0], pwgts[1], nbnd)); graph->mincut = mincut; graph->nbnd = nbnd; if (mincutorder == -1 || mincut >= initcut) break; } PQueueFree(ctrl, &parts[0]); PQueueFree(ctrl, &parts[1]); idxwspacefree(ctrl, nvtxs+1); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); } /************************************************************************* * This function performs a node-based FM refinement. This is the * one-way version **************************************************************************/ void FM_2WayNodeRefine_OneSided(CtrlType *ctrl, GraphType *graph, float ubfactor, idxtype npasses) { idxtype i, ii, j, k, jj, kk, nvtxs, nbnd, nswaps, nmind; idxtype *xadj, *vwgt, *adjncy, *where, *pwgts, *edegrees, *bndind, *bndptr; idxtype *mptr, *mind, *swaps, *perm; PQueueType parts; NRInfoType *rinfo; idxtype higain, oldgain, mincut, initcut, mincutorder; idxtype pass, to, other, limit; idxtype badmaxpwgt, mindiff, newdiff; nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; vwgt = graph->vwgt; bndind = graph->bndind; bndptr = graph->bndptr; where = graph->where; pwgts = graph->pwgts; rinfo = graph->nrinfo; PQueueInit(ctrl, &parts, nvtxs, ComputeMaxNodeGain(nvtxs, xadj, adjncy, vwgt)); perm = idxwspacemalloc(ctrl, nvtxs); swaps = idxwspacemalloc(ctrl, nvtxs); mptr = idxwspacemalloc(ctrl, nvtxs+1); mind = idxwspacemalloc(ctrl, nvtxs); IFSET(ctrl->dbglvl, DBG_REFINE, mprintf("Partitions-N1: [%6D %6D] Nv-Nb[%6D %6D]. ISep: %6D\n", pwgts[0], pwgts[1], graph->nvtxs, graph->nbnd, graph->mincut)); badmaxpwgt = (int)(ubfactor*(pwgts[0]+pwgts[1]+pwgts[2])/2); to = (pwgts[0] < pwgts[1] ? 1 : 0); for (pass=0; passmincut; nbnd = graph->nbnd; RandomPermute(nbnd, perm, 1); for (ii=0; iioflags&OFLAG_COMPRESS ? amin(5*nbnd, 400) : amin(2*nbnd, 300)); /****************************************************** * Get into the FM loop *******************************************************/ mptr[0] = nmind = 0; mindiff = idxtype_abs(pwgts[0]-pwgts[1]); for (nswaps=0; nswaps badmaxpwgt) break; /* No point going any further. Balance will be bad */ pwgts[2] -= (vwgt[higain]-rinfo[higain].edegrees[other]); newdiff = idxtype_abs(pwgts[to]+vwgt[higain] - (pwgts[other]-rinfo[higain].edegrees[other])); if (pwgts[2] < mincut || (pwgts[2] == mincut && newdiff < mindiff)) { mincut = pwgts[2]; mincutorder = nswaps; mindiff = newdiff; } else { if (nswaps - mincutorder > limit) { pwgts[2] += (vwgt[higain]-rinfo[higain].edegrees[other]); break; /* No further improvement, break out */ } } BNDDelete(nbnd, bndind, bndptr, higain); pwgts[to] += vwgt[higain]; where[higain] = to; swaps[nswaps] = higain; /********************************************************** * Update the degrees of the affected nodes ***********************************************************/ for (j=xadj[higain]; jdbglvl, DBG_MOVEINFO, mprintf("Moved %6D to %3D, Gain: %5D [%5D] \t[%5D %5D %5D] [%3D %2D]\n", higain, to, (vwgt[higain]-rinfo[higain].edegrees[other]), vwgt[higain], pwgts[0], pwgts[1], pwgts[2], nswaps, limit)); } /**************************************************************** * Roll back computation *****************************************************************/ for (nswaps--; nswaps>mincutorder; nswaps--) { higain = swaps[nswaps]; ASSERT(CheckNodePartitionParams(graph)); ASSERT(where[higain] == to); INC_DEC(pwgts[2], pwgts[to], vwgt[higain]); where[higain] = 2; BNDInsert(nbnd, bndind, bndptr, higain); edegrees = rinfo[higain].edegrees; edegrees[0] = edegrees[1] = 0; for (j=xadj[higain]; jdbglvl, DBG_REFINE, mprintf("\tMinimum sep: %6D at %5D, PWGTS: [%6D %6D], NBND: %6D\n", mincut, mincutorder, pwgts[0], pwgts[1], nbnd)); graph->mincut = mincut; graph->nbnd = nbnd; if (pass%2 == 1 && (mincutorder == -1 || mincut >= initcut)) break; } PQueueFree(ctrl, &parts); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs+1); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); } /************************************************************************* * This function performs a node-based FM refinement **************************************************************************/ void FM_2WayNodeBalance(CtrlType *ctrl, GraphType *graph, float ubfactor) { idxtype i, ii, j, k, jj, kk, nvtxs, nbnd, nswaps; idxtype *xadj, *vwgt, *adjncy, *where, *pwgts, *edegrees, *bndind, *bndptr; idxtype *perm, *moved; PQueueType parts; NRInfoType *rinfo; idxtype higain, oldgain; idxtype pass, to, other; nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; vwgt = graph->vwgt; bndind = graph->bndind; bndptr = graph->bndptr; where = graph->where; pwgts = graph->pwgts; rinfo = graph->nrinfo; if (idxtype_abs(pwgts[0]-pwgts[1]) < (int)((ubfactor-1.0)*(pwgts[0]+pwgts[1]))) return; if (idxtype_abs(pwgts[0]-pwgts[1]) < 3*idxsum(nvtxs, vwgt, 1)/nvtxs) return; to = (pwgts[0] < pwgts[1] ? 0 : 1); other = (to+1)%2; PQueueInit(ctrl, &parts, nvtxs, ComputeMaxNodeGain(nvtxs, xadj, adjncy, vwgt)); perm = idxwspacemalloc(ctrl, nvtxs); moved = idxset(nvtxs, -1, idxwspacemalloc(ctrl, nvtxs)); IFSET(ctrl->dbglvl, DBG_REFINE, mprintf("Partitions: [%6D %6D] Nv-Nb[%6D %6D]. ISep: %6D [B]\n", pwgts[0], pwgts[1], graph->nvtxs, graph->nbnd, graph->mincut)); nbnd = graph->nbnd; RandomPermute(nbnd, perm, 1); for (ii=0; iidbglvl, DBG_MOVEINFO, mprintf("Moved %6D to %3D, Gain: %3D, \t[%5D %5D %5D]\n", higain, to, vwgt[higain]-rinfo[higain].edegrees[other], pwgts[0], pwgts[1], pwgts[2])); /********************************************************** * Update the degrees of the affected nodes ***********************************************************/ for (j=xadj[higain]; j pwgts[other]) break; } IFSET(ctrl->dbglvl, DBG_REFINE, mprintf("\tBalanced sep: %6D at %4D, PWGTS: [%6D %6D], NBND: %6D\n", pwgts[2], nswaps, pwgts[0], pwgts[1], nbnd)); graph->mincut = pwgts[2]; graph->nbnd = nbnd; PQueueFree(ctrl, &parts); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); } /************************************************************************* * This function computes the maximum possible gain for a vertex **************************************************************************/ idxtype ComputeMaxNodeGain(idxtype nvtxs, idxtype *xadj, idxtype *adjncy, idxtype *vwgt) { idxtype i, j, k, max; max = 0; for (j=xadj[0]; j /************************************************************************* * This function is the entry point of the separator refinement **************************************************************************/ void Refine2WayNode(CtrlType *ctrl, GraphType *orggraph, GraphType *graph, float ubfactor) { IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->UncoarsenTmr)); for (;;) { IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->RefTmr)); if (ctrl->RType != 15) FM_2WayNodeBalance(ctrl, graph, ubfactor); switch (ctrl->RType) { case 1: FM_2WayNodeRefine(ctrl, graph, ubfactor, 8); break; case 2: FM_2WayNodeRefine_OneSided(ctrl, graph, ubfactor, 8); break; case 3: FM_2WayNodeRefine(ctrl, graph, ubfactor, 8); FM_2WayNodeRefine_OneSided(ctrl, graph, ubfactor, 8); break; case 4: FM_2WayNodeRefine_OneSided(ctrl, graph, ubfactor, 8); FM_2WayNodeRefine(ctrl, graph, ubfactor, 8); break; case 5: FM_2WayNodeRefineEqWgt(ctrl, graph, 8); break; } IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->RefTmr)); if (graph == orggraph) break; graph = graph->finer; IFSET(ctrl->dbglvl, DBG_TIME, gk_startcputimer(ctrl->ProjectTmr)); Project2WayNodePartition(ctrl, graph); IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->ProjectTmr)); } IFSET(ctrl->dbglvl, DBG_TIME, gk_stopcputimer(ctrl->UncoarsenTmr)); } /************************************************************************* * This function allocates memory for 2-way edge refinement **************************************************************************/ void Allocate2WayNodePartitionMemory(CtrlType *ctrl, GraphType *graph) { idxtype nvtxs; nvtxs = graph->nvtxs; graph->pwgts = idxmalloc(3, "Allocate2WayNodePartitionMemory: pwgts"); graph->where = idxmalloc(nvtxs, "Allocate2WayNodePartitionMemory: where"); graph->bndptr = idxmalloc(nvtxs, "Allocate2WayNodePartitionMemory: bndptr"); graph->bndind = idxmalloc(nvtxs, "Allocate2WayNodePartitionMemory: bndind"); graph->nrinfo = (NRInfoType *)gk_malloc(nvtxs*sizeof(NRInfoType), "Allocate2WayNodePartitionMemory: nrinfo"); } /************************************************************************* * This function computes the initial id/ed **************************************************************************/ void Compute2WayNodePartitionParams(CtrlType *ctrl, GraphType *graph) { idxtype i, j, k, l, nvtxs, nbnd; idxtype *xadj, *adjncy, *adjwgt, *vwgt; idxtype *where, *pwgts, *bndind, *bndptr, *edegrees; NRInfoType *rinfo; idxtype me, other; nvtxs = graph->nvtxs; xadj = graph->xadj; vwgt = graph->vwgt; adjncy = graph->adjncy; adjwgt = graph->adjwgt; where = graph->where; rinfo = graph->nrinfo; pwgts = idxset(3, 0, graph->pwgts); bndind = graph->bndind; bndptr = idxset(nvtxs, -1, graph->bndptr); /*------------------------------------------------------------ / Compute now the separator external degrees /------------------------------------------------------------*/ nbnd = 0; for (i=0; i=0 && me <= 2); if (me == 2) { /* If it is on the separator do some computations */ BNDInsert(nbnd, bndind, bndptr, i); edegrees = rinfo[i].edegrees; edegrees[0] = edegrees[1] = 0; for (j=xadj[i]; jmincut = pwgts[2]; graph->nbnd = nbnd; } /************************************************************************* * This function computes the initial id/ed **************************************************************************/ void Project2WayNodePartition(CtrlType *ctrl, GraphType *graph) { idxtype i, j, nvtxs; idxtype *cmap, *where, *cwhere; GraphType *cgraph; cgraph = graph->coarser; cwhere = cgraph->where; nvtxs = graph->nvtxs; cmap = graph->cmap; Allocate2WayNodePartitionMemory(ctrl, graph); where = graph->where; /* Project the partition */ for (i=0; i= 0 && where[i] <= 2, ("%d %d %d %d\n", i, cmap[i], where[i], cwhere[cmap[i]])); } FreeGraph(graph->coarser, 1); graph->coarser = NULL; Compute2WayNodePartitionParams(ctrl, graph); } PyMetis-0.90/src/metis/stat.c0000640000175000017500000002446510662171744015716 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * stat.c * * This file computes various statistics * * Started 7/25/97 * George * * $Id: stat.c,v 1.2 2002/08/10 06:29:34 karypis Exp $ * */ #include /************************************************************************* * This function computes cuts and balance information **************************************************************************/ void ComputePartitionInfo(GraphType *graph, idxtype nparts, idxtype *where) { idxtype i, j, k, nvtxs, ncon, mustfree=0; idxtype *xadj, *adjncy, *vwgt, *adjwgt, *kpwgts, *tmpptr; idxtype *padjncy, *padjwgt, *padjcut; nvtxs = graph->nvtxs; ncon = graph->ncon; xadj = graph->xadj; adjncy = graph->adjncy; vwgt = graph->vwgt; adjwgt = graph->adjwgt; if (vwgt == NULL) { vwgt = graph->vwgt = idxsmalloc(nvtxs, 1, "vwgt"); mustfree = 1; } if (adjwgt == NULL) { adjwgt = graph->adjwgt = idxsmalloc(xadj[nvtxs], 1, "adjwgt"); mustfree += 2; } mprintf("%D-way Cut: %5D, Vol: %5D, ", nparts, ComputeCut(graph, where), ComputeVolume(graph, where)); /* Compute balance information */ kpwgts = idxsmalloc(ncon*nparts, 0, "ComputePartitionInfo: kpwgts"); for (i=0; iwhere; graph->where = where; for (i=0; iwhere = tmpptr; if (mustfree == 1 || mustfree == 3) { gk_free((void **)&vwgt, LTERM); graph->vwgt = NULL; } if (mustfree == 2 || mustfree == 3) { gk_free((void **)&adjwgt, LTERM); graph->adjwgt = NULL; } gk_free((void **)&kpwgts, &padjncy, &padjwgt, &padjcut, LTERM); } /************************************************************************* * This function computes cuts and balance information **************************************************************************/ void ComputePartitionInfoBipartite(GraphType *graph, idxtype nparts, idxtype *where) { idxtype i, j, k, nvtxs, ncon, mustfree=0; idxtype *xadj, *adjncy, *vwgt, *vsize, *adjwgt, *kpwgts, *tmpptr; idxtype *padjncy, *padjwgt, *padjcut; nvtxs = graph->nvtxs; ncon = graph->ncon; xadj = graph->xadj; adjncy = graph->adjncy; vwgt = graph->vwgt; vsize = graph->vsize; adjwgt = graph->adjwgt; if (vwgt == NULL) { vwgt = graph->vwgt = idxsmalloc(nvtxs, 1, "vwgt"); mustfree = 1; } if (adjwgt == NULL) { adjwgt = graph->adjwgt = idxsmalloc(xadj[nvtxs], 1, "adjwgt"); mustfree += 2; } mprintf("%D-way Cut: %5D, Vol: %5D, ", nparts, ComputeCut(graph, where), ComputeVolume(graph, where)); /* Compute balance information */ kpwgts = idxsmalloc(ncon*nparts, 0, "ComputePartitionInfo: kpwgts"); for (i=0; ivwgt = NULL; } if (mustfree == 2 || mustfree == 3) { gk_free((void **)&adjwgt, LTERM); graph->adjwgt = NULL; } gk_free((void **)&kpwgts, &padjncy, &padjwgt, &padjcut, LTERM); } /************************************************************************* * This function computes the balance of the partitioning **************************************************************************/ void ComputePartitionBalance(GraphType *graph, idxtype nparts, idxtype *where, float *ubvec) { idxtype i, j, nvtxs, ncon; idxtype *kpwgts, *vwgt; float balance; nvtxs = graph->nvtxs; ncon = graph->ncon; vwgt = graph->vwgt; kpwgts = idxsmalloc(nparts, 0, "ComputePartitionInfo: kpwgts"); if (vwgt == NULL) { for (i=0; invtxs; i++) kpwgts[where[i]] += vwgt[i*ncon+j]; ubvec[j] = 1.0*nparts*kpwgts[idxargmax(nparts, kpwgts)]/(1.0*idxsum(nparts, kpwgts, 1)); } } gk_free((void **)&kpwgts, LTERM); } /************************************************************************* * This function computes the balance of the element partitioning **************************************************************************/ float ComputeElementBalance(idxtype ne, idxtype nparts, idxtype *where) { idxtype i; idxtype *kpwgts; float balance; kpwgts = idxsmalloc(nparts, 0, "ComputeElementBalance: kpwgts"); for (i=0; invtxs; ncon = graph->ncon; nvwgt = graph->nvwgt; kpwgts = gk_fmalloc(nparts, "ComputePartitionInfo: kpwgts"); for (j=0; jnvtxs; i++) kpwgts[where[i]] += nvwgt[i*ncon+j]; ubvec[j] = (float)nparts*kpwgts[gk_fargmax(nparts, kpwgts)]/gk_fsum(nparts, kpwgts, 1); } gk_free((void **)&kpwgts, LTERM); } PyMetis-0.90/src/metis/stdheaders.h0000640000175000017500000000064210662171744017065 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * stdheaders.h * * This file includes all necessary header files * * Started 8/27/94 * George * * $Id: stdheaders.h,v 1.2 2003/07/25 14:31:45 karypis Exp $ */ #include #ifdef __STDC__ #include #else #include #endif #include #include #include #include #include PyMetis-0.90/src/metis/streamio.c0000640000175000017500000000745110662171744016562 0ustar andreasandreas/* * Copyright 2007, Regents of the University of Minnesota * * streamio.c * * This function contains various functions that deal with extending the * functionality of prinf and mscanf family of routines to understand * additional format conversions. * * At this point the following conversions are support: * %D for idxtype (which either 32 or 64 bits) * * Started 4/6/07 * George * * $Id: util.c,v 1.4 2003/04/13 04:45:12 karypis Exp $ */ #include #define D_PATTERN "((^%|[^%]%)[0-\\s\\+]*[0-9]*)D" #define D_SCAN_REPLACEMENT "$1" SCNIDX #define D_PRINT_REPLACEMENT "$1" PRIIDX /************************************************************************* * Custom mprintf() routine **************************************************************************/ int mprintf(char *format,...) { char *new_format; int rc; va_list argp; gk_strstr_replace(format, D_PATTERN, D_PRINT_REPLACEMENT, "g", &new_format); /*mprintf("new_format: %s\n", new_format);*/ va_start(argp, format); rc = vprintf((char *)new_format, argp); va_end(argp); gk_free((void **)&new_format, LTERM); return rc; } /************************************************************************* * Custom msprintf() routine **************************************************************************/ int msprintf(char *str, char *format,...) { char *new_format; int rc; va_list argp; gk_strstr_replace(format, D_PATTERN, D_PRINT_REPLACEMENT, "g", &new_format); /*mprintf("new_format: %s\n", new_format);*/ va_start(argp, format); rc = vsprintf(str, (char *)new_format, argp); va_end(argp); gk_free((void **)&new_format, LTERM); return rc; } /************************************************************************* * Custom mfprintf() routine **************************************************************************/ int mfprintf(FILE *stream, char *format,...) { char *new_format; int rc; va_list argp; gk_strstr_replace(format, D_PATTERN, D_PRINT_REPLACEMENT, "g", &new_format); /*mprintf("new_format: %s\n", new_format);*/ va_start(argp, format); rc = vfprintf(stream, (char *)new_format, argp); va_end(argp); gk_free((void **)&new_format, LTERM); return rc; } /************************************************************************* * Custom mscanf() routine **************************************************************************/ int mscanf(char *format,...) { char *new_format; int rc; va_list argp; gk_strstr_replace(format, D_PATTERN, D_SCAN_REPLACEMENT, "g", &new_format); /*mprintf("new_format: %s\n", new_format);*/ va_start(argp, format); rc = vscanf((char *)new_format, argp); va_end(argp); gk_free((void **)&new_format, LTERM); return rc; } /************************************************************************* * Custom msscanf() routine **************************************************************************/ int msscanf(char *str, char *format,...) { char *new_format; int rc; va_list argp; gk_strstr_replace(format, D_PATTERN, D_SCAN_REPLACEMENT, "g", &new_format); /*mprintf("new_format: %s\n", new_format);*/ va_start(argp, format); rc = vsscanf(str, (char *)new_format, argp); va_end(argp); gk_free((void **)&new_format, LTERM); return rc; } /************************************************************************* * Custom mfscanf() routine **************************************************************************/ int mfscanf(FILE *stream, char *format,...) { char *new_format; int rc; va_list argp; gk_strstr_replace(format, D_PATTERN, D_SCAN_REPLACEMENT, "g", &new_format); /*mprintf("new_format: %s\n", new_format);*/ va_start(argp, format); rc = vfscanf(stream, (char *)new_format, argp); va_end(argp); gk_free((void **)&new_format, LTERM); return rc; } PyMetis-0.90/src/metis/struct.h0000640000175000017500000002114710662171744016266 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * struct.h * * This file contains data structures for ILU routines. * * Started 9/26/95 * George * * $Id: struct.h,v 1.11 2003/04/23 02:41:59 karypis Exp $ */ #define MAXIDX ((idxtype)1<<(8*sizeof(idxtype))-2) /************************************************************************* * The following data structure stores idxtype-val - double-key pairs **************************************************************************/ typedef struct { idxtype dim; double value; idxtype nvtxs; idxtype nsvtxs; idxtype leafid; idxtype partid; idxtype left, right; } DTreeNodeType; /************************************************************************* * The following data structure stores idxtype-val - double-key pairs **************************************************************************/ typedef struct { idxtype nvtxs; idxtype nnodes, nleafs; idxtype *leafptr, *leafind, *leafwgt; /* Information as to which partitions are assigned to the leafs */ idxtype *part; /* The actual partitioning vector */ idxtype *leafpart; /* The leaf-based partitioning vector */ DTreeNodeType *dtree; /* The decission tree itself */ } ContactInfoType; /************************************************************************* * The following data structure stores idxtype-key - double-value pairs **************************************************************************/ typedef struct { double key; idxtype val; } DKeyValueType; /************************************************************************* * The following data structure stores key-value pair **************************************************************************/ struct KeyValueType { idxtype key; idxtype val; }; typedef struct KeyValueType KeyValueType; /************************************************************************* * The following data structure will hold a node of a doubly-linked list. **************************************************************************/ struct ListNodeType { idxtype id; /* The id value of the node */ struct ListNodeType *prev, *next; /* It's a doubly-linked list */ }; typedef struct ListNodeType ListNodeType; /************************************************************************* * The following data structure is used to store the buckets for the * refinment algorithms **************************************************************************/ struct PQueueType { idxtype type; /* The type of the representation used */ idxtype nnodes; idxtype maxnodes; idxtype mustfree; /* Linear array version of the data structures */ idxtype pgainspan, ngainspan; /* plus and negative gain span */ idxtype maxgain; ListNodeType *nodes; ListNodeType **buckets; /* Heap version of the data structure */ KeyValueType *heap; idxtype *locator; }; typedef struct PQueueType PQueueType; /************************************************************************* * The following data structure stores an edge **************************************************************************/ struct edegreedef { idxtype pid; idxtype ed; }; typedef struct edegreedef EDegreeType; /************************************************************************* * The following data structure stores an edge for vol **************************************************************************/ struct vedegreedef { idxtype pid; idxtype ed, ned; idxtype gv; }; typedef struct vedegreedef VEDegreeType; /************************************************************************* * This data structure holds various working space data **************************************************************************/ struct workspacedef { idxtype *core; /* Where pairs, indices, and degrees are coming from */ idxtype maxcore, ccore; EDegreeType *edegrees; VEDegreeType *vedegrees; idxtype cdegree; idxtype *auxcore; /* This points to the memory of the edegrees */ idxtype *pmat; /* An array of k^2 used for eliminating domain connectivity in k-way refinement */ }; typedef struct workspacedef WorkSpaceType; /************************************************************************* * The following data structure holds information on degrees for k-way * partition **************************************************************************/ struct rinfodef { idxtype id, ed; /* ID/ED of nodes */ idxtype ndegrees; /* The number of different ext-degrees */ EDegreeType *edegrees; /* List of edges */ }; typedef struct rinfodef RInfoType; /************************************************************************* * The following data structure holds information on degrees for k-way * vol-based partition **************************************************************************/ struct vrinfodef { idxtype id, ed, nid; /* ID/ED of nodes */ idxtype gv; /* IV/EV of nodes */ idxtype ndegrees; /* The number of different ext-degrees */ VEDegreeType *edegrees; /* List of edges */ }; typedef struct vrinfodef VRInfoType; /************************************************************************* * The following data structure holds information on degrees for k-way * partition **************************************************************************/ struct nrinfodef { idxtype edegrees[2]; }; typedef struct nrinfodef NRInfoType; /************************************************************************* * This data structure holds the input graph **************************************************************************/ struct graphdef { idxtype nvtxs, nedges; /* The # of vertices and edges in the graph */ idxtype *xadj; /* Pointers to the locally stored vertices */ idxtype *vwgt; /* Vertex weights */ idxtype *vsize; /* Vertex sizes for min-volume formulation */ idxtype *adjncy; /* Array that stores the adjacency lists of nvtxs */ idxtype *adjwgt; /* Array that stores the weights of the adjacency lists */ /* These are to keep track control if the corresponding fields correspond to application or library memory */ int free_xadj, free_vwgt, free_vsize, free_adjncy, free_adjwgt; double *coords; /* x, y, and z, Coordinates */ idxtype *adjwgtsum; /* The sum of the adjacency weight of each vertex */ idxtype *label; idxtype *cmap; /* Partition parameters */ idxtype mincut, minvol; idxtype *where, *pwgts; idxtype nbnd; idxtype *bndptr, *bndind; /* Bisection refinement parameters */ idxtype *id, *ed; /* K-way refinement parameters */ RInfoType *rinfo; /* K-way volume refinement parameters */ VRInfoType *vrinfo; /* Node refinement information */ NRInfoType *nrinfo; /* Additional info needed by the MOC routines */ idxtype ncon; /* The # of constrains */ float *nvwgt; /* Normalized vertex weights */ float *npwgts; /* The normalized partition weights */ struct graphdef *coarser, *finer; }; typedef struct graphdef GraphType; /************************************************************************* * The following structure stores information used by Metis **************************************************************************/ struct controldef { idxtype CoarsenTo; /* The # of vertices in the coarsest graph */ idxtype dbglvl; /* Controls the debuging output of the program */ idxtype CType; /* The type of coarsening */ idxtype IType; /* The type of initial partitioning */ idxtype RType; /* The type of refinement */ idxtype maxvwgt; /* The maximum allowed weight for a vertex */ float nmaxvwgt; /* The maximum allowed weight for a vertex for each constrain */ idxtype optype; /* Type of operation */ idxtype pfactor; /* .1*prunning factor */ idxtype nseps; /* The number of separators to be found during multiple bisections */ idxtype oflags; WorkSpaceType wspace; /* Work Space Informations */ /* Various Timers */ double TotalTmr, InitPartTmr, MatchTmr, ContractTmr, CoarsenTmr, UncoarsenTmr, SepTmr, RefTmr, ProjectTmr, SplitTmr, AuxTmr1, AuxTmr2, AuxTmr3, AuxTmr4, AuxTmr5, AuxTmr6; }; typedef struct controldef CtrlType; /************************************************************************* * The following data structure stores max-partition weight info for * Vertical MOC k-way refinement **************************************************************************/ struct vpwgtdef { float max[2][MAXNCON]; idxtype imax[2][MAXNCON]; }; typedef struct vpwgtdef VPInfoType; PyMetis-0.90/src/metis/subdomains.c0000640000175000017500000011472010662171744017101 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * subdomains.c * * This file contains functions that deal with prunning the number of * adjacent subdomains in KMETIS * * Started 7/15/98 * George * * $Id: subdomains.c,v 1.3 2003/07/31 06:04:52 karypis Exp $ * */ #include /************************************************************************* * This function performs k-way refinement **************************************************************************/ void Random_KWayEdgeRefineMConn(CtrlType *ctrl, GraphType *graph, idxtype nparts, float *tpwgts, float ubfactor, idxtype npasses, idxtype ffactor) { idxtype i, ii, iii, j, jj, k, l, pass, nvtxs, nmoves, nbnd, tvwgt, myndegrees; idxtype from, me, to, oldcut, vwgt, gain; idxtype maxndoms, nadd; idxtype *xadj, *adjncy, *adjwgt; idxtype *where, *pwgts, *perm, *bndptr, *bndind, *minwgt, *maxwgt, *itpwgts; idxtype *phtable, *pmat, *pmatptr, *ndoms; EDegreeType *myedegrees; RInfoType *myrinfo; nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; adjwgt = graph->adjwgt; bndptr = graph->bndptr; bndind = graph->bndind; where = graph->where; pwgts = graph->pwgts; pmat = ctrl->wspace.pmat; phtable = idxwspacemalloc(ctrl, nparts); ndoms = idxwspacemalloc(ctrl, nparts); ComputeSubDomainGraph(graph, nparts, pmat, ndoms); /* Setup the weight intervals of the various subdomains */ minwgt = idxwspacemalloc(ctrl, nparts); maxwgt = idxwspacemalloc(ctrl, nparts); itpwgts = idxwspacemalloc(ctrl, nparts); tvwgt = idxsum(nparts, pwgts, 1); ASSERT(tvwgt == idxsum(nvtxs, graph->vwgt, 1)); for (i=0; idbglvl, DBG_REFINE, mprintf("Partitions: [%6D %6D]-[%6D %6D], Balance: %5.3f, Nv-Nb[%6D %6D]. Cut: %6D\n", pwgts[idxargmin(nparts, pwgts)], pwgts[idxargmax(nparts, pwgts)], minwgt[0], maxwgt[0], 1.0*nparts*pwgts[idxargmax(nparts, pwgts)]/tvwgt, graph->nvtxs, graph->nbnd, graph->mincut)); for (pass=0; passmincut); maxndoms = ndoms[idxargmax(nparts, ndoms)]; oldcut = graph->mincut; nbnd = graph->nbnd; RandomPermute(nbnd, perm, 1); for (nmoves=iii=0; iiinbnd; iii++) { ii = perm[iii]; if (ii >= nbnd) continue; i = bndind[ii]; myrinfo = graph->rinfo+i; if (myrinfo->ed >= myrinfo->id) { /* Total ED is too high */ from = where[i]; vwgt = graph->vwgt[i]; if (myrinfo->id > 0 && pwgts[from]-vwgt < minwgt[from]) continue; /* This cannot be moved! */ myedegrees = myrinfo->edegrees; myndegrees = myrinfo->ndegrees; /* Determine the valid domains */ for (j=0; j maxndoms-1) { phtable[to] = 0; nadd = maxndoms; break; } nadd++; } } if (ndoms[to]+nadd > maxndoms) phtable[to] = 0; if (nadd == 0) phtable[to] = 2; } /* Find the first valid move */ j = myrinfo->id; for (k=0; kid. Allow good nodes to move */ if (pwgts[to]+vwgt <= maxwgt[to]+ffactor*gain && gain >= 0) break; } if (k == myndegrees) continue; /* break out if you did not find a candidate */ for (j=k+1; j myedegrees[k].ed && pwgts[to]+vwgt <= maxwgt[to]) || (myedegrees[j].ed == myedegrees[k].ed && itpwgts[myedegrees[k].pid]*pwgts[to] < itpwgts[to]*pwgts[myedegrees[k].pid])) k = j; } to = myedegrees[k].pid; j = 0; if (myedegrees[k].ed-myrinfo->id > 0) j = 1; else if (myedegrees[k].ed-myrinfo->id == 0) { if (/*(iii&7) == 0 ||*/ phtable[myedegrees[k].pid] == 2 || pwgts[from] >= maxwgt[from] || itpwgts[from]*(pwgts[to]+vwgt) < itpwgts[to]*pwgts[from]) j = 1; } if (j == 0) continue; /*===================================================================== * If we got here, we can now move the vertex from 'from' to 'to' *======================================================================*/ graph->mincut -= myedegrees[k].ed-myrinfo->id; IFSET(ctrl->dbglvl, DBG_MOVEINFO, mprintf("\t\tMoving %6D to %3D. Gain: %4D. Cut: %6D\n", i, to, myedegrees[k].ed-myrinfo->id, graph->mincut)); /* Update pmat to reflect the move of 'i' */ pmat[from*nparts+to] += (myrinfo->id-myedegrees[k].ed); pmat[to*nparts+from] += (myrinfo->id-myedegrees[k].ed); if (pmat[from*nparts+to] == 0) { ndoms[from]--; if (ndoms[from]+1 == maxndoms) maxndoms = ndoms[idxargmax(nparts, ndoms)]; } if (pmat[to*nparts+from] == 0) { ndoms[to]--; if (ndoms[to]+1 == maxndoms) maxndoms = ndoms[idxargmax(nparts, ndoms)]; } /* Update where, weight, and ID/ED information of the vertex you moved */ where[i] = to; INC_DEC(pwgts[to], pwgts[from], vwgt); myrinfo->ed += myrinfo->id-myedegrees[k].ed; SWAP(myrinfo->id, myedegrees[k].ed, j); if (myedegrees[k].ed == 0) myedegrees[k] = myedegrees[--myrinfo->ndegrees]; else myedegrees[k].pid = from; if (myrinfo->ed-myrinfo->id < 0) BNDDelete(nbnd, bndind, bndptr, i); /* Update the degrees of adjacent vertices */ for (j=xadj[i]; jrinfo+ii; if (myrinfo->edegrees == NULL) { myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree; ctrl->wspace.cdegree += xadj[ii+1]-xadj[ii]; } myedegrees = myrinfo->edegrees; ASSERT(CheckRInfo(myrinfo)); if (me == from) { INC_DEC(myrinfo->ed, myrinfo->id, adjwgt[j]); if (myrinfo->ed-myrinfo->id >= 0 && bndptr[ii] == -1) BNDInsert(nbnd, bndind, bndptr, ii); } else if (me == to) { INC_DEC(myrinfo->id, myrinfo->ed, adjwgt[j]); if (myrinfo->ed-myrinfo->id < 0 && bndptr[ii] != -1) BNDDelete(nbnd, bndind, bndptr, ii); } /* Remove contribution from the .ed of 'from' */ if (me != from) { for (k=0; kndegrees; k++) { if (myedegrees[k].pid == from) { if (myedegrees[k].ed == adjwgt[j]) myedegrees[k] = myedegrees[--myrinfo->ndegrees]; else myedegrees[k].ed -= adjwgt[j]; break; } } } /* Add contribution to the .ed of 'to' */ if (me != to) { for (k=0; kndegrees; k++) { if (myedegrees[k].pid == to) { myedegrees[k].ed += adjwgt[j]; break; } } if (k == myrinfo->ndegrees) { myedegrees[myrinfo->ndegrees].pid = to; myedegrees[myrinfo->ndegrees++].ed = adjwgt[j]; } } /* Update pmat to reflect the move of 'i' for domains other than 'from' and 'to' */ if (me != from && me != to) { pmat[me*nparts+from] -= adjwgt[j]; pmat[from*nparts+me] -= adjwgt[j]; if (pmat[me*nparts+from] == 0) { ndoms[me]--; if (ndoms[me]+1 == maxndoms) maxndoms = ndoms[idxargmax(nparts, ndoms)]; } if (pmat[from*nparts+me] == 0) { ndoms[from]--; if (ndoms[from]+1 == maxndoms) maxndoms = ndoms[idxargmax(nparts, ndoms)]; } if (pmat[me*nparts+to] == 0) { ndoms[me]++; if (ndoms[me] > maxndoms) { mprintf("You just increased the maxndoms: %D %D\n", ndoms[me], maxndoms); maxndoms = ndoms[me]; } } if (pmat[to*nparts+me] == 0) { ndoms[to]++; if (ndoms[to] > maxndoms) { mprintf("You just increased the maxndoms: %D %D\n", ndoms[to], maxndoms); maxndoms = ndoms[to]; } } pmat[me*nparts+to] += adjwgt[j]; pmat[to*nparts+me] += adjwgt[j]; } ASSERT(myrinfo->ndegrees <= xadj[ii+1]-xadj[ii]); ASSERT(CheckRInfo(myrinfo)); } nmoves++; } } graph->nbnd = nbnd; IFSET(ctrl->dbglvl, DBG_REFINE, mprintf("\t[%6D %6D], Balance: %5.3f, Nb: %6D. Nmoves: %5D, Cut: %5D, Vol: %5D, %D\n", pwgts[idxargmin(nparts, pwgts)], pwgts[idxargmax(nparts, pwgts)], 1.0*nparts*pwgts[idxargmax(nparts, pwgts)]/tvwgt, graph->nbnd, nmoves, graph->mincut, ComputeVolume(graph, where), idxsum(nparts, ndoms, 1))); if (graph->mincut == oldcut) break; } idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nvtxs); } /************************************************************************* * This function performs k-way refinement **************************************************************************/ void Greedy_KWayEdgeBalanceMConn(CtrlType *ctrl, GraphType *graph, idxtype nparts, float *tpwgts, float ubfactor, idxtype npasses) { idxtype i, ii, iii, j, jj, k, l, pass, nvtxs, nbnd, tvwgt, myndegrees, oldgain, gain, nmoves; idxtype from, me, to, oldcut, vwgt, maxndoms, nadd; idxtype *xadj, *adjncy, *adjwgt; idxtype *where, *pwgts, *perm, *bndptr, *bndind, *minwgt, *maxwgt, *moved, *itpwgts; idxtype *phtable, *pmat, *pmatptr, *ndoms; EDegreeType *myedegrees; RInfoType *myrinfo; PQueueType queue; nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; adjwgt = graph->adjwgt; bndind = graph->bndind; bndptr = graph->bndptr; where = graph->where; pwgts = graph->pwgts; pmat = ctrl->wspace.pmat; phtable = idxwspacemalloc(ctrl, nparts); ndoms = idxwspacemalloc(ctrl, nparts); ComputeSubDomainGraph(graph, nparts, pmat, ndoms); /* Setup the weight intervals of the various subdomains */ minwgt = idxwspacemalloc(ctrl, nparts); maxwgt = idxwspacemalloc(ctrl, nparts); itpwgts = idxwspacemalloc(ctrl, nparts); tvwgt = idxsum(nparts, pwgts, 1); ASSERT(tvwgt == idxsum(nvtxs, graph->vwgt, 1)); for (i=0; iadjwgtsum[idxargmax(nvtxs, graph->adjwgtsum)]); IFSET(ctrl->dbglvl, DBG_REFINE, mprintf("Partitions: [%6D %6D]-[%6D %6D], Balance: %5.3f, Nv-Nb[%6D %6D]. Cut: %6D [B]\n", pwgts[idxargmin(nparts, pwgts)], pwgts[idxargmax(nparts, pwgts)], minwgt[0], maxwgt[0], 1.0*nparts*pwgts[idxargmax(nparts, pwgts)]/tvwgt, graph->nvtxs, graph->nbnd, graph->mincut)); for (pass=0; passmincut); /* Check to see if things are out of balance, given the tolerance */ for (i=0; i maxwgt[i]) break; } if (i == nparts) /* Things are balanced. Return right away */ break; PQueueReset(&queue); idxset(nvtxs, -1, moved); oldcut = graph->mincut; nbnd = graph->nbnd; RandomPermute(nbnd, perm, 1); for (ii=0; iirinfo[i].ed - graph->rinfo[i].id); moved[i] = 2; } maxndoms = ndoms[idxargmax(nparts, ndoms)]; for (nmoves=0;;) { if ((i = PQueueGetMax(&queue)) == -1) break; moved[i] = 1; myrinfo = graph->rinfo+i; from = where[i]; vwgt = graph->vwgt[i]; if (pwgts[from]-vwgt < minwgt[from]) continue; /* This cannot be moved! */ myedegrees = myrinfo->edegrees; myndegrees = myrinfo->ndegrees; /* Determine the valid domains */ for (j=0; j maxndoms-1) { phtable[to] = 0; nadd = maxndoms; break; } nadd++; } } if (ndoms[to]+nadd > maxndoms) phtable[to] = 0; } for (k=0; k minwgt[to] && myedegrees[k].ed-myrinfo->id < 0) continue; /*===================================================================== * If we got here, we can now move the vertex from 'from' to 'to' *======================================================================*/ graph->mincut -= myedegrees[k].ed-myrinfo->id; IFSET(ctrl->dbglvl, DBG_MOVEINFO, mprintf("\t\tMoving %6D to %3D. Gain: %4D. Cut: %6D\n", i, to, myedegrees[k].ed-myrinfo->id, graph->mincut)); /* Update pmat to reflect the move of 'i' */ pmat[from*nparts+to] += (myrinfo->id-myedegrees[k].ed); pmat[to*nparts+from] += (myrinfo->id-myedegrees[k].ed); if (pmat[from*nparts+to] == 0) { ndoms[from]--; if (ndoms[from]+1 == maxndoms) maxndoms = ndoms[idxargmax(nparts, ndoms)]; } if (pmat[to*nparts+from] == 0) { ndoms[to]--; if (ndoms[to]+1 == maxndoms) maxndoms = ndoms[idxargmax(nparts, ndoms)]; } /* Update where, weight, and ID/ED information of the vertex you moved */ where[i] = to; INC_DEC(pwgts[to], pwgts[from], vwgt); myrinfo->ed += myrinfo->id-myedegrees[k].ed; SWAP(myrinfo->id, myedegrees[k].ed, j); if (myedegrees[k].ed == 0) myedegrees[k] = myedegrees[--myrinfo->ndegrees]; else myedegrees[k].pid = from; if (myrinfo->ed == 0) BNDDelete(nbnd, bndind, bndptr, i); /* Update the degrees of adjacent vertices */ for (j=xadj[i]; jrinfo+ii; if (myrinfo->edegrees == NULL) { myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree; ctrl->wspace.cdegree += xadj[ii+1]-xadj[ii]; } myedegrees = myrinfo->edegrees; ASSERT(CheckRInfo(myrinfo)); oldgain = (myrinfo->ed-myrinfo->id); if (me == from) { INC_DEC(myrinfo->ed, myrinfo->id, adjwgt[j]); if (myrinfo->ed > 0 && bndptr[ii] == -1) BNDInsert(nbnd, bndind, bndptr, ii); } else if (me == to) { INC_DEC(myrinfo->id, myrinfo->ed, adjwgt[j]); if (myrinfo->ed == 0 && bndptr[ii] != -1) BNDDelete(nbnd, bndind, bndptr, ii); } /* Remove contribution from the .ed of 'from' */ if (me != from) { for (k=0; kndegrees; k++) { if (myedegrees[k].pid == from) { if (myedegrees[k].ed == adjwgt[j]) myedegrees[k] = myedegrees[--myrinfo->ndegrees]; else myedegrees[k].ed -= adjwgt[j]; break; } } } /* Add contribution to the .ed of 'to' */ if (me != to) { for (k=0; kndegrees; k++) { if (myedegrees[k].pid == to) { myedegrees[k].ed += adjwgt[j]; break; } } if (k == myrinfo->ndegrees) { myedegrees[myrinfo->ndegrees].pid = to; myedegrees[myrinfo->ndegrees++].ed = adjwgt[j]; } } /* Update pmat to reflect the move of 'i' for domains other than 'from' and 'to' */ if (me != from && me != to) { pmat[me*nparts+from] -= adjwgt[j]; pmat[from*nparts+me] -= adjwgt[j]; if (pmat[me*nparts+from] == 0) { ndoms[me]--; if (ndoms[me]+1 == maxndoms) maxndoms = ndoms[idxargmax(nparts, ndoms)]; } if (pmat[from*nparts+me] == 0) { ndoms[from]--; if (ndoms[from]+1 == maxndoms) maxndoms = ndoms[idxargmax(nparts, ndoms)]; } if (pmat[me*nparts+to] == 0) { ndoms[me]++; if (ndoms[me] > maxndoms) { mprintf("You just increased the maxndoms: %D %D\n", ndoms[me], maxndoms); maxndoms = ndoms[me]; } } if (pmat[to*nparts+me] == 0) { ndoms[to]++; if (ndoms[to] > maxndoms) { mprintf("You just increased the maxndoms: %D %D\n", ndoms[to], maxndoms); maxndoms = ndoms[to]; } } pmat[me*nparts+to] += adjwgt[j]; pmat[to*nparts+me] += adjwgt[j]; } /* Update the queue */ if (me == to || me == from) { gain = myrinfo->ed-myrinfo->id; if (moved[ii] == 2) { if (myrinfo->ed > 0) PQueueUpdate(&queue, ii, oldgain, gain); else { PQueueDelete(&queue, ii, oldgain); moved[ii] = -1; } } else if (moved[ii] == -1 && myrinfo->ed > 0) { PQueueInsert(&queue, ii, gain); moved[ii] = 2; } } ASSERT(myrinfo->ndegrees <= xadj[ii+1]-xadj[ii]); ASSERT(CheckRInfo(myrinfo)); } nmoves++; } graph->nbnd = nbnd; IFSET(ctrl->dbglvl, DBG_REFINE, mprintf("\t[%6D %6D], Balance: %5.3f, Nb: %6D. Nmoves: %5D, Cut: %6D, %D\n", pwgts[idxargmin(nparts, pwgts)], pwgts[idxargmax(nparts, pwgts)], 1.0*nparts*pwgts[idxargmax(nparts, pwgts)]/tvwgt, graph->nbnd, nmoves, graph->mincut, idxsum(nparts, ndoms, 1))); } PQueueFree(ctrl, &queue); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); } /************************************************************************* * This function computes the subdomain graph **************************************************************************/ void PrintSubDomainGraph(GraphType *graph, idxtype nparts, idxtype *where) { idxtype i, j, k, me, nvtxs, total, max; idxtype *xadj, *adjncy, *adjwgt, *pmat; nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; adjwgt = graph->adjwgt; pmat = idxsmalloc(nparts*nparts, 0, "ComputeSubDomainGraph: pmat"); for (i=0; i 0) k++; } total += k; if (k > max) max = k; /* mprintf("%2D -> %2D ", i, k); for (j=0; j 0) mprintf("[%2D %4D] ", j, pmat[i*nparts+j]); } mprintf("\n"); */ } mprintf("Total adjacent subdomains: %D, Max: %D\n", total, max); gk_free((void **)&pmat, LTERM); } /************************************************************************* * This function computes the subdomain graph **************************************************************************/ void ComputeSubDomainGraph(GraphType *graph, idxtype nparts, idxtype *pmat, idxtype *ndoms) { idxtype i, j, k, me, nvtxs, ndegrees; idxtype *xadj, *adjncy, *adjwgt, *where; RInfoType *rinfo; EDegreeType *edegrees; nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; adjwgt = graph->adjwgt; where = graph->where; rinfo = graph->rinfo; idxset(nparts*nparts, 0, pmat); for (i=0; i 0) { me = where[i]; ndegrees = rinfo[i].ndegrees; edegrees = rinfo[i].edegrees; k = me*nparts; for (j=0; j 0) ndoms[i]++; } } } /************************************************************************* * This function computes the subdomain graph **************************************************************************/ void EliminateSubDomainEdges(CtrlType *ctrl, GraphType *graph, idxtype nparts, float *tpwgts) { idxtype i, ii, j, k, me, other, nvtxs, total, max, avg, totalout, nind, ncand, ncand2, target, target2, nadd; idxtype min, move, cpwgt, tvwgt; idxtype *xadj, *adjncy, *vwgt, *adjwgt, *pwgts, *where, *maxpwgt, *pmat, *ndoms, *mypmat, *otherpmat, *ind; KeyValueType *cand, *cand2; nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; vwgt = graph->vwgt; adjwgt = graph->adjwgt; where = graph->where; pwgts = graph->pwgts; /* We agk_fsume that this is properly initialized */ maxpwgt = idxwspacemalloc(ctrl, nparts); ndoms = idxwspacemalloc(ctrl, nparts); otherpmat = idxwspacemalloc(ctrl, nparts); ind = idxwspacemalloc(ctrl, nvtxs); pmat = ctrl->wspace.pmat; cand = (KeyValueType *)gk_malloc(nparts*sizeof(KeyValueType), "EliminateSubDomainEdges: cand"); cand2 = (KeyValueType *)gk_malloc(nparts*sizeof(KeyValueType), "EliminateSubDomainEdges: cand"); /* Compute the pmat matrix and ndoms */ ComputeSubDomainGraph(graph, nparts, pmat, ndoms); /* Compute the maximum allowed weight for each domain */ tvwgt = idxsum(nparts, pwgts, 1); for (i=0; i 0) { cand2[ncand2].key = mypmat[i]; cand2[ncand2++].val = i; } } ikeysort(ncand2, cand2); move = 0; for (min=0; min totalout/(2*ndoms[me])) break; other = cand2[min].val; /*mprintf("\tMinOut: %D to %D\n", mypmat[other], other);*/ idxset(nparts, 0, otherpmat); /* Go and find the vertices in 'other' that are connected in 'me' */ for (nind=0, i=0; i 0) { cand[ncand].key = -otherpmat[i]; cand[ncand++].val = i; } } ikeysort(ncand, cand); /* * Go through and the select the first domain that is common with 'me', and * does not increase the ndoms[target] higher than my ndoms, subject to the * maxpwgt constraint. Traversal is done from the mostly connected to the least. */ target = target2 = -1; for (i=0; i 0) { if (pwgts[k] + cpwgt > maxpwgt[k]) /* Check if balance will go off */ continue; for (j=0; j 0 && ndoms[j] >= ndoms[me]-1 && pmat[nparts*j+k] == 0) break; } if (j == nparts) { /* No bad second level effects */ for (nadd=0, j=0; j 0 && pmat[nparts*k+j] == 0) nadd++; } /*mprintf("\t\tto=%D, nadd=%D, %D\n", k, nadd, ndoms[k]);*/ if (target2 == -1 && ndoms[k]+nadd < ndoms[me]) { target2 = k; } if (nadd == 0) { target = k; break; } } } } if (target == -1 && target2 != -1) target = target2; if (target == -1) { /* mprintf("\t\tCould not make the move\n");*/ continue; } /*mprintf("\t\tMoving to %D\n", target);*/ /* Update the partition weights */ INC_DEC(pwgts[target], pwgts[other], cpwgt); MoveGroupMConn(ctrl, graph, ndoms, pmat, nparts, target, nind, ind); move = 1; break; } if (move == 0) break; } idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nvtxs); gk_free((void **)&cand, &cand2, LTERM); } /************************************************************************* * This function moves a collection of vertices and updates their rinfo **************************************************************************/ void MoveGroupMConn(CtrlType *ctrl, GraphType *graph, idxtype *ndoms, idxtype *pmat, idxtype nparts, idxtype to, idxtype nind, idxtype *ind) { idxtype i, ii, iii, j, jj, k, l, nvtxs, nbnd, myndegrees; idxtype from, me; idxtype *xadj, *adjncy, *adjwgt; idxtype *where, *bndptr, *bndind; EDegreeType *myedegrees; RInfoType *myrinfo; nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; adjwgt = graph->adjwgt; where = graph->where; bndptr = graph->bndptr; bndind = graph->bndind; nbnd = graph->nbnd; for (iii=0; iiirinfo+i; if (myrinfo->edegrees == NULL) { myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree; ctrl->wspace.cdegree += xadj[i+1]-xadj[i]; myrinfo->ndegrees = 0; } myedegrees = myrinfo->edegrees; /* find the location of 'to' in myrinfo or create it if it is not there */ for (k=0; kndegrees; k++) { if (myedegrees[k].pid == to) break; } if (k == myrinfo->ndegrees) { myedegrees[k].pid = to; myedegrees[k].ed = 0; myrinfo->ndegrees++; } graph->mincut -= myedegrees[k].ed-myrinfo->id; /* Update pmat to reflect the move of 'i' */ pmat[from*nparts+to] += (myrinfo->id-myedegrees[k].ed); pmat[to*nparts+from] += (myrinfo->id-myedegrees[k].ed); if (pmat[from*nparts+to] == 0) ndoms[from]--; if (pmat[to*nparts+from] == 0) ndoms[to]--; /* Update where, weight, and ID/ED information of the vertex you moved */ where[i] = to; myrinfo->ed += myrinfo->id-myedegrees[k].ed; SWAP(myrinfo->id, myedegrees[k].ed, j); if (myedegrees[k].ed == 0) myedegrees[k] = myedegrees[--myrinfo->ndegrees]; else myedegrees[k].pid = from; if (myrinfo->ed-myrinfo->id < 0 && bndptr[i] != -1) BNDDelete(nbnd, bndind, bndptr, i); /* Update the degrees of adjacent vertices */ for (j=xadj[i]; jrinfo+ii; if (myrinfo->edegrees == NULL) { myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree; ctrl->wspace.cdegree += xadj[ii+1]-xadj[ii]; } myedegrees = myrinfo->edegrees; ASSERT(CheckRInfo(myrinfo)); if (me == from) { INC_DEC(myrinfo->ed, myrinfo->id, adjwgt[j]); if (myrinfo->ed-myrinfo->id >= 0 && bndptr[ii] == -1) BNDInsert(nbnd, bndind, bndptr, ii); } else if (me == to) { INC_DEC(myrinfo->id, myrinfo->ed, adjwgt[j]); if (myrinfo->ed-myrinfo->id < 0 && bndptr[ii] != -1) BNDDelete(nbnd, bndind, bndptr, ii); } /* Remove contribution from the .ed of 'from' */ if (me != from) { for (k=0; kndegrees; k++) { if (myedegrees[k].pid == from) { if (myedegrees[k].ed == adjwgt[j]) myedegrees[k] = myedegrees[--myrinfo->ndegrees]; else myedegrees[k].ed -= adjwgt[j]; break; } } } /* Add contribution to the .ed of 'to' */ if (me != to) { for (k=0; kndegrees; k++) { if (myedegrees[k].pid == to) { myedegrees[k].ed += adjwgt[j]; break; } } if (k == myrinfo->ndegrees) { myedegrees[myrinfo->ndegrees].pid = to; myedegrees[myrinfo->ndegrees++].ed = adjwgt[j]; } } /* Update pmat to reflect the move of 'i' for domains other than 'from' and 'to' */ if (me != from && me != to) { pmat[me*nparts+from] -= adjwgt[j]; pmat[from*nparts+me] -= adjwgt[j]; if (pmat[me*nparts+from] == 0) ndoms[me]--; if (pmat[from*nparts+me] == 0) ndoms[from]--; if (pmat[me*nparts+to] == 0) ndoms[me]++; if (pmat[to*nparts+me] == 0) ndoms[to]++; pmat[me*nparts+to] += adjwgt[j]; pmat[to*nparts+me] += adjwgt[j]; } ASSERT(CheckRInfo(myrinfo)); } ASSERT(CheckRInfo(graph->rinfo+i)); } graph->nbnd = nbnd; } /************************************************************************* * This function finds all the connected components induced by the * partitioning vector in wgraph->where and tries to push them around to * remove some of them **************************************************************************/ void EliminateComponents(CtrlType *ctrl, GraphType *graph, idxtype nparts, float *tpwgts, float ubfactor) { idxtype i, ii, j, jj, k, me, nvtxs, tvwgt, first, last, nleft, ncmps, cwgt, other, target, deltawgt; idxtype *xadj, *adjncy, *vwgt, *adjwgt, *where, *pwgts, *maxpwgt; idxtype *cpvec, *touched, *perm, *todo, *cind, *cptr, *npcmps; nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; vwgt = graph->vwgt; adjwgt = graph->adjwgt; where = graph->where; pwgts = graph->pwgts; touched = idxset(nvtxs, 0, idxwspacemalloc(ctrl, nvtxs)); cptr = idxwspacemalloc(ctrl, nvtxs+1); cind = idxwspacemalloc(ctrl, nvtxs); perm = idxwspacemalloc(ctrl, nvtxs); todo = idxwspacemalloc(ctrl, nvtxs); maxpwgt = idxwspacemalloc(ctrl, nparts); cpvec = idxwspacemalloc(ctrl, nparts); npcmps = idxset(nparts, 0, idxwspacemalloc(ctrl, nparts)); for (i=0; i 0) { if (first == last) { /* Find another starting vertex */ cptr[++ncmps] = first; ASSERT(touched[todo[0]] == 0); i = todo[0]; cind[last++] = i; touched[i] = 1; me = where[i]; npcmps[me]++; } i = cind[first++]; k = perm[i]; j = todo[k] = todo[--nleft]; perm[j] = k; for (j=xadj[i]; j nparts) { /* There are more components than processors */ /* First determine the max allowed load imbalance */ tvwgt = idxsum(nparts, pwgts, 1); for (i=0; i .30*pwgts[me]) continue; /* Skip the component if it is over 30% of the weight */ /* Determine the connectivity */ idxset(nparts, 0, cpvec); for (j=cptr[i]; j 0 && (cwgt < deltawgt || pwgts[j] + cwgt < maxpwgt[j])) { if (target == -1 || cpvec[target] < cpvec[j]) target = j; } } /* mprintf("\tMoving it to %D [%D]\n", target, cpvec[target]);*/ if (target != -1) { /* Assign all the vertices of 'me' to 'target' and update data structures */ INC_DEC(pwgts[target], pwgts[me], cwgt); npcmps[me]--; MoveGroup(ctrl, graph, nparts, target, i, cptr, cind); } } } idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nparts); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs); idxwspacefree(ctrl, nvtxs+1); } /************************************************************************* * This function moves a collection of vertices and updates their rinfo **************************************************************************/ void MoveGroup(CtrlType *ctrl, GraphType *graph, idxtype nparts, idxtype to, idxtype gid, idxtype *ptr, idxtype *ind) { idxtype i, ii, iii, j, jj, k, l, nvtxs, nbnd, myndegrees; idxtype from, me; idxtype *xadj, *adjncy, *adjwgt; idxtype *where, *bndptr, *bndind; EDegreeType *myedegrees; RInfoType *myrinfo; nvtxs = graph->nvtxs; xadj = graph->xadj; adjncy = graph->adjncy; adjwgt = graph->adjwgt; where = graph->where; bndptr = graph->bndptr; bndind = graph->bndind; nbnd = graph->nbnd; for (iii=ptr[gid]; iiirinfo+i; if (myrinfo->edegrees == NULL) { myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree; ctrl->wspace.cdegree += xadj[i+1]-xadj[i]; myrinfo->ndegrees = 0; } myedegrees = myrinfo->edegrees; /* find the location of 'to' in myrinfo or create it if it is not there */ for (k=0; kndegrees; k++) { if (myedegrees[k].pid == to) break; } if (k == myrinfo->ndegrees) { myedegrees[k].pid = to; myedegrees[k].ed = 0; myrinfo->ndegrees++; } graph->mincut -= myedegrees[k].ed-myrinfo->id; /* Update where, weight, and ID/ED information of the vertex you moved */ where[i] = to; myrinfo->ed += myrinfo->id-myedegrees[k].ed; SWAP(myrinfo->id, myedegrees[k].ed, j); if (myedegrees[k].ed == 0) myedegrees[k] = myedegrees[--myrinfo->ndegrees]; else myedegrees[k].pid = from; if (myrinfo->ed-myrinfo->id < 0 && bndptr[i] != -1) BNDDelete(nbnd, bndind, bndptr, i); /* Update the degrees of adjacent vertices */ for (j=xadj[i]; jrinfo+ii; if (myrinfo->edegrees == NULL) { myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree; ctrl->wspace.cdegree += xadj[ii+1]-xadj[ii]; } myedegrees = myrinfo->edegrees; ASSERT(CheckRInfo(myrinfo)); if (me == from) { INC_DEC(myrinfo->ed, myrinfo->id, adjwgt[j]); if (myrinfo->ed-myrinfo->id >= 0 && bndptr[ii] == -1) BNDInsert(nbnd, bndind, bndptr, ii); } else if (me == to) { INC_DEC(myrinfo->id, myrinfo->ed, adjwgt[j]); if (myrinfo->ed-myrinfo->id < 0 && bndptr[ii] != -1) BNDDelete(nbnd, bndind, bndptr, ii); } /* Remove contribution from the .ed of 'from' */ if (me != from) { for (k=0; kndegrees; k++) { if (myedegrees[k].pid == from) { if (myedegrees[k].ed == adjwgt[j]) myedegrees[k] = myedegrees[--myrinfo->ndegrees]; else myedegrees[k].ed -= adjwgt[j]; break; } } } /* Add contribution to the .ed of 'to' */ if (me != to) { for (k=0; kndegrees; k++) { if (myedegrees[k].pid == to) { myedegrees[k].ed += adjwgt[j]; break; } } if (k == myrinfo->ndegrees) { myedegrees[myrinfo->ndegrees].pid = to; myedegrees[myrinfo->ndegrees++].ed = adjwgt[j]; } } ASSERT(CheckRInfo(myrinfo)); } ASSERT(CheckRInfo(graph->rinfo+i)); } graph->nbnd = nbnd; } PyMetis-0.90/src/metis/timing.c0000640000175000017500000000470210662171744016222 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * timing.c * * This file contains routines that deal with timing Metis * * Started 7/24/97 * George * * $Id: timing.c,v 1.2 2002/08/10 06:29:34 karypis Exp $ * */ #include /************************************************************************* * This function clears the timers **************************************************************************/ void InitTimers(CtrlType *ctrl) { gk_clearcputimer(ctrl->TotalTmr); gk_clearcputimer(ctrl->InitPartTmr); gk_clearcputimer(ctrl->MatchTmr); gk_clearcputimer(ctrl->ContractTmr); gk_clearcputimer(ctrl->CoarsenTmr); gk_clearcputimer(ctrl->UncoarsenTmr); gk_clearcputimer(ctrl->RefTmr); gk_clearcputimer(ctrl->ProjectTmr); gk_clearcputimer(ctrl->SplitTmr); gk_clearcputimer(ctrl->SepTmr); gk_clearcputimer(ctrl->AuxTmr1); gk_clearcputimer(ctrl->AuxTmr2); gk_clearcputimer(ctrl->AuxTmr3); gk_clearcputimer(ctrl->AuxTmr4); gk_clearcputimer(ctrl->AuxTmr5); gk_clearcputimer(ctrl->AuxTmr6); } /************************************************************************* * This function prints the various timers **************************************************************************/ void PrintTimers(CtrlType *ctrl) { mprintf("\nTiming Information -------------------------------------------------"); mprintf("\n Multilevel: \t\t %7.3f", gk_getcputimer(ctrl->TotalTmr)); mprintf("\n Coarsening: \t\t %7.3f", gk_getcputimer(ctrl->CoarsenTmr)); mprintf("\n Matching: \t\t\t %7.3f", gk_getcputimer(ctrl->MatchTmr)); mprintf("\n Contract: \t\t\t %7.3f", gk_getcputimer(ctrl->ContractTmr)); mprintf("\n Initial Partition: \t %7.3f", gk_getcputimer(ctrl->InitPartTmr)); mprintf("\n Construct Separator: \t %7.3f", gk_getcputimer(ctrl->SepTmr)); mprintf("\n Uncoarsening: \t\t %7.3f", gk_getcputimer(ctrl->UncoarsenTmr)); mprintf("\n Refinement: \t\t\t %7.3f", gk_getcputimer(ctrl->RefTmr)); mprintf("\n Projection: \t\t\t %7.3f", gk_getcputimer(ctrl->ProjectTmr)); mprintf("\n Splitting: \t\t %7.3f", gk_getcputimer(ctrl->SplitTmr)); mprintf("\n AUX1: \t\t %7.3f", gk_getcputimer(ctrl->AuxTmr1)); mprintf("\n AUX2: \t\t %7.3f", gk_getcputimer(ctrl->AuxTmr2)); mprintf("\n AUX3: \t\t %7.3f", gk_getcputimer(ctrl->AuxTmr3)); mprintf("\n********************************************************************\n"); } PyMetis-0.90/src/metis/util.c0000640000175000017500000000613210662171744015707 0ustar andreasandreas/* * Copyright 1997, Regents of the University of Minnesota * * util.c * * This function contains various utility routines * * Started 9/28/95 * George * * $Id: util.c,v 1.4 2003/04/13 04:45:12 karypis Exp $ */ #include /************************************************************************* * The following are utility functions defined for idxtype using GKlib's * function generating macros **************************************************************************/ GK_XMALLOC(idxmalloc, idxtype) GK_XREALLOC(idxrealloc, idxtype) GK_XSMALLOC(idxsmalloc, idxtype, idxset) GK_SET(idxset, idxtype) GK_ARGMAX(idxargmax, idxtype) GK_ARGMIN(idxargmin, idxtype) GK_SUM(idxsum, idxtype, idxtype) GK_AXPY(idxaxpy, idxtype) /************************************************************************* * These functions return the index of the maximum element in a vector **************************************************************************/ idxtype idxargmax_strd(size_t n, idxtype *x, idxtype incx) { size_t i, max=0; n *= incx; for (i=incx; i x[max] ? i : max); return max/incx; } /************************************************************************* * These functions return the index of the almost maximum element in a vector **************************************************************************/ idxtype famax2(size_t n, float *x) { size_t i, max1, max2; if (x[0] > x[1]) { max1 = 0; max2 = 1; } else { max1 = 1; max2 = 0; } for (i=2; i x[max1]) { max2 = max1; max1 = i; } else if (x[i] > x[max2]) max2 = i; } return max2; } /************************************************************************* * This file randomly permutes the contents of an array. * flag == 0, don't initialize perm * flag == 1, set p[i] = i **************************************************************************/ void RandomPermute(size_t n, idxtype *p, idxtype flag) { size_t i, u, v; idxtype tmp; if (flag == 1) { for (i=0; i 8: recursive = False else: recursive = True from pymetis._internal import part_graph if adjacency is not None: assert xadj is None assert adjncy is None xadj = [0] adjncy = [] for i in range(len(adjacency)): adj = adjacency[i] adjncy += adj xadj.append(len(adjncy)) else: assert xadj is not None assert adjncy is not None return part_graph(nparts, xadj, adjncy, vweights, eweights, recursive) PyMetis-0.90/src/wrapper/0000755000175000017500000000000010662401137015117 5ustar andreasandreasPyMetis-0.90/src/wrapper/wrapper.cpp0000644000175000017500000000341110662215262017304 0ustar andreasandreas#include #include #include #include #include #include #include using namespace boost::python; using namespace std; #define COPY_IDXTYPE_LIST(NAME) \ { \ stl_input_iterator begin(NAME##_py), end; \ std::copy(begin, end, back_inserter(NAME)); \ } #define ITL(NAME) (const_cast(NAME.data())) #define COPY_OUTPUT(NAME, LEN) \ list NAME##_py; \ { \ BOOST_FOREACH(idxtype i, std::make_pair(NAME.get(), NAME.get()+(LEN))) \ NAME##_py.append(i); \ } namespace { object wrap_part_graph( int nparts, const object &xadj_py, const object &adjncy_py, const object &vwgt_py, const object &adjwgt_py, bool recursive) { int n = len(xadj_py) - 1; vector xadj, adjncy, vwgt, adjwgt; COPY_IDXTYPE_LIST(xadj); COPY_IDXTYPE_LIST(adjncy); int wgtflag = 0; if (vwgt_py != object()) { COPY_IDXTYPE_LIST(vwgt); wgtflag |= 2; } if (adjwgt_py != object()) { COPY_IDXTYPE_LIST(adjwgt); wgtflag |= 1; } int numflag = 0; int options[5]; options[0] = 0; int edgecut; boost::scoped_array part(new idxtype[n]); if (recursive) METIS_PartGraphRecursive(&n, ITL(xadj), ITL(adjncy), ITL(vwgt), ITL(adjwgt), &wgtflag, &numflag, &nparts, options, &edgecut, part.get()); else METIS_PartGraphKway(&n, ITL(xadj), ITL(adjncy), ITL(vwgt), ITL(adjwgt), &wgtflag, &numflag, &nparts, options, &edgecut, part.get()); COPY_OUTPUT(part, n); return make_tuple(edgecut, part_py); } } BOOST_PYTHON_MODULE(_internal) { def("part_graph", wrap_part_graph); } PyMetis-0.90/test/0000755000175000017500000000000010662401137013627 5ustar andreasandreasPyMetis-0.90/test/test_metis.py0000644000175000017500000000324310662372244016371 0ustar andreasandreasdef main(): from math import pi, cos, sin from meshpy.tet import MeshInfo, build, generate_surface_of_revolution,\ EXT_CLOSED_IN_RZ big_r = 3 little_r = 1.5 points = 50 dphi = 2*pi/points rz = [(big_r+little_r*cos(i*dphi), little_r*sin(i*dphi)) for i in range(points)] mesh_info = MeshInfo() points, facets = generate_surface_of_revolution(rz, closure=EXT_CLOSED_IN_RZ, radial_subdiv=20) mesh_info.set_points(points) mesh_info.set_facets(facets, len(facets) *[1]) mesh = build(mesh_info) def tet_face_vertices(vertices): return [(vertices[0],vertices[1],vertices[2]), (vertices[0],vertices[1],vertices[3]), (vertices[0],vertices[2],vertices[3]), (vertices[1],vertices[2],vertices[3]), ] face_map = {} for el_id, el in enumerate(mesh.elements): for fid, face_vertices in enumerate(tet_face_vertices(el)): face_map.setdefault(frozenset(face_vertices), []).append((el_id, fid)) adjacency = {} for face_vertices, els_faces in face_map.iteritems(): if len(els_faces) == 2: (e1, f1), (e2, f2) = els_faces adjacency.setdefault(e1, []).append(e2) adjacency.setdefault(e2, []).append(e1) from pymetis import part_graph cuts, part_vert = part_graph(17, adjacency) import pyvtk vtkelements = pyvtk.VtkData( pyvtk.UnstructuredGrid(mesh.points, tetra=mesh.elements), "Mesh", pyvtk.CellData(pyvtk.Scalars(part_vert, name="partition"))) vtkelements.tofile('split.vtk') if __name__ == "__main__": main() PyMetis-0.90/LICENSE0000640000175000017500000000463710662170474013672 0ustar andreasandreasCopyright Notice for METIS -------------------------- The METIS package is copyrighted by the Regents of the University of Minnesota. It can be freely used for educational and research purposes by non-profit institutions and US government agencies only. Other organizations are allowed to use METIS only for evaluation purposes, and any further uses will require prior approval. The software may not be sold or redistributed without prior approval. One may make copies of the software for their use provided that the copies, are not sold or distributed, are used under the same terms and conditions. As unestablished research software, this code is provided on an ``as is'' basis without warranty of any kind, either expressed or implied. The downloading, or executing any part of this software constitutes an implicit agreement to these terms. These terms and conditions are subject to change at any time without prior notice. Copyright Notice for the Wrapper -------------------------------- The wrapper is licensed to you under the following terms: Copyright (c) Andreas Kloeckner All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. None of the authors' names may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. PyMetis-0.90/Makefile.in0000644000175000017500000000026410662170237014723 0ustar andreasandreas.PHONY : all install clean tags all: tags ${PYTHON_EXE} setup.py build install: tags ${PYTHON_EXE} setup.py install clean: rm -Rf build rm tags tags: ctags -R src || true PyMetis-0.90/README0000644000175000017500000000047010662172220013527 0ustar andreasandreasWelcome to PyMetis, a Python wrapper for Metis. ----------------------------------------------- This code wraps (and includes a copy of) Metis 5.0pre2. Metis is the work of the George Karypis, Vipin Kumar and others at UMN. It may be downloaded from http://glaros.dtc.umn.edu/gkhome/metis/metis/overview. PyMetis-0.90/configure0000755000175000017500000000454410662167260014574 0ustar andreasandreas#! /usr/bin/env python def var_to_option(caps_name): return "--" + caps_name.lower().replace("_", "-") def var_kind(caps_name): last_underscore = caps_name.rfind("_") return caps_name[last_underscore+1:] if __name__ == "__main__": from optparse import OptionParser execfile("configvars.py") description = "generate a siteconf.py file for this software package" parser = OptionParser(description=description) parser.add_option( "--python-exe", dest="python_exe", default="python", help="Which Python interpreter to use", metavar="PATH") for var, default, help in vars: option = var_to_option if default: help += " (default: %s)" % default parser.add_option( var_to_option(var), dest=var.lower(), default=default, metavar=var_kind(var), help=help) parser.add_option("--prefix", default=None, help="Ignored") parser.add_option("--enable-shared", help="Ignored", action="store_false") parser.add_option("--disable-static", help="Ignored", action="store_false") options, args = parser.parse_args() substitutions = { "PYTHON_EXE": options.python_exe } for var, default, help in vars: substitutions[var] = getattr(options, var.lower()) import re var_re = re.compile(r"\$\{([A-Za-z_0-9]+)\}") string_var_re = re.compile(r"\$str\{([A-Za-z_0-9]+)\}") for fname in subst_files: lines = open(fname+".in", "r").readlines() new_lines = [] for l in lines: made_change = True while made_change: made_change = False match = var_re.search(l) if match: varname = match.group(1) l = l[:match.start()] + substitutions[varname] + l[match.end():] made_change = True match = string_var_re.search(l) if match: varname = match.group(1) subst = substitutions[varname] if subst is None: subst = "" else: subst = '"%s"' % subst l = l[:match.start()] + subst + l[match.end():] made_change = True new_lines.append(l) file(fname, "w").write("".join(new_lines)) PyMetis-0.90/configvars.py0000644000175000017500000000066110662167254015377 0ustar andreasandreasvars = [ ("BOOST_INC_DIR", None, "The include directory for all of Boost C++"), ("BOOST_LIB_DIR", None, "The library directory for all of Boost C++"), ("BOOST_PYTHON_LIBNAME", "boost_python-gcc41-mt", "The name of the Boost Python library binary (without lib and .so)"), ("CXXFLAGS", None, "Any extra C++ compiler options to include"), ] subst_files = ["Makefile", "siteconf.py"] PyMetis-0.90/import-metis.sh0000755000175000017500000000043010662215212015632 0ustar andreasandreas#! /bin/sh set -e if test "$1" = ""; then echo "usage: $0 path-to-metis" exit 1 fi rm src/gklib/*.{c,h} cp $1/GKlib/trunk/*.{c,h} src/gklib/ rm src/metis/*.{c,h} cp $1/include/*.h src/metis/ cp $1/libmetis/*.{c,h} src/metis/ rm src/metis/kfmetis.c patch -p0 < metis.patch PyMetis-0.90/metis.patch0000644000175000017500000000040610662171644015021 0ustar andreasandreas--- src/metis/metislib.h~ 2007-08-19 21:49:36.000000000 -0400 +++ src/metis/metislib.h 2007-08-19 21:51:13.000000000 -0400 @@ -45,6 +45,6 @@ #if defined(COMPILER_GCC) -extern char* strdup (const char *); +/* extern char* strdup (const char *); */ #endif PyMetis-0.90/setup.py0000644000175000017500000000252010662205526014365 0ustar andreasandreas#!/usr/bin/env python import sys import glob try: execfile("siteconf.py") except IOError: print "*** Please run configure first." sys.exit(1) from distutils.core import setup,Extension def non_matching_config(): print "*** The version of your configuration template does not match" print "*** the version of the setup script. Please re-run configure." sys.exit(1) try: PYMETIS_CONF_TEMPLATE_VERSION except NameError: non_matching_config() if PYMETIS_CONF_TEMPLATE_VERSION != 1: non_matching_config() INCLUDE_DIRS = BOOST_INCLUDE_DIRS LIBRARY_DIRS = BOOST_LIBRARY_DIRS LIBRARIES = BPL_LIBRARIES execfile("src/python/__init__.py") setup(name="PyMetis", version=version, description="A wrapper around Metis", author="Andreas Kloeckner", author_email="inform@tiker.net", license = "BSD for the wrapper/", url="http://news.tiker.net/software/pymetis", packages = [ "pymetis" ], package_dir={"pymetis": "src/python"}, ext_modules = [ Extension( "pymetis._internal", glob.glob("src/gklib/*.c") + glob.glob("src/metis/*.c") + ["src/wrapper/wrapper.cpp"], include_dirs=["src/gklib", "src/metis"] + INCLUDE_DIRS, library_dirs=LIBRARY_DIRS, libraries=LIBRARIES, ), ] ) PyMetis-0.90/siteconf.py.in0000644000175000017500000000133610662170104015441 0ustar andreasandreas# -------------------------------------------------------------------- # Specify your configuration below. # See documentation for hints. # -------------------------------------------------------------------- PYMETIS_CONF_TEMPLATE_VERSION = 1 # -------------------------------------------------------------------- # Path options # -------------------------------------------------------------------- BOOST_INCLUDE_DIRS = [$str{BOOST_INC_DIR}] BOOST_LIBRARY_DIRS = [$str{BOOST_LIB_DIR}] BPL_LIBRARIES = [$str{BOOST_PYTHON_LIBNAME}] # -------------------------------------------------------------------- # Compiler flags # -------------------------------------------------------------------- EXTRA_COMPILE_ARGS = [$str{CXXFLAGS}] PyMetis-0.90/PKG-INFO0000644000175000017500000000040210662401137013741 0ustar andreasandreasMetadata-Version: 1.0 Name: PyMetis Version: 0.90 Summary: A wrapper around Metis Home-page: http://news.tiker.net/software/pymetis Author: Andreas Kloeckner Author-email: inform@tiker.net License: BSD for the wrapper/ Description: UNKNOWN Platform: UNKNOWN