Skip to content

AFNI/NIfTI Server

Sections
Personal tools
You are here: Home » AFNI » Documentation
 

Doxygen Source Code Documentation

Main Page   Alphabetical List   Data Structures   File List   Data Fields   Globals   Search  

mem.h File Reference

Go to the source code of this file.


Data Structures

struct  qhmemT

Defines

#define qhmem_ERRmem   4
#define qhmem_ERRqhull   5
#define qh_memalloc_(size, freelistp, object, type)
#define qh_memfree_(object, size, freelistp)

Typedefs

typedef unsigned long ptr_intT
typedef qhmemT qhmemT

Functions

void * qh_memalloc (int insize)
void qh_memfree (void *object, int size)
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)

Variables

qhmemT qhmem

Define Documentation

#define qh_memalloc_ (  size,
freelistp,
object,
type    ) 
 

Value:

{\
  freelistp= qhmem.freelists + qhmem.indextable[size];\
  if ((object= (type*)*freelistp)) {\
    qhmem.cntquick++;  \
    *freelistp= *((void **)*freelistp);\
  }else object= (type*)qh_memalloc (size);}

Definition at line 131 of file mem.h.

Referenced by qh_appendmergeset(), qh_newfacet(), qh_newridge(), qh_projectpoint(), qh_setfacetplane(), and qh_setnew().

#define qh_memfree_ (  object,
size,
freelistp    ) 
 

Value:

{\
  if (object) { \
    qhmem .freeshort++;\
    freelistp= qhmem.freelists + qhmem.indextable[size];\
    *((void **)object)= *freelistp;\
    *freelistp= object;}}

Definition at line 154 of file mem.h.

Referenced by qh_all_merges(), qh_delfacet(), qh_delridge(), qh_makenew_nonsimplicial(), qh_mergecycle_ridges(), and qh_setfree().

#define qhmem_ERRmem   4
 

Definition at line 49 of file mem.h.

Referenced by qh_memalloc(), qh_meminitbuffers(), and qh_memsetup().

#define qhmem_ERRqhull   5
 

Definition at line 50 of file mem.h.

Referenced by qh_memalloc(), qh_meminitbuffers(), qh_memsize(), qh_setaddnth(), qh_setcheck(), qh_setdelnth(), qh_setdelnthsorted(), qh_setnew_delnthsorted(), qh_setreplace(), qh_setsize(), qh_settempfree(), qh_settemppop(), qh_settruncate(), and qh_setzero().

Typedef Documentation

typedef unsigned long ptr_intT
 

Definition at line 62 of file mem.h.

Referenced by qh_gethash().

typedef struct qhmemT qhmemT
 

Definition at line 82 of file mem.h.

Function Documentation

void* qh_memalloc (  int    insize ) 
 

Definition at line 99 of file qhulldir/mem.c.

References qhmemT::ALIGNmask, qhmemT::BUFinit, qhmemT::BUFsize, qhmemT::cntlong, qhmemT::cntquick, qhmemT::cntshort, qhmemT::curbuffer, qhmemT::curlong, qhmemT::ferr, qhmemT::freelists, qhmemT::freemem, qhmemT::freesize, qhmemT::indextable, qhmemT::IStracing, qhmemT::LASTsize, malloc, qhmemT::maxlong, object, qh_errexit(), qhmem_ERRmem, qhmem_ERRqhull, qhmemT::sizetable, qhmemT::totlong, and qhmemT::totshort.

Referenced by qh_findbestsharp(), qh_getcenter(), qh_initqhull_buffers(), qh_newvertex(), qh_printafacet(), qh_projectinput(), qh_setduplicate(), qh_setnew(), and qh_voronoi_center(). 

