src/vm-limit.c

   1 /* Functions for memory limit warnings.
   2    Copyright (C) 1990, 1992, 2002, 2003, 2004,
   3                  2005, 2006 Free Software Foundation, Inc.
   4
   5 This file is part of GNU Emacs.
   6
   7 GNU Emacs is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU Emacs is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU Emacs; see the file COPYING.  If not, write to
  19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  20 Boston, MA 02110-1301, USA.  */
  21
  22 #ifdef emacs
  23 #include <config.h>
  24 #include "lisp.h"
  25 #endif
  26
  27 #ifndef emacs
  28 #include <stddef.h>
  29 typedef size_t SIZE;
  30 typedef void *POINTER;
  31 #define EXCEEDS_LISP_PTR(x) 0
  32 #endif
  33
  34 #include "mem-limits.h"
  35
  36 #ifdef HAVE_GETRLIMIT
  37 #include <sys/resource.h>
  38 #endif
  39
  40 /*
  41   Level number of warnings already issued.
  42   0 -- no warnings issued.
  43   1 -- 75% warning already issued.
  44   2 -- 85% warning already issued.
  45   3 -- 95% warning issued; keep warning frequently.
  46 */
  47 enum warnlevel { not_warned, warned_75, warned_85, warned_95 };
  48
  49 static enum warnlevel warnlevel;
  50
  51 /* Function to call to issue a warning;
  52    0 means don't issue them.  */
  53 static void (*warn_function) ();
  54
  55 /* Start of data space; can be changed by calling malloc_init.  */
  56 static POINTER data_space_start;
  57
  58 /* Number of bytes of writable memory we can expect to be able to get.  */
  59 static unsigned long lim_data;
  60 \f
  61
  62 #ifdef NO_LIM_DATA
  63 static void
  64 get_lim_data ()
  65 {
  66   lim_data = -1;
  67 }
  68 #else /* not NO_LIM_DATA */
  69
  70 #ifdef USG
  71
  72 static void
  73 get_lim_data ()
  74 {
  75   extern long ulimit ();
  76
  77   lim_data = -1;
  78
  79   /* Use the ulimit call, if we seem to have it.  */
  80 #if !defined (ULIMIT_BREAK_VALUE) || defined (GNU_LINUX)
  81   lim_data = ulimit (3, 0);
  82 #endif
  83
  84   /* If that didn't work, just use the macro's value.  */
  85 #ifdef ULIMIT_BREAK_VALUE
  86   if (lim_data == -1)
  87     lim_data = ULIMIT_BREAK_VALUE;
  88 #endif
  89
  90   lim_data -= (long) data_space_start;
  91 }
  92
  93 #else /* not USG */
  94 #ifdef WINDOWSNT
  95
  96 static void
  97 get_lim_data ()
  98 {
  99   extern unsigned long reserved_heap_size;
 100   lim_data = reserved_heap_size;
 101 }
 102
 103 #else
 104 #if !defined (BSD4_2) && !defined (__osf__)
 105
 106 #ifdef MSDOS
 107 void
 108 get_lim_data ()
 109 {
 110   _go32_dpmi_meminfo info;
 111
 112   _go32_dpmi_get_free_memory_information (&info);
 113   lim_data = info.available_memory;
 114 }
 115 #else /* not MSDOS */
 116 static void
 117 get_lim_data ()
 118 {
 119   lim_data = vlimit (LIM_DATA, -1);
 120 }
 121 #endif /* not MSDOS */
 122
 123 #else /* BSD4_2 */
 124
 125 static void
 126 get_lim_data ()
 127 {
 128   struct rlimit XXrlimit;
 129
 130   getrlimit (RLIMIT_DATA, &XXrlimit);
 131 #ifdef RLIM_INFINITY
 132   lim_data = XXrlimit.rlim_cur & RLIM_INFINITY; /* soft limit */
 133 #else
 134   lim_data = XXrlimit.rlim_cur; /* soft limit */
 135 #endif
 136 }
 137 #endif /* BSD4_2 */
 138 #endif /* not WINDOWSNT */
 139 #endif /* not USG */
 140 #endif /* not NO_LIM_DATA */
 141 \f
 142 /* Verify amount of memory available, complaining if we're near the end. */
 143
 144 static void
 145 check_memory_limits ()
 146 {
 147 #ifdef REL_ALLOC
 148   extern POINTER (*real_morecore) ();
 149 #endif
 150   extern POINTER (*__morecore) ();
 151
 152
 153   register POINTER cp;
 154   unsigned long five_percent;
 155   unsigned long data_size;
 156   enum warnlevel new_warnlevel;
 157
 158 #ifdef HAVE_GETRLIMIT
 159   struct rlimit rlimit;
 160
 161   getrlimit (RLIMIT_AS, &rlimit);
 162
 163   if (RLIM_INFINITY == rlimit.rlim_max)
 164     return;
 165
 166   /* This is a nonsensical case, but it happens -- rms.  */
 167   if (rlimit.rlim_cur > rlimit.rlim_max)
 168     return;
 169
 170   five_percent = rlimit.rlim_max / 20;
 171   data_size = rlimit.rlim_cur;
 172
 173 #else /* not HAVE_GETRLIMIT */
 174
 175   if (lim_data == 0)
 176     get_lim_data ();
 177   five_percent = lim_data / 20;
 178
 179   /* Find current end of memory and issue warning if getting near max */
 180 #ifdef REL_ALLOC
 181   if (real_morecore)
 182     cp = (char *) (*real_morecore) (0);
 183   else
 184 #endif
 185   cp = (char *) (*__morecore) (0);
 186   data_size = (char *) cp - (char *) data_space_start;
 187
 188 #endif /* not HAVE_GETRLIMIT */
 189
 190   if (!warn_function)
 191     return;
 192
 193   /* What level of warning does current memory usage demand?  */
 194   if (data_size > five_percent * 19)
 195     new_warnlevel = warned_95;
 196   else if (data_size > five_percent * 17)
 197     new_warnlevel = warned_85;
 198   else if (data_size > five_percent * 15)
 199     new_warnlevel = warned_75;
 200   else
 201     new_warnlevel = not_warned;
 202
 203   /* If we have gone up a level, give the appropriate warning.  */
 204   if (new_warnlevel > warnlevel || new_warnlevel == warned_95)
 205     {
 206       warnlevel = new_warnlevel;
 207       switch (warnlevel)
 208         {
 209         case warned_75:
 210           (*warn_function) ("Warning: past 75% of memory limit");
 211           break;
 212
 213         case warned_85:
 214           (*warn_function) ("Warning: past 85% of memory limit");
 215           break;
 216
 217         case warned_95:
 218           (*warn_function) ("Warning: past 95% of memory limit");
 219         }
 220     }
 221   /* Handle going down in usage levels, with some hysteresis.  */
 222   else
 223     {
 224       /* If we go down below 70% full, issue another 75% warning
 225          when we go up again.  */
 226       if (data_size < five_percent * 14)
 227         warnlevel = not_warned;
 228       /* If we go down below 80% full, issue another 85% warning
 229          when we go up again.  */
 230       else if (warnlevel > warned_75 && data_size < five_percent * 16)
 231         warnlevel = warned_75;
 232       /* If we go down below 90% full, issue another 95% warning
 233          when we go up again.  */
 234       else if (warnlevel > warned_85 && data_size < five_percent * 18)
 235         warnlevel = warned_85;
 236     }
 237
 238   if (EXCEEDS_LISP_PTR (cp))
 239     (*warn_function) ("Warning: memory in use exceeds lisp pointer size");
 240 }
 241 \f
 242 /* Enable memory usage warnings.
 243    START says where the end of pure storage is.
 244    WARNFUN specifies the function to call to issue a warning.  */
 245
 246 void
 247 memory_warnings (start, warnfun)
 248      POINTER start;
 249      void (*warnfun) ();
 250 {
 251   extern void (* __after_morecore_hook) ();     /* From gmalloc.c */
 252
 253   if (start)
 254     data_space_start = start;
 255   else
 256     data_space_start = start_of_data ();
 257
 258   warn_function = warnfun;
 259   __after_morecore_hook = check_memory_limits;
 260
 261   /* Force data limit to be recalculated on each run.  */
 262   lim_data = 0;
 263 }
 264
 265 /* arch-tag: eab04eda-1f69-447a-8d9f-95f0a3983ca5
 266    (do not change this comment) */