lib/memalloc.c File Reference

#include "common.h"
#include "obscure.h"
#include "memalloc.h"
#include "dlist.h"

Include dependency graph for memalloc.c:

Go to the source code of this file.

Data Structures

struct  carefulMemBlock
struct  memTracker

Defines

#define NEEDMEM_LIMIT   500000000

Functions

static void * defaultAlloc (size_t size)
static void defaultFree (void *vpt)
static void * defaultRealloc (void *vpt, size_t size)
memHandler * pushMemHandler (struct memHandler *newHandler)
memHandler * popMemHandler ()
void setDefaultMemHandler ()
void setMaxAlloc (size_t s)
void * needLargeMem (size_t size)
void * needLargeZeroedMem (size_t size)
void * needLargeMemResize (void *vp, size_t size)
void * needLargeZeroedMemResize (void *vp, size_t oldSize, size_t newSize)
void * needHugeMem (size_t size)
void * needHugeZeroedMem (size_t size)
void * needHugeMemResize (void *vp, size_t size)
void * needHugeZeroedMemResize (void *vp, size_t oldSize, size_t newSize)
void * needMem (size_t size)
void * needMoreMem (void *old, size_t oldSize, size_t newSize)
void * wantMem (size_t size)
void freeMem (void *pt)
void freez (void *vpt)
static void carefulMemInit (size_t maxToAlloc)
static void * carefulAlloc (size_t size)
static void carefulFree (void *vpt)
static void * carefulRealloc (void *vpt, size_t size)
void carefulCheckHeap ()
int carefulCountBlocksAllocated ()
long carefulTotalAllocated ()
void pushCarefulMemHandler (size_t maxAlloc)
static void * memTrackerAlloc (size_t size)
static void memTrackerFree (void *vpt)
static void * memTrackerRealloc (void *vpt, size_t size)
void memTrackerStart ()
void memTrackerEnd ()

Variables

static char const rcsid [] = "$Id: memalloc.c,v 1.30 2007/03/07 01:46:43 angie Exp $"
static struct memHandler defaultMemHandler
static struct memHandler * mhStack = &defaultMemHandler
static size_t maxAlloc = 128*8*1024*1024*(sizeof(size_t)/4)*(sizeof(size_t)/4)
static int carefulAlignSize
static int carefulAlignAdd
static bits32 carefulAlignMask
static struct memHandler * carefulParent
static size_t carefulMaxToAlloc
static size_t carefulAlloced
int cmbStartCookie = 0x78753421
char cmbEndCookie [4] = {0x44, 0x33, 0x7F, 0x42}
dlList * cmbAllocedList
static struct memHandler carefulMemHandler
static struct memTracker * memTracker = NULL

Define Documentation

#define NEEDMEM_LIMIT   500000000

Definition at line 178 of file memalloc.c.

Referenced by needMem().

Function Documentation

static void* carefulAlloc ( size_t  size  )  [static]

Definition at line 277 of file memalloc.c.

References memHandler::alloc, carefulAlignAdd, carefulAlignMask, carefulAlloced, carefulMaxToAlloc, carefulParent, cmbAllocedList, cmbEndCookie, cmbStartCookie, dlAddHead(), errAbort(), maxAlloc, carefulMemBlock::size, sprintLongWithCommas(), and carefulMemBlock::startCookie.

Referenced by carefulRealloc().

00280 {
00281 struct carefulMemBlock *cmb;
00282 char *pEndCookie;
00283 size_t newAlloced = size + carefulAlloced;
00284 size_t aliSize;
00285 
00286 if (newAlloced > carefulMaxToAlloc)
00287     {
00288     char maxAlloc[32];
00289     char allocRequest[32];
00290     sprintLongWithCommas(maxAlloc, (long long)carefulMaxToAlloc);
00291     sprintLongWithCommas(allocRequest, (long long)newAlloced);
00292     errAbort("Allocated too much memory - more than %s bytes (%s)",
00293         maxAlloc, allocRequest);
00294     }
00295 carefulAlloced = newAlloced;
00296 aliSize = ((size + sizeof(*cmb) + 4 + carefulAlignAdd)&carefulAlignMask);
00297 cmb = carefulParent->alloc(aliSize);
00298 cmb->size = size;
00299 cmb->startCookie = cmbStartCookie;
00300 pEndCookie = (char *)(cmb+1);
00301 pEndCookie += size;
00302 memcpy(pEndCookie, cmbEndCookie, sizeof(cmbEndCookie));
00303 dlAddHead(cmbAllocedList, (struct dlNode *)cmb);
00304 return (void *)(cmb+1);
00305 }