00099                               {
00100   void **freelistp, *newbuffer;
00101   int index, size;
00102   int outsize, bufsize;
00103   void *object;
00104 
00105   if ((unsigned) insize <= (unsigned) qhmem.LASTsize) {
00106     index= qhmem.indextable[insize];
00107     freelistp= qhmem.freelists+index;
00108     if ((object= *freelistp)) {
00109       qhmem.cntquick++;  
00110       *freelistp= *((void **)*freelistp);  /* replace freelist with next object */
00111       return (object);
00112     }else {
00113       outsize= qhmem.sizetable[index];
00114       qhmem.cntshort++;
00115       if (outsize > qhmem .freesize) {
00116         if (!qhmem.curbuffer)
00117           bufsize= qhmem.BUFinit;
00118         else
00119           bufsize= qhmem.BUFsize;
00120         qhmem.totshort += bufsize;
00121         if (!(newbuffer= malloc(bufsize))) {
00122           fprintf(qhmem.ferr, "qhull error (qh_memalloc): insufficient memory\n");
00123           qh_errexit(qhmem_ERRmem, NULL, NULL);
00124         } 
00125         *((void **)newbuffer)= qhmem.curbuffer;  /* prepend newbuffer to curbuffer 
00126                                                     list */
00127         qhmem.curbuffer= newbuffer;
00128         size= (sizeof(void **) + qhmem.ALIGNmask) & ~qhmem.ALIGNmask;
00129         qhmem.freemem= (void *)((char *)newbuffer+size);
00130         qhmem.freesize= bufsize - size;
00131       }
00132       object= qhmem.freemem;
00133       qhmem.freemem= (void *)((char *)qhmem.freemem + outsize);
00134       qhmem.freesize -= outsize;
00135       return object;
00136     }
00137   }else {                     /* long allocation */
00138     if (!qhmem.indextable) {
00139       fprintf (qhmem.ferr, "qhull internal error (qh_memalloc): qhmem has not been initialized.\n");
00140       qh_errexit(qhmem_ERRqhull, NULL, NULL);
00141     }
00142     outsize= insize;
00143     qhmem .cntlong++;
00144     qhmem .curlong++;
00145     qhmem .totlong += outsize;
00146     if (qhmem.maxlong < qhmem.totlong)
00147       qhmem.maxlong= qhmem.totlong;
00148     if (!(object= malloc(outsize))) {
00149       fprintf(qhmem.ferr, "qhull error (qh_memalloc): insufficient memory\n");
00150       qh_errexit(qhmem_ERRmem, NULL, NULL);
00151     }
00152     if (qhmem.IStracing >= 5)
00153       fprintf (qhmem.ferr, "qh_memalloc long: %d bytes at %p\n", outsize, object);
00154   }
00155   return (object);
00156 } /* memalloc */

void qh_memfree (  void *    object,
int    size
) 
 

Definition at line 177 of file qhulldir/mem.c.

References qhmemT::ferr, free, qhmemT::freelists, qhmemT::freelong, qhmemT::freeshort, qhmemT::indextable, qhmemT::IStracing, qhmemT::LASTsize, object, and qhmemT::totlong.

Referenced by qh_attachnewfacets(), qh_checkconvex(), qh_clearcenters(), qh_delvertex(), qh_facetarea(), qh_findbestsharp(), qh_flippedmerges(), qh_forcedmerges(), qh_freebuffers(), qh_freebuild(), qh_getcentrum(), qh_makenew_nonsimplicial(), qh_merge_degenredundant(), qh_mergecycle_facets(), qh_mergesimplex(), qh_printafacet(), qh_printcentrum(), qh_printfacet2geom(), qh_printfacet2geom_points(), qh_printfacet2math(), qh_printfacet3geom_nonsimplicial(), qh_printfacet3geom_points(), qh_printfacet3math(), qh_printfacet4geom_nonsimplicial(), qh_printfacets(), qh_projectinput(), qh_setfree(), qh_setfree2(), qh_setfreelong(), and qh_updatetested(). 

00177                                         {
00178   void **freelistp;
00179 
00180   if (!object)
00181     return;
00182   if (size <= qhmem.LASTsize) {
00183     qhmem .freeshort++;
00184     freelistp= qhmem.freelists + qhmem.indextable[size];
00185     *((void **)object)= *freelistp;
00186     *freelistp= object;
00187   }else {
00188     qhmem .freelong++;
00189     qhmem .totlong -= size;
00190     free (object);
00191     if (qhmem.IStracing >= 5)
00192       fprintf (qhmem.ferr, "qh_memfree long: %d bytes at %p\n", size, object);
00193   }
00194 } /* memfree */

void qh_memfreeshort (  int *    curlong,
int *    totlong
) 
 

Definition at line 206 of file qhulldir/mem.c. 

