heap.hpp cstring cstdlib algorithm /usr/include/gecode/support.hh Gecode::Heap Gecode GECODE_SUPPORT_REALLOC T template<> \ forceinline T* \ Heap::realloc<T>(T* b, long unsigned int, long unsigned int m) { \ return static_cast<T*>(rrealloc(b,m*sizeof(T))); \ } \ template<> \ forceinline T* \ Heap::realloc<T>(T* b, long int n, long int m) { \ assert((n >= 0) && (m >= 0)); \ return realloc<T>(b,static_cast<long unsigned int>(n), \ static_cast<long unsigned int>(m)); \ } \ template<> \ forceinline T* \ Heap::realloc<T>(T* b, unsigned int n, unsigned int m) { \ return realloc<T>(b,static_cast<long unsigned int>(n), \ static_cast<long unsigned int>(m)); \ } \ template<> \ forceinline T* \ Heap::realloc<T>(T* b, int n, int m) { \ assert((n >= 0) && (m >= 0)); \ return realloc<T>(b,static_cast<long unsigned int>(n), \ static_cast<long unsigned int>(m)); \ } GECODE_SUPPORT_COPY T template<> \ forceinline T* \ Heap::copy(T* d, const T* s, long unsigned int n) { \ return static_cast<T*>(memcpy(d,s,n*sizeof(T))); \ } \ template<> \ forceinline T* \ Heap::copy(T* d, const T* s, long int n) { \ assert(n >= 0); \ return copy<T>(d,s,static_cast<long unsigned int>(n)); \ } \ template<> \ forceinline T* \ Heap::copy(T* d, const T* s, unsigned int n) { \ return copy<T>(d,s,static_cast<long unsigned int>(n)); \ } \ template<> \ forceinline T* \ Heap::copy(T* d, const T* s, int n) { \ assert(n >= 0); \ return copy<T>(d,s,static_cast<long unsigned int>(n)); \ } /*-*-mode:C++;c-basic-offset:2;indent-tabs-mode:nil-*-*/ /* *Mainauthors: *ChristianSchulte<schulte@gecode.org> * *Copyright: *ChristianSchulte,2008 * *Lastmodified: *$Date:2013-07-1502:49:56+0200(Mon,15Jul2013)$by$Author:tack$ *$Revision:13879$ * *ThisfileispartofGecode,thegenericconstraint *developmentenvironment: *http://www.gecode.org * *Permissionisherebygranted,freeofcharge,toanypersonobtaining *acopyofthissoftwareandassociateddocumentationfiles(the *"Software"),todealintheSoftwarewithoutrestriction,including *withoutlimitationtherightstouse,copy,modify,merge,publish, *distribute,sublicense,and/orsellcopiesoftheSoftware,andto *permitpersonstowhomtheSoftwareisfurnishedtodoso,subjectto *thefollowingconditions: * *Theabovecopyrightnoticeandthispermissionnoticeshallbe *includedinallcopiesorsubstantialportionsoftheSoftware. * *THESOFTWAREISPROVIDED"ASIS",WITHOUTWARRANTYOFANYKIND, *EXPRESSORIMPLIED,INCLUDINGBUTNOTLIMITEDTOTHEWARRANTIESOF *MERCHANTABILITY,FITNESSFORAPARTICULARPURPOSEAND *NONINFRINGEMENT.INNOEVENTSHALLTHEAUTHORSORCOPYRIGHTHOLDERSBE *LIABLEFORANYCLAIM,DAMAGESOROTHERLIABILITY,WHETHERINANACTION *OFCONTRACT,TORTOROTHERWISE,ARISINGFROM,OUTOFORINCONNECTION *WITHTHESOFTWAREORTHEUSEOROTHERDEALINGSINTHESOFTWARE. * */ #include<cstring> #include<cstdlib> #include<algorithm> #ifdefGECODE_PEAKHEAP_MALLOC_H #include<malloc.h> #endif #ifdefGECODE_PEAKHEAP_MALLOC_MALLOC_H #include<malloc/malloc.h> #endif namespaceGecode{ classHeap{ public: Heap(void); template<classT> T*alloc(longunsignedintn); template<classT> T*alloc(longintn); template<classT> T*alloc(unsignedintn); template<classT> T*alloc(intn); template<classT> voidfree(T*b,longunsignedintn); template<classT> voidfree(T*b,longintn); template<classT> voidfree(T*b,unsignedintn); template<classT> voidfree(T*b,intn); template<classT> T*realloc(T*b,longunsignedintn,longunsignedintm); template<classT> T*realloc(T*b,longintn,longintm); template<classT> T*realloc(T*b,unsignedintn,unsignedintm); template<classT> T*realloc(T*b,intn,intm); template<classT> T**realloc(T**b,longunsignedintn,longunsignedintm); template<classT> T**realloc(T**b,longintn,longintm); template<classT> T**realloc(T**b,unsignedintn,unsignedintm); template<classT> T**realloc(T**b,intn,intm); template<classT> staticT*copy(T*d,constT*s,longunsignedintn); template<classT> staticT*copy(T*d,constT*s,longintn); template<classT> staticT*copy(T*d,constT*s,unsignedintn); template<classT> staticT*copy(T*d,constT*s,intn); template<classT> staticT**copy(T**d,constT**s,longunsignedintn); template<classT> staticT**copy(T**d,constT**s,longintn); template<classT> staticT**copy(T**d,constT**s,unsignedintn); template<classT> staticT**copy(T**d,constT**s,intn); void*ralloc(size_ts); voidrfree(void*p); voidrfree(void*p,size_ts); void*rrealloc(void*p,size_ts); private: staticvoid*operatornew(size_ts)throw(){(void)s;returnNULL;} staticvoidoperatordelete(void*p){(void)p;}; Heap(constHeap&){} constHeap&operator=(constHeap&){return*this;} #ifdefGECODE_PEAKHEAP Support::FastMutex_m; size_t_peak; size_t_cur; public: size_tpeak(void); #endif }; externGECODE_SUPPORT_EXPORTHeapheap; /* *Wrappersforrawallocationroutines * */ forceinlinevoid* Heap::ralloc(size_ts){ void*p=::malloc(s); #ifdefGECODE_PEAKHEAP _m.acquire(); _cur+=GECODE_MSIZE(p); _peak=std::max(_peak,_cur); _m.release(); #endif if(p!=NULL) returnp; throwMemoryExhausted(); } forceinlinevoid Heap::rfree(void*p){ #ifdefGECODE_PEAKHEAP _m.acquire(); _cur-=GECODE_MSIZE(p); _m.release(); #endif ::free(p); } forceinlinevoid Heap::rfree(void*p,size_t){ #ifdefGECODE_PEAKHEAP _m.acquire(); _cur-=GECODE_MSIZE(p); _m.release(); #endif ::free(p); } forceinlinevoid* Heap::rrealloc(void*p,size_ts){ #ifdefGECODE_PEAKHEAP _m.acquire(); _cur-=GECODE_MSIZE(p); _m.release(); #endif p=::realloc(p,s); #ifdefGECODE_PEAKHEAP _m.acquire(); _cur+=GECODE_MSIZE(p); _peak=std::max(_peak,_cur); _m.release(); #endif if(p!=NULL||s==0) returnp; throwMemoryExhausted(); } /* *Typedallocationroutines * */ template<classT> forceinlineT* Heap::alloc(longunsignedintn){ T*p=static_cast<T*>(ralloc(sizeof(T)*n)); for(longunsignedinti=n;i--;) (void)new(p+i)T(); returnp; } template<classT> forceinlineT* Heap::alloc(longintn){ assert(n>=0); returnalloc<T>(static_cast<longunsignedint>(n)); } template<classT> forceinlineT* Heap::alloc(unsignedintn){ returnalloc<T>(static_cast<longunsignedint>(n)); } template<classT> forceinlineT* Heap::alloc(intn){ assert(n>=0); returnalloc<T>(static_cast<longunsignedint>(n)); } template<classT> forceinlinevoid Heap::free(T*b,longunsignedintn){ for(longunsignedinti=n;i--;) b[i].~T(); rfree(b); } template<classT> forceinlinevoid Heap::free(T*b,longintn){ assert(n>=0); free<T>(b,static_cast<longunsignedint>(n)); } template<classT> forceinlinevoid Heap::free(T*b,unsignedintn){ free<T>(b,static_cast<longunsignedint>(n)); } template<classT> forceinlinevoid Heap::free(T*b,intn){ assert(n>=0); free<T>(b,static_cast<longunsignedint>(n)); } template<classT> forceinlineT* Heap::realloc(T*b,longunsignedintn,longunsignedintm){ if(n==m) returnb; T*p=static_cast<T*>(ralloc(sizeof(T)*m)); for(longunsignedinti=std::min(n,m);i--;) (void)new(p+i)T(b[i]); for(longunsignedinti=n;i<m;i++) (void)new(p+i)T(); free<T>(b,n); returnp; } template<classT> forceinlineT* Heap::realloc(T*b,longintn,longintm){ assert((n>=0)&&(m>=0)); returnrealloc<T>(b,static_cast<longunsignedint>(n), static_cast<longunsignedint>(m)); } template<classT> forceinlineT* Heap::realloc(T*b,unsignedintn,unsignedintm){ returnrealloc<T>(b,static_cast<longunsignedint>(n), static_cast<longunsignedint>(m)); } template<classT> forceinlineT* Heap::realloc(T*b,intn,intm){ assert((n>=0)&&(m>=0)); returnrealloc<T>(b,static_cast<longunsignedint>(n), static_cast<longunsignedint>(m)); } #defineGECODE_SUPPORT_REALLOC(T)\ template<>\ forceinlineT*\ Heap::realloc<T>(T*b,longunsignedint,longunsignedintm){\ returnstatic_cast<T*>(rrealloc(b,m*sizeof(T)));\ }\ template<>\ forceinlineT*\ Heap::realloc<T>(T*b,longintn,longintm){\ assert((n>=0)&&(m>=0));\ returnrealloc<T>(b,static_cast<longunsignedint>(n),\ static_cast<longunsignedint>(m));\ }\ template<>\ forceinlineT*\ Heap::realloc<T>(T*b,unsignedintn,unsignedintm){\ returnrealloc<T>(b,static_cast<longunsignedint>(n),\ static_cast<longunsignedint>(m));\ }\ template<>\ forceinlineT*\ Heap::realloc<T>(T*b,intn,intm){\ assert((n>=0)&&(m>=0));\ returnrealloc<T>(b,static_cast<longunsignedint>(n),\ static_cast<longunsignedint>(m));\ } GECODE_SUPPORT_REALLOC(bool) GECODE_SUPPORT_REALLOC(signedchar) GECODE_SUPPORT_REALLOC(unsignedchar) GECODE_SUPPORT_REALLOC(signedshortint) GECODE_SUPPORT_REALLOC(unsignedshortint) GECODE_SUPPORT_REALLOC(signedint) GECODE_SUPPORT_REALLOC(unsignedint) GECODE_SUPPORT_REALLOC(signedlongint) GECODE_SUPPORT_REALLOC(unsignedlongint) GECODE_SUPPORT_REALLOC(float) GECODE_SUPPORT_REALLOC(double) #undefGECODE_SUPPORT_REALLOC template<classT> forceinlineT** Heap::realloc(T**b,longunsignedint,longunsignedintm){ returnstatic_cast<T**>(rrealloc(b,m*sizeof(T*))); } template<classT> forceinlineT** Heap::realloc(T**b,longintn,longintm){ assert((n>=0)&&(m>=0)); returnrealloc<T*>(b,static_cast<longunsignedint>(n), static_cast<longunsignedint>(m)); } template<classT> forceinlineT** Heap::realloc(T**b,unsignedintn,unsignedintm){ returnrealloc<T*>(b,static_cast<longunsignedint>(n), static_cast<longunsignedint>(m)); } template<classT> forceinlineT** Heap::realloc(T**b,intn,intm){ assert((n>=0)&&(m>=0)); returnrealloc<T*>(b,static_cast<longunsignedint>(n), static_cast<longunsignedint>(m)); } template<classT> forceinlineT* Heap::copy(T*d,constT*s,longunsignedintn){ for(longunsignedinti=n;i--;) d[i]=s[i]; returnd; } template<classT> forceinlineT* Heap::copy(T*d,constT*s,longintn){ assert(n>=0); returncopy<T>(d,s,static_cast<longunsignedint>(n)); } template<classT> forceinlineT* Heap::copy(T*d,constT*s,unsignedintn){ returncopy<T>(d,s,static_cast<longunsignedint>(n)); } template<classT> forceinlineT* Heap::copy(T*d,constT*s,intn){ assert(n>=0); returncopy<T>(d,s,static_cast<longunsignedint>(n)); } #defineGECODE_SUPPORT_COPY(T)\ template<>\ forceinlineT*\ Heap::copy(T*d,constT*s,longunsignedintn){\ returnstatic_cast<T*>(memcpy(d,s,n*sizeof(T)));\ }\ template<>\ forceinlineT*\ Heap::copy(T*d,constT*s,longintn){\ assert(n>=0);\ returncopy<T>(d,s,static_cast<longunsignedint>(n));\ }\ template<>\ forceinlineT*\ Heap::copy(T*d,constT*s,unsignedintn){\ returncopy<T>(d,s,static_cast<longunsignedint>(n));\ }\ template<>\ forceinlineT*\ Heap::copy(T*d,constT*s,intn){\ assert(n>=0);\ returncopy<T>(d,s,static_cast<longunsignedint>(n));\ } GECODE_SUPPORT_COPY(bool) GECODE_SUPPORT_COPY(signedchar) GECODE_SUPPORT_COPY(unsignedchar) GECODE_SUPPORT_COPY(signedshortint) GECODE_SUPPORT_COPY(unsignedshortint) GECODE_SUPPORT_COPY(signedint) GECODE_SUPPORT_COPY(unsignedint) GECODE_SUPPORT_COPY(signedlongint) GECODE_SUPPORT_COPY(unsignedlongint) GECODE_SUPPORT_COPY(float) GECODE_SUPPORT_COPY(double) #undefGECODE_SUPPORT_COPY template<classT> forceinlineT** Heap::copy(T**d,constT**s,longunsignedintn){ returnstatic_cast<T**>(memcpy(d,s,n*sizeof(T*))); } template<classT> forceinlineT** Heap::copy(T**d,constT**s,longintn){ assert(n>=0); returncopy<T*>(d,s,static_cast<longunsignedint>(n)); } template<classT> forceinlineT** Heap::copy(T**d,constT**s,unsignedintn){ returncopy<T*>(d,s,static_cast<longunsignedint>(n)); } template<classT> forceinlineT** Heap::copy(T**d,constT**s,intn){ assert(n>=0); returncopy<T*>(d,s,static_cast<longunsignedint>(n)); } #ifdefGECODE_PEAKHEAP forceinlinesize_t Heap::peak(void){ _m.acquire(); size_tret=_peak; _m.release(); returnret; } #endif } //STATISTICS:support-any