Here is the call graph for this function:

Here is the caller graph for this function:

void carefulCheckHeap (  ) 

Definition at line 342 of file memalloc.c.

References carefulParent, cmbAllocedList, cmbEndCookie, cmbStartCookie, errAbort(), dlList::head, carefulMemBlock::next, ptrToLL, carefulMemBlock::size, and carefulMemBlock::startCookie.

00345 {
00346 int maxPieces = 10000000;    /* Assume no more than this many pieces allocated. */
00347 struct carefulMemBlock *cmb;
00348 char *pEndCookie;
00349 size_t size;
00350 
00351 if (carefulParent == NULL)
00352     return;
00353 
00354 for (cmb = (struct carefulMemBlock *)(cmbAllocedList->head); cmb->next != NULL; cmb = cmb->next)
00355     {
00356     size = cmb->size;
00357     pEndCookie = (((char *)(cmb+1)) + size);
00358     if (cmb->startCookie != cmbStartCookie)
00359         errAbort("Bad start cookie %x checking %llx\n", cmb->startCookie,
00360                  ptrToLL(cmb+1));
00361     if (memcmp(pEndCookie, cmbEndCookie, sizeof(cmbEndCookie)) != 0)
00362         errAbort("Bad end cookie %x%x%x%x checking %llx\n", 
00363                  pEndCookie[0], pEndCookie[1], pEndCookie[2], pEndCookie[3],
00364                  ptrToLL(cmb+1));
00365     if (--maxPieces == 0)
00366         errAbort("Loop or more than 10000000 pieces in memory list");
00367     }
00368 }

Here is the call graph for this function:

int carefulCountBlocksAllocated (  ) 

Definition at line 370 of file memalloc.c.

References cmbAllocedList, and dlCount().

00372 {
00373 return dlCount(cmbAllocedList);
00374 }

Here is the call graph for this function:

static void carefulFree ( void *  vpt  )  [static]

Definition at line 307 of file memalloc.c.

References carefulAlloced, carefulParent, cmbEndCookie, cmbStartCookie, dlRemove(), errAbort(), memHandler::free, ptrToLL, carefulMemBlock::size, and carefulMemBlock::startCookie.

Referenced by carefulRealloc().