00206                                                   {
00207   void *buffer, *nextbuffer;
00208 
00209   *curlong= qhmem .cntlong - qhmem .freelong;
00210   *totlong= qhmem .totlong;
00211   for(buffer= qhmem.curbuffer; buffer; buffer= nextbuffer) {
00212     nextbuffer= *((void **) buffer);
00213     free(buffer);
00214   }
00215   qhmem.curbuffer= NULL;
00216   if (qhmem .LASTsize) {
00217     free (qhmem .indextable);
00218     free (qhmem .freelists);
00219     free (qhmem .sizetable);
00220   }
00221   memset((char *)&qhmem, 0, sizeof qhmem);  /* every field is 0, FALSE, NULL */
00222 } /* memfreeshort */

void qh_meminit (  FILE *    ferr ) 
 

Definition at line 231 of file qhulldir/mem.c. 

00231                              {
00232   
00233   memset((char *)&qhmem, 0, sizeof qhmem);  /* every field is 0, FALSE, NULL */
00234   qhmem.ferr= ferr;
00235   if (sizeof(void*) < sizeof(int)) {
00236     fprintf (ferr, "qhull internal error (qh_meminit): sizeof(void*) < sizeof(int).  qset.c will not work\n");
00237     exit (1);  /* can not use qh_errexit() */
00238   }
00239 } /* meminit */

void qh_meminitbuffers (  int    tracelevel,
int    alignment,
int    numsizes,
int    bufsize,
int    bufinit
) 
 

Definition at line 252 of file qhulldir/mem.c.

References qhmemT::ALIGNmask, qhmemT::BUFinit, qhmemT::BUFsize, calloc, qhmemT::ferr, qhmemT::freelists, qhmemT::IStracing, qhmemT::NUMsizes, qh_errexit(), qhmem_ERRmem, qhmem_ERRqhull, and qhmemT::sizetable.

Referenced by qh_initqhull_mem(). 

00252                                                                                                {
00253 
00254   qhmem.IStracing= tracelevel;
00255   qhmem.NUMsizes= numsizes;
00256   qhmem.BUFsize= bufsize;
00257   qhmem.BUFinit= bufinit;
00258   qhmem.ALIGNmask= alignment-1;
00259   if (qhmem.ALIGNmask & ~qhmem.ALIGNmask) {
00260     fprintf (qhmem.ferr, "qhull internal error (qh_meminit): memory alignment %d is not a power of 2\n", alignment);
00261     qh_errexit (qhmem_ERRqhull, NULL, NULL);
00262   }
00263   qhmem.sizetable= (int *) calloc (numsizes, sizeof(int));
00264   qhmem.freelists= (void **) calloc (numsizes, sizeof(void *));
00265   if (!qhmem.sizetable || !qhmem.freelists) {
00266     fprintf(qhmem.ferr, "qhull error (qh_meminit): insufficient memory\n");
00267     qh_errexit (qhmem_ERRmem, NULL, NULL);
00268   }
00269   if (qhmem.IStracing >= 1)
00270     fprintf (qhmem.ferr, "qh_meminitbuffers: memory initialized with alignment %d\n", alignment);
00271 } /* meminitbuffers */

void qh_memsetup (  void    ) 
 

Definition at line 279 of file qhulldir/mem.c.

References qhmemT::BUFinit, qhmemT::BUFsize, qhmemT::ferr, i, qhmemT::indextable, qhmemT::LASTsize, malloc, qh_errexit(), qh_intcompare(), qhmem_ERRmem, qhmemT::sizetable, and qhmemT::TABLEsize.

Referenced by qh_initqhull_mem(). 

00279                         {
00280   int k,i;
00281 
00282   qsort(qhmem.sizetable, qhmem.TABLEsize, sizeof(int), qh_intcompare);
00283   qhmem.LASTsize= qhmem.sizetable[qhmem.TABLEsize-1];
00284   if (qhmem .LASTsize >= qhmem .BUFsize || qhmem.LASTsize >= qhmem .BUFinit) {
00285     fprintf (qhmem.ferr, "qhull error (qh_memsetup): largest mem size %d is >= buffer size %d or initial buffer size %d\n",
00286             qhmem .LASTsize, qhmem .BUFsize, qhmem .BUFinit);
00287     qh_errexit(qhmem_ERRmem, NULL, NULL);
00288   }
00289   if (!(qhmem.indextable= (int *)malloc((qhmem.LASTsize+1) * sizeof(int)))) {
00290     fprintf(qhmem.ferr, "qhull error (qh_memsetup): insufficient memory\n");
00291     qh_errexit(qhmem_ERRmem, NULL, NULL);
00292   }
00293   for(k=qhmem.LASTsize+1; k--; )
00294     qhmem.indextable[k]= k;
00295   i= 0;
00296   for(k= 0; k <= qhmem.LASTsize; k++) {
00297     if (qhmem.indextable[k] <= qhmem.sizetable[i])
00298       qhmem.indextable[k]= i;
00299     else
00300       qhmem.indextable[k]= ++i;
00301   }
00302 } /* memsetup */

