mirror of
https://github.com/FULU-Foundation/OrcaSlicer-bambulab.git
synced 2026-08-01 11:25:50 +00:00
Initial release
This commit is contained in:
Louis Rossmann
@@ -0,0 +1,222 @@
|
||||
/*<html><pre> -<a href="qh-mem.htm"
|
||||
>-------------------------------</a><a name="TOP">-</a>
|
||||
|
||||
mem.h
|
||||
prototypes for memory management functions
|
||||
|
||||
see qh-mem.htm, mem.c and qset.h
|
||||
|
||||
for error handling, writes message and calls
|
||||
qh_errexit(qhmem_ERRmem, NULL, NULL) if insufficient memory
|
||||
and
|
||||
qh_errexit(qhmem_ERRqhull, NULL, NULL) otherwise
|
||||
|
||||
Copyright (c) 1993-2015 The Geometry Center.
|
||||
$Id: //main/2015/qhull/src/libqhull/mem.h#2 $$Change: 2062 $
|
||||
$DateTime: 2016/01/17 13:13:18 $$Author: bbarber $
|
||||
*/
|
||||
|
||||
#ifndef qhDEFmem
|
||||
#define qhDEFmem 1
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
/*-<a href="qh-mem.htm#TOC"
|
||||
>-------------------------------</a><a name="NOmem">-</a>
|
||||
|
||||
qh_NOmem
|
||||
turn off quick-fit memory allocation
|
||||
|
||||
notes:
|
||||
mem.c implements Quickfit memory allocation for about 20% time
|
||||
savings. If it fails on your machine, try to locate the
|
||||
problem, and send the answer to qhull@qhull.org. If this can
|
||||
not be done, define qh_NOmem to use malloc/free instead.
|
||||
|
||||
#define qh_NOmem
|
||||
*/
|
||||
|
||||
/*-<a href="qh-mem.htm#TOC"
|
||||
>-------------------------------</a><a name="TRACEshort">-</a>
|
||||
|
||||
qh_TRACEshort
|
||||
Trace short and quick memory allocations at T5
|
||||
|
||||
*/
|
||||
#define qh_TRACEshort
|
||||
|
||||
/*-------------------------------------------
|
||||
to avoid bus errors, memory allocation must consider alignment requirements.
|
||||
malloc() automatically takes care of alignment. Since mem.c manages
|
||||
its own memory, we need to explicitly specify alignment in
|
||||
qh_meminitbuffers().
|
||||
|
||||
A safe choice is sizeof(double). sizeof(float) may be used if doubles
|
||||
do not occur in data structures and pointers are the same size. Be careful
|
||||
of machines (e.g., DEC Alpha) with large pointers. If gcc is available,
|
||||
use __alignof__(double) or fmax_(__alignof__(float), __alignof__(void *)).
|
||||
|
||||
see <a href="user.h#MEMalign">qh_MEMalign</a> in user.h for qhull's alignment
|
||||
*/
|
||||
|
||||
#define qhmem_ERRmem 4 /* matches qh_ERRmem in libqhull.h */
|
||||
#define qhmem_ERRqhull 5 /* matches qh_ERRqhull in libqhull.h */
|
||||
|
||||
/*-<a href="qh-mem.htm#TOC"
|
||||
>--------------------------------</a><a name="ptr_intT">-</a>
|
||||
|
||||
ptr_intT
|
||||
for casting a void * to an integer-type that holds a pointer
|
||||
Used for integer expressions (e.g., computing qh_gethash() in poly.c)
|
||||
|
||||
notes:
|
||||
WARN64 -- these notes indicate 64-bit issues
|
||||
On 64-bit machines, a pointer may be larger than an 'int'.
|
||||
qh_meminit()/mem.c checks that 'ptr_intT' holds a 'void*'
|
||||
ptr_intT is typically a signed value, but not necessarily so
|
||||
size_t is typically unsigned, but should match the parameter type
|
||||
Qhull uses int instead of size_t except for system calls such as malloc, qsort, qh_malloc, etc.
|
||||
This matches Qt convention and is easier to work with.
|
||||
*/
|
||||
#if (defined(__MINGW64__)) && defined(_WIN64)
|
||||
typedef long long ptr_intT;
|
||||
#elif (_MSC_VER) && defined(_WIN64)
|
||||
typedef long long ptr_intT;
|
||||
#else
|
||||
typedef long ptr_intT;
|
||||
#endif
|
||||
|
||||
/*-<a href="qh-mem.htm#TOC"
|
||||
>--------------------------------</a><a name="qhmemT">-</a>
|
||||
|
||||
qhmemT
|
||||
global memory structure for mem.c
|
||||
|
||||
notes:
|
||||
users should ignore qhmem except for writing extensions
|
||||
qhmem is allocated in mem.c
|
||||
|
||||
qhmem could be swapable like qh and qhstat, but then
|
||||
multiple qh's and qhmem's would need to keep in synch.
|
||||
A swapable qhmem would also waste memory buffers. As long
|
||||
as memory operations are atomic, there is no problem with
|
||||
multiple qh structures being active at the same time.
|
||||
If you need separate address spaces, you can swap the
|
||||
contents of qhmem.
|
||||
*/
|
||||
typedef struct qhmemT qhmemT;
|
||||
extern qhmemT qhmem;
|
||||
|
||||
#ifndef DEFsetT
|
||||
#define DEFsetT 1
|
||||
typedef struct setT setT; /* defined in qset.h */
|
||||
#endif
|
||||
|
||||
/* Update qhmem in mem.c if add or remove fields */
|
||||
struct qhmemT { /* global memory management variables */
|
||||
int BUFsize; /* size of memory allocation buffer */
|
||||
int BUFinit; /* initial size of memory allocation buffer */
|
||||
int TABLEsize; /* actual number of sizes in free list table */
|
||||
int NUMsizes; /* maximum number of sizes in free list table */
|
||||
int LASTsize; /* last size in free list table */
|
||||
int ALIGNmask; /* worst-case alignment, must be 2^n-1 */
|
||||
void **freelists; /* free list table, linked by offset 0 */
|
||||
int *sizetable; /* size of each freelist */
|
||||
int *indextable; /* size->index table */
|
||||
void *curbuffer; /* current buffer, linked by offset 0 */
|
||||
void *freemem; /* free memory in curbuffer */
|
||||
int freesize; /* size of freemem in bytes */
|
||||
setT *tempstack; /* stack of temporary memory, managed by users */
|
||||
FILE *ferr; /* file for reporting errors when 'qh' may be undefined */
|
||||
int IStracing; /* =5 if tracing memory allocations */
|
||||
int cntquick; /* count of quick allocations */
|
||||
/* Note: removing statistics doesn't effect speed */
|
||||
int cntshort; /* count of short allocations */
|
||||
int cntlong; /* count of long allocations */
|
||||
int freeshort; /* count of short memfrees */
|
||||
int freelong; /* count of long memfrees */
|
||||
int totbuffer; /* total short memory buffers minus buffer links */
|
||||
int totdropped; /* total dropped memory at end of short memory buffers (e.g., freesize) */
|
||||
int totfree; /* total size of free, short memory on freelists */
|
||||
int totlong; /* total size of long memory in use */
|
||||
int maxlong; /* maximum totlong */
|
||||
int totshort; /* total size of short memory in use */
|
||||
int totunused; /* total unused short memory (estimated, short size - request size of first allocations) */
|
||||
int cntlarger; /* count of setlarger's */
|
||||
int totlarger; /* total copied by setlarger */
|
||||
};
|
||||
|
||||
|
||||
/*==================== -macros ====================*/
|
||||
|
||||
/*-<a href="qh-mem.htm#TOC"
|
||||
>--------------------------------</a><a name="memalloc_">-</a>
|
||||
|
||||
qh_memalloc_(insize, freelistp, object, type)
|
||||
returns object of size bytes
|
||||
assumes size<=qhmem.LASTsize and void **freelistp is a temp
|
||||
*/
|
||||
|
||||
#if defined qh_NOmem
|
||||
#define qh_memalloc_(insize, freelistp, object, type) {\
|
||||
object= (type*)qh_memalloc(insize); }
|
||||
#elif defined qh_TRACEshort
|
||||
#define qh_memalloc_(insize, freelistp, object, type) {\
|
||||
freelistp= NULL; /* Avoid warnings */ \
|
||||
object= (type*)qh_memalloc(insize); }
|
||||
#else /* !qh_NOmem */
|
||||
|
||||
#define qh_memalloc_(insize, freelistp, object, type) {\
|
||||
freelistp= qhmem.freelists + qhmem.indextable[insize];\
|
||||
if ((object= (type*)*freelistp)) {\
|
||||
qhmem.totshort += qhmem.sizetable[qhmem.indextable[insize]]; \
|
||||
qhmem.totfree -= qhmem.sizetable[qhmem.indextable[insize]]; \
|
||||
qhmem.cntquick++; \
|
||||
*freelistp= *((void **)*freelistp);\
|
||||
}else object= (type*)qh_memalloc(insize);}
|
||||
#endif
|
||||
|
||||
/*-<a href="qh-mem.htm#TOC"
|
||||
>--------------------------------</a><a name="memfree_">-</a>
|
||||
|
||||
qh_memfree_(object, insize, freelistp)
|
||||
free up an object
|
||||
|
||||
notes:
|
||||
object may be NULL
|
||||
assumes size<=qhmem.LASTsize and void **freelistp is a temp
|
||||
*/
|
||||
#if defined qh_NOmem
|
||||
#define qh_memfree_(object, insize, freelistp) {\
|
||||
qh_memfree(object, insize); }
|
||||
#elif defined qh_TRACEshort
|
||||
#define qh_memfree_(object, insize, freelistp) {\
|
||||
freelistp= NULL; /* Avoid warnings */ \
|
||||
qh_memfree(object, insize); }
|
||||
#else /* !qh_NOmem */
|
||||
|
||||
#define qh_memfree_(object, insize, freelistp) {\
|
||||
if (object) { \
|
||||
qhmem.freeshort++;\
|
||||
freelistp= qhmem.freelists + qhmem.indextable[insize];\
|
||||
qhmem.totshort -= qhmem.sizetable[qhmem.indextable[insize]]; \
|
||||
qhmem.totfree += qhmem.sizetable[qhmem.indextable[insize]]; \
|
||||
*((void **)object)= *freelistp;\
|
||||
*freelistp= object;}}
|
||||
#endif
|
||||
|
||||
/*=============== prototypes in alphabetical order ============*/
|
||||
|
||||
void *qh_memalloc(int insize);
|
||||
void qh_memcheck(void);
|
||||
void qh_memfree(void *object, int insize);
|
||||
void qh_memfreeshort(int *curlong, int *totlong);
|
||||
void qh_meminit(FILE *ferr);
|
||||
void qh_meminitbuffers(int tracelevel, int alignment, int numsizes,
|
||||
int bufsize, int bufinit);
|
||||
void qh_memsetup(void);
|
||||
void qh_memsize(int size);
|
||||
void qh_memstatistics(FILE *fp);
|
||||
void qh_memtotal(int *totlong, int *curlong, int *totshort, int *curshort, int *maxlong, int *totbuffer);
|
||||
|
||||
#endif /* qhDEFmem */
|
||||
Reference in New Issue
Block a user