"Fossies" - the Fresh Open Source Software Archive

Member "memcached-1.6.15/vendor/lua/src/lmem.c" (1 Oct 2021, 5894 Bytes) of package /linux/www/memcached-1.6.15.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file.

    1 /*
    2 ** $Id: lmem.c $
    3 ** Interface to Memory Manager
    4 ** See Copyright Notice in lua.h
    5 */
    6 
    7 #define lmem_c
    8 #define LUA_CORE
    9 
   10 #include "lprefix.h"
   11 
   12 
   13 #include <stddef.h>
   14 
   15 #include "lua.h"
   16 
   17 #include "ldebug.h"
   18 #include "ldo.h"
   19 #include "lgc.h"
   20 #include "lmem.h"
   21 #include "lobject.h"
   22 #include "lstate.h"
   23 
   24 
   25 #if defined(EMERGENCYGCTESTS)
   26 /*
   27 ** First allocation will fail whenever not building initial state.
   28 ** (This fail will trigger 'tryagain' and a full GC cycle at every
   29 ** allocation.)
   30 */
   31 static void *firsttry (global_State *g, void *block, size_t os, size_t ns) {
   32   if (completestate(g) && ns > 0)  /* frees never fail */
   33     return NULL;  /* fail */
   34   else  /* normal allocation */
   35     return (*g->frealloc)(g->ud, block, os, ns);
   36 }
   37 #else
   38 #define firsttry(g,block,os,ns)    ((*g->frealloc)(g->ud, block, os, ns))
   39 #endif
   40 
   41 
   42 
   43 
   44 
   45 /*
   46 ** About the realloc function:
   47 ** void *frealloc (void *ud, void *ptr, size_t osize, size_t nsize);
   48 ** ('osize' is the old size, 'nsize' is the new size)
   49 **
   50 ** - frealloc(ud, p, x, 0) frees the block 'p' and returns NULL.
   51 ** Particularly, frealloc(ud, NULL, 0, 0) does nothing,
   52 ** which is equivalent to free(NULL) in ISO C.
   53 **
   54 ** - frealloc(ud, NULL, x, s) creates a new block of size 's'
   55 ** (no matter 'x'). Returns NULL if it cannot create the new block.
   56 **
   57 ** - otherwise, frealloc(ud, b, x, y) reallocates the block 'b' from
   58 ** size 'x' to size 'y'. Returns NULL if it cannot reallocate the
   59 ** block to the new size.
   60 */
   61 
   62 
   63 
   64 
   65 /*
   66 ** {==================================================================
   67 ** Functions to allocate/deallocate arrays for the Parser
   68 ** ===================================================================
   69 */
   70 
   71 /*
   72 ** Minimum size for arrays during parsing, to avoid overhead of
   73 ** reallocating to size 1, then 2, and then 4. All these arrays
   74 ** will be reallocated to exact sizes or erased when parsing ends.
   75 */
   76 #define MINSIZEARRAY    4
   77 
   78 
   79 void *luaM_growaux_ (lua_State *L, void *block, int nelems, int *psize,
   80                      int size_elems, int limit, const char *what) {
   81   void *newblock;
   82   int size = *psize;
   83   if (nelems + 1 <= size)  /* does one extra element still fit? */
   84     return block;  /* nothing to be done */
   85   if (size >= limit / 2) {  /* cannot double it? */
   86     if (l_unlikely(size >= limit))  /* cannot grow even a little? */
   87       luaG_runerror(L, "too many %s (limit is %d)", what, limit);
   88     size = limit;  /* still have at least one free place */
   89   }
   90   else {
   91     size *= 2;
   92     if (size < MINSIZEARRAY)
   93       size = MINSIZEARRAY;  /* minimum size */
   94   }
   95   lua_assert(nelems + 1 <= size && size <= limit);
   96   /* 'limit' ensures that multiplication will not overflow */
   97   newblock = luaM_saferealloc_(L, block, cast_sizet(*psize) * size_elems,
   98                                          cast_sizet(size) * size_elems);
   99   *psize = size;  /* update only when everything else is OK */
  100   return newblock;
  101 }
  102 
  103 
  104 /*
  105 ** In prototypes, the size of the array is also its number of
  106 ** elements (to save memory). So, if it cannot shrink an array
  107 ** to its number of elements, the only option is to raise an
  108 ** error.
  109 */
  110 void *luaM_shrinkvector_ (lua_State *L, void *block, int *size,
  111                           int final_n, int size_elem) {
  112   void *newblock;
  113   size_t oldsize = cast_sizet((*size) * size_elem);
  114   size_t newsize = cast_sizet(final_n * size_elem);
  115   lua_assert(newsize <= oldsize);
  116   newblock = luaM_saferealloc_(L, block, oldsize, newsize);
  117   *size = final_n;
  118   return newblock;
  119 }
  120 
  121 /* }================================================================== */
  122 
  123 
  124 l_noret luaM_toobig (lua_State *L) {
  125   luaG_runerror(L, "memory allocation error: block too big");
  126 }
  127 
  128 
  129 /*
  130 ** Free memory
  131 */
  132 void luaM_free_ (lua_State *L, void *block, size_t osize) {
  133   global_State *g = G(L);
  134   lua_assert((osize == 0) == (block == NULL));
  135   (*g->frealloc)(g->ud, block, osize, 0);
  136   g->GCdebt -= osize;
  137 }
  138 
  139 
  140 /*
  141 ** In case of allocation fail, this function will do an emergency
  142 ** collection to free some memory and then try the allocation again.
  143 ** The GC should not be called while state is not fully built, as the
  144 ** collector is not yet fully initialized. Also, it should not be called
  145 ** when 'gcstopem' is true, because then the interpreter is in the
  146 ** middle of a collection step.
  147 */
  148 static void *tryagain (lua_State *L, void *block,
  149                        size_t osize, size_t nsize) {
  150   global_State *g = G(L);
  151   if (completestate(g) && !g->gcstopem) {
  152     luaC_fullgc(L, 1);  /* try to free some memory... */
  153     return (*g->frealloc)(g->ud, block, osize, nsize);  /* try again */
  154   }
  155   else return NULL;  /* cannot free any memory without a full state */
  156 }
  157 
  158 
  159 /*
  160 ** Generic allocation routine.
  161 */
  162 void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) {
  163   void *newblock;
  164   global_State *g = G(L);
  165   lua_assert((osize == 0) == (block == NULL));
  166   newblock = firsttry(g, block, osize, nsize);
  167   if (l_unlikely(newblock == NULL && nsize > 0)) {
  168     newblock = tryagain(L, block, osize, nsize);
  169     if (newblock == NULL)  /* still no memory? */
  170       return NULL;  /* do not update 'GCdebt' */
  171   }
  172   lua_assert((nsize == 0) == (newblock == NULL));
  173   g->GCdebt = (g->GCdebt + nsize) - osize;
  174   return newblock;
  175 }
  176 
  177 
  178 void *luaM_saferealloc_ (lua_State *L, void *block, size_t osize,
  179                                                     size_t nsize) {
  180   void *newblock = luaM_realloc_(L, block, osize, nsize);
  181   if (l_unlikely(newblock == NULL && nsize > 0))  /* allocation failed? */
  182     luaM_error(L);
  183   return newblock;
  184 }
  185 
  186 
  187 void *luaM_malloc_ (lua_State *L, size_t size, int tag) {
  188   if (size == 0)
  189     return NULL;  /* that's all */
  190   else {
  191     global_State *g = G(L);
  192     void *newblock = firsttry(g, NULL, tag, size);
  193     if (l_unlikely(newblock == NULL)) {
  194       newblock = tryagain(L, NULL, tag, size);
  195       if (newblock == NULL)
  196         luaM_error(L);
  197     }
  198     g->GCdebt += size;
  199     return newblock;
  200   }
  201 }