void qh_memsize (  int    size ) 
 

Definition at line 310 of file qhulldir/mem.c.

References qhmemT::ALIGNmask, qhmemT::ferr, qhmemT::LASTsize, qhmemT::NUMsizes, qh_errexit(), qhmem_ERRqhull, qhmemT::sizetable, and qhmemT::TABLEsize.

Referenced by qh_initqhull_mem(). 

00310                           {
00311   int k;
00312 
00313   if (qhmem .LASTsize) {
00314     fprintf (qhmem .ferr, "qhull error (qh_memsize): called after qhmem_setup\n");
00315     qh_errexit (qhmem_ERRqhull, NULL, NULL);
00316   }
00317   size= (size + qhmem.ALIGNmask) & ~qhmem.ALIGNmask;
00318   for(k= qhmem.TABLEsize; k--; ) {
00319     if (qhmem.sizetable[k] == size)
00320       return;
00321   }
00322   if (qhmem.TABLEsize < qhmem.NUMsizes)
00323     qhmem.sizetable[qhmem.TABLEsize++]= size;
00324   else
00325     fprintf(qhmem.ferr, "qhull warning (memsize): free list table has room for only %d sizes\n", qhmem.NUMsizes);
00326 } /* memsize */

void qh_memstatistics (  FILE *    fp ) 
 

Definition at line 338 of file qhulldir/mem.c.

References qhmemT::BUFinit, qhmemT::BUFsize, qhmemT::cntlarger, qhmemT::cntlong, qhmemT::cntshort, qhmemT::freelists, qhmemT::freelong, qhmemT::freeshort, qhmemT::freesize, i, qhmemT::maxlong, object, qhmemT::sizetable, qhmemT::TABLEsize, qhmemT::totlarger, qhmemT::totlong, and qhmemT::totshort.

Referenced by qh_errexit(), qh_printallstatistics(), and qh_produce_output(). 

00338                                  {
00339   int i, count, totfree= 0;
00340   void *object;
00341   
00342   for (i=0; i < qhmem.TABLEsize; i++) {
00343     count=0;
00344     for (object= qhmem .freelists[i]; object; object= *((void **)object))
00345       count++;
00346     totfree += qhmem.sizetable[i] * count;
00347   }
00348   fprintf (fp, "\nmemory statistics:\n\
00349 %7d quick allocations\n\
00350 %7d short allocations\n\
00351 %7d long allocations\n\
00352 %7d short frees\n\
00353 %7d long frees\n\
00354 %7d bytes of short memory in use\n\
00355 %7d bytes of short memory in freelists\n\
00356 %7d bytes of long memory allocated (except for input)\n\
00357 %7d bytes of long memory in use (in %d pieces)\n\
00358 %7d bytes per memory buffer (initially %d bytes)\n",
00359            qhmem .cntquick, qhmem.cntshort, qhmem.cntlong,
00360            qhmem .freeshort, qhmem.freelong, 
00361            qhmem .totshort - qhmem .freesize - totfree,
00362            totfree,
00363            qhmem .maxlong, qhmem .totlong, qhmem .cntlong - qhmem .freelong,
00364            qhmem .BUFsize, qhmem .BUFinit);
00365   if (qhmem.cntlarger) {
00366     fprintf (fp, "%7d calls to qh_setlarger\n%7.2g     average copy size\n",
00367            qhmem.cntlarger, ((float) qhmem.totlarger)/ qhmem.cntlarger);
00368     fprintf (fp, "  freelists (bytes->count):");
00369   }
00370   for (i=0; i < qhmem.TABLEsize; i++) {
00371     count=0;
00372     for (object= qhmem .freelists[i]; object; object= *((void **)object))
00373       count++;
00374     fprintf (fp, " %d->%d", qhmem.sizetable[i], count);
00375   }
00376   fprintf (fp, "\n\n");
00377 } /* memstatistics */

Variable Documentation

qhmemT qhmem
 

Definition at line 83 of file mem.h.

 
Powered by Plone

This site conforms to the following standards: