root/src/vm-limit.c

DEFINITIONS

1. get_lim_data
2. get_lim_data
3. get_lim_data
4. ret_lim_data
5. check_memory_limits
6. memory_warnings

     1 /* Functions for memory limit warnings.
     2    Copyright (C) 1990, 1992, 2001-2023 Free Software Foundation, Inc.
     3 
     4 This file is part of GNU Emacs.
     5 
     6 GNU Emacs is free software: you can redistribute it and/or modify
     7 it under the terms of the GNU General Public License as published by
     8 the Free Software Foundation, either version 3 of the License, or (at
     9 your option) any later version.
    10 
    11 GNU Emacs is distributed in the hope that it will be useful,
    12 but WITHOUT ANY WARRANTY; without even the implied warranty of
    13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    14 GNU General Public License for more details.
    15 
    16 You should have received a copy of the GNU General Public License
    17 along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
    18 
    19 #include <config.h>
    20 #include <unistd.h> /* for 'environ', on AIX */
    21 #include "lisp.h"
    22 
    23 #ifdef MSDOS
    24 #include "dosfns.h"
    25 extern int etext;
    26 #endif
    27 
    28 /* Some systems need this before <sys/resource.h>.  */
    29 #include <sys/types.h>
    30 
    31 #ifdef HAVE_SYS_RESOURCE_H
    32 # include <sys/time.h>
    33 # include <sys/resource.h>
    34 #else
    35 # if HAVE_SYS_VLIMIT_H
    36 #  include <sys/vlimit.h>       /* Obsolete, says glibc */
    37 # endif
    38 #endif
    39 
    40 /* Start of data.  It is OK if this is approximate; it's used only as
    41    a heuristic.  */
    42 #ifdef DATA_START
    43 # define data_start ((char *) DATA_START)
    44 #else
    45 extern char data_start[];
    46 # ifndef HAVE_DATA_START
    47 /* Initialize to nonzero, so that it's put into data and not bss.
    48    Link this file's object code first, so that this symbol is near the
    49    start of data.  */
    50 char data_start[1] = { 1 };
    51 # endif
    52 #endif
    53 
    54 #ifdef HAVE_MALLOC_H
    55 # include <malloc.h>
    56 #endif
    57 #ifndef DOUG_LEA_MALLOC
    58 # ifndef __MALLOC_HOOK_VOLATILE
    59 #  define __MALLOC_HOOK_VOLATILE volatile
    60 # endif
    61 extern void *(*__morecore) (ptrdiff_t);
    62 extern void (*__MALLOC_HOOK_VOLATILE __after_morecore_hook) (void);
    63 #endif
    64 
    65 /* From ralloc.c.  */
    66 #ifdef REL_ALLOC
    67 extern void *(*real_morecore) (ptrdiff_t);
    68 #endif
    69 
    70 /*
    71   Level number of warnings already issued.
    72   0 -- no warnings issued.
    73   1 -- 75% warning already issued.
    74   2 -- 85% warning already issued.
    75   3 -- 95% warning issued; keep warning frequently.
    76 */
    77 enum warnlevel { not_warned, warned_75, warned_85, warned_95 };
    78 static enum warnlevel warnlevel;
    79 
    80 /* Function to call to issue a warning;
    81    0 means don't issue them.  */
    82 static void (*warn_function) (const char *);
    83 
    84 /* Start of data space; can be changed by calling memory_warnings.  */
    85 static char *data_space_start;
    86 
    87 /* Number of bytes of writable memory we can expect to be able to get.  */
    88 static size_t lim_data;
    89 
    90 #ifdef HAVE_GETRLIMIT
    91 
    92 # ifndef RLIMIT_AS
    93 #  define RLIMIT_AS RLIMIT_DATA
    94 # endif
    95 
    96 static void
    97 get_lim_data (void)
    98 {
    99   /* Set LIM_DATA to the minimum of the maximum object size and the
   100      maximum address space.  Don't bother to check for values like
   101      RLIM_INFINITY since in practice they are not much less than SIZE_MAX.  */
   102   struct rlimit rlimit;
   103   lim_data
   104     = (getrlimit (RLIMIT_AS, &rlimit) == 0 && rlimit.rlim_cur <= SIZE_MAX
   105        ? rlimit.rlim_cur
   106        : SIZE_MAX);
   107 }
   108 
   109 #elif defined WINDOWSNT
   110 
   111 #include "w32heap.h"
   112 
   113 static void
   114 get_lim_data (void)
   115 {
   116   extern size_t reserved_heap_size;
   117   lim_data = reserved_heap_size;
   118 }
   119 
   120 #elif defined MSDOS
   121 
   122 void
   123 get_lim_data (void)
   124 {
   125   unsigned long totalram, freeram, totalswap, freeswap;
   126 
   127   dos_memory_info (&totalram, &freeram, &totalswap, &freeswap);
   128   lim_data = freeram;
   129   /* Don't believe they will give us more than 0.5 GB.   */
   130   if (lim_data > 512U * 1024U * 1024U)
   131     lim_data = 512U * 1024U * 1024U;
   132 }
   133 
   134 unsigned long
   135 ret_lim_data (void)
   136 {
   137   get_lim_data ();
   138   return lim_data;
   139 }
   140 #else
   141 # error "get_lim_data not implemented on this machine"
   142 #endif
   143 
   144 /* Verify amount of memory available, complaining if we're near the end. */
   145 
   146 static void
   147 check_memory_limits (void)
   148 {
   149 #ifndef REL_ALLOC
   150   void *(*real_morecore) (ptrdiff_t) = 0;
   151 #endif
   152 
   153   char *cp;
   154   size_t five_percent;
   155   size_t data_size;
   156   enum warnlevel new_warnlevel;
   157 
   158   if (lim_data == 0)
   159     get_lim_data ();
   160   five_percent = lim_data / 20;
   161 
   162   /* Find current end of memory and issue warning if getting near max */
   163   cp = (real_morecore ? real_morecore : __morecore) (0);
   164   data_size = cp - data_space_start;
   165 
   166   if (!warn_function)
   167     return;
   168 
   169   /* What level of warning does current memory usage demand?  */
   170   new_warnlevel
   171     = (data_size > five_percent * 19) ? warned_95
   172     : (data_size > five_percent * 17) ? warned_85
   173     : (data_size > five_percent * 15) ? warned_75
   174     : not_warned;
   175 
   176   /* If we have gone up a level, give the appropriate warning.  */
   177   if (new_warnlevel > warnlevel || new_warnlevel == warned_95)
   178     {
   179       warnlevel = new_warnlevel;
   180       static char const *const warn_diagnostic[] =
   181         {
   182           "Warning: past 75% of memory limit",
   183           "Warning: past 85% of memory limit",
   184           "Warning: past 95% of memory limit"
   185         };
   186       warn_function (warn_diagnostic[warnlevel - 1]);
   187     }
   188   /* Handle going down in usage levels, with some hysteresis.  */
   189   else
   190     {
   191       /* If we go down below 70% full, issue another 75% warning
   192          when we go up again.  */
   193       if (data_size < five_percent * 14)
   194         warnlevel = not_warned;
   195       /* If we go down below 80% full, issue another 85% warning
   196          when we go up again.  */
   197       else if (warnlevel > warned_75 && data_size < five_percent * 16)
   198         warnlevel = warned_75;
   199       /* If we go down below 90% full, issue another 95% warning
   200          when we go up again.  */
   201       else if (warnlevel > warned_85 && data_size < five_percent * 18)
   202         warnlevel = warned_85;
   203     }
   204 }
   205 
   206 /* Enable memory usage warnings.
   207    START says where the end of pure storage is.
   208    WARNFUN specifies the function to call to issue a warning.  */
   209 
   210 void
   211 memory_warnings (void *start, void (*warnfun) (const char *))
   212 {
   213   data_space_start = start ? start : data_start;
   214 
   215   warn_function = warnfun;
   216   __after_morecore_hook = check_memory_limits;
   217 
   218   /* Force data limit to be recalculated on each run.  */
   219   lim_data = 0;
   220 }