00309 {
00310 struct carefulMemBlock *cmb = ((struct carefulMemBlock *)vpt)-1;
00311 size_t size = cmb->size;
00312 char *pEndCookie;
00313 
00314 carefulAlloced -= size;
00315 pEndCookie = (((char *)(cmb+1)) + size);
00316 if (cmb->startCookie != cmbStartCookie)
00317     errAbort("Bad start cookie %x freeing %llx\n", cmb->startCookie,
00318              ptrToLL(vpt));
00319 if (memcmp(pEndCookie, cmbEndCookie, sizeof(cmbEndCookie)) != 0)
00320     errAbort("Bad end cookie %x%x%x%x freeing %llx\n", 
00321         pEndCookie[0], pEndCookie[1], pEndCookie[2], pEndCookie[3],
00322              ptrToLL(vpt));
00323 dlRemove((struct dlNode *)cmb);
00324 carefulParent->free(cmb);
00325 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void carefulMemInit ( size_t  maxToAlloc  )  [static]

Definition at line 258 of file memalloc.c.

References carefulAlignAdd, carefulAlignMask, carefulAlignSize, carefulMaxToAlloc, cmbAllocedList, and newDlList().

Referenced by pushCarefulMemHandler().

00260 {
00261 carefulMaxToAlloc = maxToAlloc;
00262 cmbAllocedList = newDlList();
00263 carefulAlignSize = sizeof(double);
00264 if (sizeof(void *) > carefulAlignSize)
00265     carefulAlignSize = sizeof(void *);
00266 if (sizeof(long) > carefulAlignSize)
00267     carefulAlignSize = sizeof(long);
00268 if (sizeof(off_t) > carefulAlignSize)
00269     carefulAlignSize = sizeof(off_t);
00270 if (sizeof(long long) > carefulAlignSize)
00271     carefulAlignSize = sizeof(long long);
00272 carefulAlignAdd = carefulAlignSize-1;
00273 carefulAlignMask = ~carefulAlignAdd;
00274 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void* carefulRealloc ( void *  vpt,
size_t  size 
) [static]

Definition at line 328 of file memalloc.c.

References carefulAlloc(), carefulFree(), and carefulMemBlock::size.

00330 {
00331 unsigned char* newBlk = carefulAlloc(size);
00332 if (vpt != NULL)
00333     {
00334     struct carefulMemBlock *cmb = ((struct carefulMemBlock *)vpt)-1;
00335     memcpy(newBlk, vpt, cmb->size);
00336     carefulFree(vpt);
00337     }
00338 return newBlk;
00339 }

Here is the call graph for this function:

long carefulTotalAllocated (  ) 

Definition at line 376 of file memalloc.c.

References carefulAlloced.

00378 {
00379 return carefulAlloced;
00380 }

static void* defaultAlloc ( size_t  size  )  [static]

Definition at line 18 of file memalloc.c.

00020 {
00021 return malloc(size);
00022 }

static void defaultFree ( void *  vpt  )  [static]

Definition at line 24 of file memalloc.c.

00026 {
00027 free(vpt);
00028 }

static void* defaultRealloc ( void *  vpt,
size_t  size 
) [static]

Definition at line 30 of file memalloc.c.

00032 {
00033 return realloc(vpt, size);
00034 }

void freeMem ( void *  pt  ) 

Definition at line 210 of file memalloc.c.

References memHandler::free, and mhStack.

Referenced by apacheAccessLogFree(), axtFree(), axtScoreSchemeProteinRead(), bandExtFf(), bfGraphFree(), binKeeperFree(), binKeeperRemove(), blastBlockFree(), blastFileFree(), blastGappedAliFree(), blastQueryFree(), cdaFreeAli(), chainFree(), chainMergeAbutting(), checkTagIsInside(), clusterRemoveEncompassed(), contigRemoveEncompassed(), copyFile(), cpFile(), crudeAliFind(), dgConstrainedPriorityOrder(), dgDisconnect(), dgFindPath(), dgRemoveFromConList(), dlDelete(), dlListReset(), dlSort(), dnaLoadClose(), dnaMotifFree(), expandFaFastBuf(), ffMergeNeedleAlis(), ffRemoveEmptyAlis(), findCrudeGenes(), fofClose(), freeContig(), freeDlListAndVals(), freeDnaSeq(), freeDyString(), freeFastProber(), freeHashAndVals(), freeHistoGram(), freeKvt(), freeNt4(), freePatSpace(), freez(), gapCalcFree(), gdfFreeGene(), genoFindFree(), gentleFree(), gfAlignTrans(), gfAlignTransTrans(), gffClose(), gffFileFree(), gffFreeGene(), gffHasGtfGroup(), gfOutputFree(), gfPcrInputFree(), gfPcrOutputFree(), gfRangeFree(), gif_decoder(), hpfModelFree(), hpfResultFree(), htmlAttributeFree(), htmlCookieFree(), htmlFormVarFree(), htmlIncludeFile(), htmlStatusFree(), htmlTagFree(), kdTreeMake(), lineFileClose(), lmCleanup(), mafCompFree(), mafFileFree(), makeHits8(), memTrackerEnd(), mergeContigs(), mergeWithinCluster(), mgFree(), netParseUrl(), nibInfoFree(), nibStreamClose(), nt4LoadPart(), oligoDg(), oligoTm(), phmmMatrixFree(), plProcFree(), pscmSetHint(), pslFree(), pslTblFree(), pslxFileOpen(), pslxFileOpenWithMetaConfig(), queryServer(), raFromString(), rcSeqs(), readLine(), removeNegativeBlocks(), repeatMaskOutFree(), scanChromOffsetFile(), scoreNoninsertingExtensions(), shaFreeNode(), shuffleList(), slDoubleMedian(), slFreeList(), slPairFree(), slSort(), snofClose(), snofOpen(), spacedColumnFromLineFile(), spacedColumnFromSample(), spaceSaverFree(), sqlStringFreeDynamicArray(), ssGraphFree(), stringToSlNames(), strstrNoCase(), subTextFree(), synQueueGet(), synQueueGrab(), targetHitsFree(), tokenizerFree(), trimFlakyEnds(), trixClose(), trixHitPosFree(), trixSearchResultFree(), trixWordResultFree(), twoBitIsRange(), twoBitSpecFree(), wormFreeCdnaInfo(), wormInfoForGene(), xaAliFree(), xAliFree(), xapFree(), xapStartTag(), xpFree(), and xStitch().

00212 {
00213 if (pt != NULL)
00214     mhStack->free(pt);
00215 }

Here is the caller graph for this function:

void freez ( void *  vpt  ) 

Definition at line 217 of file memalloc.c.

References freeMem().

Referenced by aliLines(), apacheAccessLogFree(), appendCgiVar(), axtAffine2Level(), axtBundleFree(), axtFree(), axtScoreSchemeFree(), bfGraphFree(), binKeeperFree(), bitFree(), blastBlockFree(), blastFileFree(), blastGappedAliFree(), blastQueryFree(), boxClumpFree(), cfmFree(), cgiFromFile(), cgiParseMultipart(), cgiUrlString(), chainFree(), chainRemovePartialOverlaps(), clumpHits(), colHashFree(), convertEpsToPdf(), correlateFree(), dgFree(), dgNodeFree(), dnaLoadClose(), dnaLoadSingle(), dnaLoadStackFree(), dnaMotifFree(), doBlat(), dyStringCannibalize(), errCatchFree(), faFreeFastBuf(), fillConcave(), flyFreeNt4Genome(), fofClose(), formParseVars(), freeContig(), freeDlList(), freeDnaSeq(), freeDyString(), freeFastProber(), freeHash(), freeKvt(), freeNt4(), freePatSpace(), freeQuickHeap(), freeWormCdnaIterator(), gapCalcFree(), genoFindFree(), getHitsFromServer(), gfAbort(), gfClumpFree(), gffFileFree(), gffGroupFree(), gfHitSortDiagonal(), gfOutputFree(), gfPcrInputFree(), gfPcrOutputFree(), gfRangeFree(), gfxPolyFree(), hashElFree(), hashVarLine(), headerBytes(), hpfModelFree(), hpfResultFree(), htmlAttributeFree(), htmlCookieFree(), htmlExpandUrl(), htmlFormFree(), htmlFormVarFree(), htmlFormVarSet(), htmlPageFree(), htmlPageFromForm(), htmlPageParse(), htmlPageParseNoHead(), htmlStatusFree(), htmlTagFree(), jpegSize(), lineFileClose(), lineFileDecompress(), loadHashT3Ranges(), mafAliFree(), mafCompFree(), mafFileFree(), memGifClose(), netHttpConnect(), netHttpGet(), netParseSubnet(), nibInfoFree(), nibStreamClose(), nibTwoCacheFree(), outputFa(), parseMultiParts(), parsePasvPort(), pcrClumps(), phmmMatrixFree(), pipelineFree(), psClose(), pscmClose(), pslFree(), pslShowAlignmentStranded(), psPolyFree(), qaStatusSoftError(), rbTreeFree(), readPartHeaderMB(), repeatMaskOutFree(), rudpClose(), rudpFree(), searchOneIndex(), slPairFree(), slPairFreeVals(), spaceSaverFree(), sqlStringFreeDynamicArray(), ssBundleFree(), ssFfItemFree(), ssGraphFree(), startServer(), subTextFree(), synQueueFree(), synQueueFreeAndVals(), targetHitsFree(), tokenizerFree(), trans3Free(), trixClose(), trixHitPosFree(), trixSearchResultFree(), trixWordResultFree(), twoBitClose(), twoBitOutNBeds(), twoBitReadSeqFragExt(), twoBitSeqSizeNoNs(), validateTables(), vgClose(), vgOpenGif(), wormCdnaUncache(), wormFreeNt4Genome(), xAliFree(), xapFree(), xenAlignWorm(), and xpFree().

00220 {
00221 void **ppt = (void **)vpt;
00222 void *pt = *ppt;
00223 *ppt = NULL;
00224 freeMem(pt);
00225 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void* memTrackerAlloc ( size_t  size  )  [static]

Definition at line 410 of file memalloc.c.

References memHandler::alloc, dlAddTail(), memTracker::list, memTracker, and memTracker::parent.

Referenced by memTrackerRealloc(), and memTrackerStart().

00413 {
00414 struct dlNode *node;
00415 
00416 size += sizeof (*node);
00417 node = memTracker->parent->alloc(size);
00418 if (node == NULL)
00419     return node;
00420 dlAddTail(memTracker->list, node);
00421 return (void*)(node+1);
00422 }

Here is the call graph for this function:

Here is the caller graph for this function:

void memTrackerEnd (  ) 

Definition at line 471 of file memalloc.c.

References dlListFree, errAbort(), freeMem(), memTracker::handler, memTracker::list, memTracker, and popMemHandler().

Referenced by errorSafePcr(), and errorSafeQuery().

00473 {
00474 struct memTracker *mt = memTracker;
00475 if (mt == NULL)
00476     errAbort("memTrackerEnd without memTrackerStart");
00477 memTracker = NULL;
00478 popMemHandler();
00479 dlListFree(&mt->list);
00480 freeMem(mt->handler);
00481 freeMem(mt);
00482 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void memTrackerFree ( void *  vpt  )  [static]

Definition at line 424 of file memalloc.c.

References dlRemove(), memHandler::free, memTracker, and memTracker::parent.

Referenced by memTrackerStart().

00426 {
00427 struct dlNode *node = vpt;
00428 node -= 1;
00429 dlRemove(node);
00430 memTracker->parent->free(node);
00431 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void* memTrackerRealloc ( void *  vpt,
size_t  size 
) [static]

Definition at line 433 of file memalloc.c.

References dlAddTail(), dlRemove(), memTracker::list, memTracker, memTrackerAlloc(), memTracker::parent, and memHandler::realloc.

Referenced by memTrackerStart().

00435 {
00436 if (vpt == NULL)
00437     return memTrackerAlloc(size);
00438 else
00439     {
00440     struct dlNode *node = ((struct dlNode *)vpt)-1;
00441     size += sizeof(*node);
00442     dlRemove(node);
00443     node = memTracker->parent->realloc(node, size);
00444     if (node == NULL)
00445         return node;
00446     dlAddTail(memTracker->list, node);
00447     return (void*)(node+1);
00448     }
00449 }

Here is the call graph for this function:

Here is the caller graph for this function:

void memTrackerStart (  ) 

Definition at line 451 of file memalloc.c.

References memHandler::alloc, AllocVar, dlListNew, errAbort(), memHandler::free, memTracker::handler, memTracker::list, memTracker, memTrackerAlloc(), memTrackerFree(), memTrackerRealloc(), memTracker::parent, pushMemHandler(), and memHandler::realloc.

Referenced by errorSafeSetup().

00456 {
00457 struct memTracker *mt;
00458 
00459 if (memTracker != NULL)
00460      errAbort("multiple memTrackerStart calls");
00461 AllocVar(mt);
00462 AllocVar(mt->handler);
00463 mt->handler->alloc = memTrackerAlloc;
00464 mt->handler->free = memTrackerFree;
00465 mt->handler->realloc = memTrackerRealloc;
00466 mt->list = dlListNew();
00467 mt->parent = pushMemHandler(mt->handler);
00468 memTracker = mt;
00469 }

Here is the call graph for this function:

Here is the caller graph for this function:

void* needHugeMem ( size_t  size  ) 

Definition at line 131 of file memalloc.c.

References memHandler::alloc, errAbort(), and mhStack.

Referenced by cloneDnaSeq(), expandFaFastBuf(), faReadMixedNext(), faReadSeq(), gfAllocLargeLists(), gfAllocLists(), and needHugeZeroedMem().

00133 {
00134 void *pt;
00135 if (size == 0)
00136     errAbort("needHugeMem: trying to allocate 0 bytes");
00137 if ((pt = mhStack->alloc(size)) == NULL)
00138     errAbort("needHugeMen: Out of huge memory - request size %llu bytes\n",
00139              (unsigned long long)size);
00140 return pt;
00141 }

Here is the call graph for this function:

Here is the caller graph for this function:

void* needHugeMemResize ( void *  vp,
size_t  size 
)

Definition at line 153 of file memalloc.c.

References errAbort(), mhStack, and memHandler::realloc.

Referenced by needHugeZeroedMemResize().

00157 {
00158 void *pt;
00159 if ((pt = mhStack->realloc(vp, size)) == NULL)
00160     errAbort("needHugeMemResize: Out of memory - request resize %llu bytes\n",
00161         (unsigned long long)size);
00162 return pt;
00163 }

Here is the call graph for this function:

Here is the caller graph for this function:

void* needHugeZeroedMem ( size_t  size  ) 

Definition at line 144 of file memalloc.c.

References needHugeMem().

Referenced by gfNewEmpty().

00146 {
00147 void *v;
00148 v = needHugeMem(size);
00149 memset(v, 0, size);
00150 return v;
00151 }

Here is the call graph for this function:

Here is the caller graph for this function:

void* needHugeZeroedMemResize ( void *  vp,
size_t  oldSize,
size_t  newSize 
)

Definition at line 166 of file memalloc.c.

References needHugeMemResize().

00170 {
00171 void *v;
00172 v = needHugeMemResize(vp, newSize);
00173 if (newSize > oldSize)
00174     memset(((char*)v)+oldSize, 0, newSize-oldSize);
00175 return v;
00176 }

Here is the call graph for this function:

void* needLargeMem ( size_t  size  ) 

Definition at line 84 of file memalloc.c.

References memHandler::alloc, errAbort(), maxAlloc, and mhStack.

Referenced by allocNt4(), allocPatSpaceLists(), axtAffine2Level(), axtFromBlocks(), cloneMem(), dlSort(), dnaLoadNextFromStack(), fofFetch(), fofFetchString(), gfHitSortDiagonal(), makeHits8(), makeTileHash(), mgNew(), needLargeZeroedMem(), nibInput(), nt4LoadPart(), nt4Unpack(), parseMultiParts(), phmmMatrixNew(), pipelineFile(), rcSeqs(), readInGulp(), shuffleList(), slSort(), startServer(), translateSeqN(), twoBitFromFile(), and twoBitReadSeqFragExt().

00087 {
00088 void *pt;
00089 if (size == 0 || size >= maxAlloc)
00090     errAbort("needLargeMem: trying to allocate %llu bytes (limit: %llu)",
00091          (unsigned long long)size, (unsigned long long)maxAlloc);
00092 if ((pt = mhStack->alloc(size)) == NULL)
00093     errAbort("needLargeMem: Out of memory - request size %llu bytes\n",
00094              (unsigned long long)size);
00095 return pt;
00096 }

Here is the call graph for this function:

Here is the caller graph for this function:

void* needLargeMemResize ( void *  vp,
size_t  size 
)

Definition at line 107 of file memalloc.c.

References errAbort(), maxAlloc, mhStack, and memHandler::realloc.

Referenced by needLargeZeroedMemResize().

00110 {
00111 void *pt;
00112 if (size == 0 || size >= maxAlloc)
00113     errAbort("needLargeMemResize: trying to allocate %llu bytes (limit: %llu)",
00114          (unsigned long long)size, (unsigned long long)maxAlloc);
00115 if ((pt = mhStack->realloc(vp, size)) == NULL)
00116     errAbort("needLargeMemResize: Out of memory - request size %llu bytes\n",
00117              (unsigned long long)size);
00118 return pt;
00119 }

Here is the call graph for this function:

Here is the caller graph for this function:

void* needLargeZeroedMem ( size_t  size  ) 

Definition at line 98 of file memalloc.c.

References needLargeMem().

Referenced by bitAlloc(), bitClone(), newBlock(), and newPatSpace().

00100 {
00101 void *v;
00102 v = needLargeMem(size);
00103 memset(v, 0, size);
00104 return v;
00105 }

Here is the call graph for this function:

Here is the caller graph for this function:

void* needLargeZeroedMemResize ( void *  vp,
size_t  oldSize,
size_t  newSize 
)

Definition at line 121 of file memalloc.c.

References needLargeMemResize().

Referenced by bitRealloc(), and needMoreMem().

00124 {
00125 void *v = needLargeMemResize(vp, newSize);
00126 if (newSize > oldSize)
00127     memset(((char*)v)+oldSize, 0, newSize-oldSize);
00128 return v;
00129 }

Here is the call graph for this function:

Here is the caller graph for this function:

void* needMem ( size_t  size  ) 

Definition at line 180 of file memalloc.c.

References memHandler::alloc, errAbort(), mhStack, and NEEDMEM_LIMIT.

Referenced by addSuffix(), allocNt4(), axtAffine2Level(), bandExtFf(), base64Decode(), base64Encode(), cdaAliFromFfAli(), cdaLoadOne(), cdaLoadString(), cgiEncode(), cgiEncodeFull(), cloneStringZ(), copyFile(), cpFile(), crudeAliFind(), envUpdate(), errorSafeSetup(), expandRelativePath(), ffShAliPart(), ffShNeedle(), fillConcave(), findCrudeGenes(), flyLoadNt4Genome(), fofOpen(), fold2pairingList(), forwardMergeTwo(), geneDna(), getPostInput(), gffDupeGeneAndSurrounds(), gfPcrMakePrimer(), gif_compress_data(), gif_decoder(), headerBytes(), htmlEncode(), jpegSize(), kxTokNew(), lineFileAttach(), lmInit(), makeEscapedString(), makeFastProber(), makeQuotedString(), mgNew(), mixedCaseName(), netGetHugeString(), netGetLongString(), newDnaSeq(), newDyString(), newFileInfo(), newGdfGene(), newHash(), newKvt(), newSlName(), newWormFeature(), phmmMatrixNew(), plProcNew(), projectIntArray(), projectString(), pslShowAlignmentStranded(), pslShowAlignmentStranded2(), quotedPrintableDecode(), readAllWords(), readLine(), readString(), replaceChars(), saveAliToPermanentMem(), scanChromOffsetFile(), setProgram(), shaNewNode(), slNameNewN(), snofOpen(), spacedColumnFromLineFile(), spaceSaverAddOverflow(), strstrNoCase(), subTextString(), tabRowNew(), tokenizerOnLineFile(), wormLoadNt4Genome(), wormSearchAllCdna(), xaReadNext(), and xStitch().

00183 {
00184 void *pt;
00185 if (size == 0 || size > NEEDMEM_LIMIT)
00186     errAbort("needMem: trying to allocate %llu bytes (limit: %llu)",
00187          (unsigned long long)size, (unsigned long long)NEEDMEM_LIMIT);
00188 if ((pt = mhStack->alloc(size)) == NULL)
00189     errAbort("needMem: Out of memory - request size %llu bytes\n",
00190              (unsigned long long)size);
00191 memset(pt, 0, size);
00192 return pt;
00193 }

Here is the call graph for this function:

Here is the caller graph for this function:

void* needMoreMem ( void *  old,
size_t  oldSize,
size_t  newSize 
)

Definition at line 195 of file memalloc.c.

References needLargeZeroedMemResize().

Referenced by dyStringExpandBuf(), lineFileExpandBuf(), newEdge(), and pslNext().

00199 {
00200 return needLargeZeroedMemResize(old, oldSize, newSize);
00201 }

Here is the call graph for this function:

Here is the caller graph for this function:

struct memHandler* popMemHandler (  )  [read]

Definition at line 57 of file memalloc.c.

References defaultMemHandler, errAbort(), mhStack, and memHandler::next.

Referenced by memTrackerEnd().

00059 {
00060 struct memHandler *oldHandler = mhStack;
00061 if (mhStack == &defaultMemHandler)
00062     errAbort("Too many popMemHandlers()");
00063 mhStack = mhStack->next;
00064 return oldHandler;
00065 }

Here is the call graph for this function:

Here is the caller graph for this function:

void pushCarefulMemHandler ( size_t  maxAlloc  ) 

Definition at line 391 of file memalloc.c.

References carefulMemHandler, carefulMemInit(), carefulParent, and pushMemHandler().

00394 {
00395 carefulMemInit(maxAlloc);
00396 carefulParent = pushMemHandler(&carefulMemHandler);
00397 }

Here is the call graph for this function:

struct memHandler* pushMemHandler ( struct memHandler *  newHandler  )  [read]

Definition at line 47 of file memalloc.c.

References mhStack, and slAddHead.

Referenced by memTrackerStart(), and pushCarefulMemHandler().

00050 {
00051 struct memHandler *oldHandler = mhStack;
00052 slAddHead(&mhStack, newHandler);
00053 return oldHandler;
00054 }

Here is the caller graph for this function:

void setDefaultMemHandler (  ) 

Definition at line 68 of file memalloc.c.

References defaultMemHandler, and mhStack.

00070 {
00071 mhStack = &defaultMemHandler;
00072 }

void setMaxAlloc ( size_t  s  ) 

Definition at line 78 of file memalloc.c.

References maxAlloc.

00080 {
00081 maxAlloc = s;
00082 }

void* wantMem ( size_t  size  ) 

Definition at line 203 of file memalloc.c.

References memHandler::alloc, and mhStack.

Referenced by gffReadDna().

00206 {
00207 return mhStack->alloc(size);
00208 }

Here is the caller graph for this function:

Variable Documentation

int carefulAlignAdd [static]

Definition at line 228 of file memalloc.c.

Referenced by carefulAlloc(), and carefulMemInit().

bits32 carefulAlignMask [static]

Definition at line 235 of file memalloc.c.

Referenced by carefulAlloc(), and carefulMemInit().

int carefulAlignSize [static]

Definition at line 227 of file memalloc.c.

Referenced by carefulMemInit().

size_t carefulAlloced [static]

Definition at line 241 of file memalloc.c.

Referenced by carefulAlloc(), carefulFree(), and carefulTotalAllocated().

size_t carefulMaxToAlloc [static]

Definition at line 240 of file memalloc.c.

Referenced by carefulAlloc(), and carefulMemInit().

struct memHandler carefulMemHandler [static]

Initial value:

 

    {
    NULL,
    carefulAlloc,
    carefulFree,
    carefulRealloc,
    }

Definition at line 382 of file memalloc.c.

Referenced by pushCarefulMemHandler().

struct memHandler* carefulParent [static]

Definition at line 238 of file memalloc.c.

Referenced by carefulAlloc(), carefulCheckHeap(), carefulFree(), and pushCarefulMemHandler().

struct dlList* cmbAllocedList

Definition at line 256 of file memalloc.c.

Referenced by carefulAlloc(), carefulCheckHeap(), carefulCountBlocksAllocated(), and carefulMemInit().

char cmbEndCookie[4] = {0x44, 0x33, 0x7F, 0x42}

Definition at line 254 of file memalloc.c.

Referenced by carefulAlloc(), carefulCheckHeap(), and carefulFree().

int cmbStartCookie = 0x78753421

Definition at line 252 of file memalloc.c.

Referenced by carefulAlloc(), carefulCheckHeap(), and carefulFree().

struct memHandler defaultMemHandler [static]

Initial value:

 

    {
    NULL,
    defaultAlloc,
    defaultFree,
    defaultRealloc,
    }

Definition at line 36 of file memalloc.c.

Referenced by popMemHandler(), and setDefaultMemHandler().

size_t maxAlloc = 128*8*1024*1024*(sizeof(size_t)/4)*(sizeof(size_t)/4) [static]

Definition at line 76 of file memalloc.c.

Referenced by carefulAlloc(), needLargeMem(), needLargeMemResize(), and setMaxAlloc().

struct memTracker* memTracker = NULL [static]

Definition at line 408 of file memalloc.c.

Referenced by memTrackerAlloc(), memTrackerEnd(), memTrackerFree(), memTrackerRealloc(), and memTrackerStart().

struct memHandler* mhStack = &defaultMemHandler [static]

Definition at line 45 of file memalloc.c.

Referenced by freeMem(), needHugeMem(), needHugeMemResize(), needLargeMem(), needLargeMemResize(), needMem(), popMemHandler(), pushMemHandler(), setDefaultMemHandler(), and wantMem().

char const rcsid[] = "$Id: memalloc.c,v 1.30 2007/03/07 01:46:43 angie Exp $" [static]

Definition at line 16 of file memalloc.c.

Generated on Tue Dec 25 20:01:45 2007 for blat by  doxygen 1.5.2