Index: doc/driver/invocation =================================================================== --- doc/driver/invocation (Revision 2505) +++ doc/driver/invocation (Arbeitskopie) @@ -183,9 +183,16 @@ Giving this option results in smaller, but also more fragmented swapfiles, and the swap performance may degrade. - --max-malloc - Restrict total memory allocations to bytes. + --hard-malloc-limit + Restrict total memory allocation to bytes. A of 0 or 'unlimited' removes any restriction.\n" + + --soft-malloc-limit + This value gives a soft limit of the allocated memory (kind of low + watermark). If this value is exceeded, the driver will call low_memory() + in the master to inform the mudlib about the (potenntially) developing low + memory situation. + A of 0 or 'unlimited' removes this threshold. --min-malloc --min-small-malloc Index: doc/master/low_memory =================================================================== --- doc/master/low_memory (Revision 0) +++ doc/master/low_memory (Revision 0) @@ -0,0 +1,58 @@ +SYNOPSIS + void low_memory(int what, int limitvalue, int memory, int reservestate) + +DESCRIPTION + This efun is called when there is a (potential) low-memory situation. + Two different limits for the amount of allocated memory can be + configured: a soft limit and a hard limit. + If the soft limit is exceeded, the driver calls low_memory() but does + nothing else. + If the hard limit is exceeded, the driver calls low_memory() as well, + but initiates a garbage collection directly after the call. + The efun is called as well directly before a user-initiated garbage + collection is started. + + denotes the type of limit which was exceeded: + - NO_MALLOC_LIMIT_EXCEEDED (0) + No limit was exceeded, by a garbage collection was requested by a + call to garbage_collection() and it will begin right after + low_memory() returns. + - SOFT_MALLOC_LIMIT_EXCEEDED (1) + The soft limit was exceeded. + - HARD_MALLOC_LIMIT_EXCEEDED (2) + The hard limit was exceeded. A garbage collection will begin right + after low_memory() returns. + + specifies the numerical value of the limit which was exceeded. + It is 0 in case of NO_MALLOC_LIMIT_EXCEEDED. + + specifies the amount of allocated memory right now. + + specifies the current state of the memory reserves of + the driver. The states of the 3 different reserves are OR'ed together. + - USER_RESERVE_AVAILABLE (1) + The user reserve is available. + - MASTER_RESERVE_AVAILABLE (2) + The master reserve is available. + - SYSTEM_RESERVE_AVAILABLE (4) + The system reserve is available. + + This efun might be used to inform users about the garbage collection + and the expeced long lag. + Another possibility is to initiate a garbage collection deliberately + at a suitable time (e.g. during the following night) after the soft + limit was hit. + +REMARKS + If in a low_memory condition when the memory reserves have been used + already they could not be re-allocated after a garbage_collection() + slow_shut_down() is called instead of calling this function again. + +HISTORY + Introduced in 3.3.719 + +SEE ALSO + debug_info(E), garbage_collection(E) + slow_shut_down(M) + memory(C) + malloc(D) Index: doc/master/slow_shut_down =================================================================== --- doc/master/slow_shut_down (Revision 2505) +++ doc/master/slow_shut_down (Arbeitskopie) @@ -38,3 +38,4 @@ SEE ALSO quota_demon(M), notify_shutdown(M), shutdown(E), malloc(D), memory(C) + low_memory(M) Index: doc/concepts/memory =================================================================== --- doc/concepts/memory (Revision 2505) +++ doc/concepts/memory (Arbeitskopie) @@ -53,4 +53,6 @@ other objects. SEE ALSO - clean_up(A), slow_shut_down(M), quota_demon(M), malloc(D) + clean_up(A), slow_shut_down(M), quota_demon(M), low_memory(M) + malloc(D), + garbage_collection(E) Index: src/settings/lethynna =================================================================== --- src/settings/lethynna (Revision 2505) +++ src/settings/lethynna (Arbeitskopie) @@ -40,7 +40,7 @@ with_htable_size=65536 with_otable_size=8192 -with_max_malloced=0x20000000 +with_hard_malloc_limit=0x20000000 with_max_array_size=10000 with_max_mapping_keys=40000 Index: src/settings/evermore =================================================================== --- src/settings/evermore (Revision 2505) +++ src/settings/evermore (Arbeitskopie) @@ -96,7 +96,7 @@ with_reserved_user_size=800000 with_catch_reserved_cost=0xF000 with_master_reserved_cost=0xF000 -with_max_malloced=0 +with_hard_malloc_limit=0 enable_use_system_crypt=no enable_with_pthreads=no Index: src/settings/dt2 =================================================================== --- src/settings/dt2 (Revision 2505) +++ src/settings/dt2 (Arbeitskopie) @@ -32,7 +32,7 @@ with_max_players=100 with_min_malloced=0x1000000 -with_max_malloced=0x8000000 +with_hard_malloc_limit=0x8000000 with_htable_size=65536 with_itable_size=4096 Index: src/settings/gestrandet =================================================================== --- src/settings/gestrandet (Revision 2505) +++ src/settings/gestrandet (Arbeitskopie) @@ -23,7 +23,7 @@ with_reserved_user_size=0x400000 with_reserved_master_size=0x100000 with_reserved_system_size=0x200000 -with_max_malloced=0x1c000000 +with_hard_malloc_limit=0x1c000000 enable_min_malloced=yes with_min_malloced=0x8000000 enable_min_small_malloced=yes Index: src/settings/eotl =================================================================== --- src/settings/eotl (Revision 2505) +++ src/settings/eotl (Arbeitskopie) @@ -15,7 +15,7 @@ with_read_file_max_size=3000000 with_max_byte_transfer=500000 -with_max_malloced=0x6000000 +with_hard_malloc_limit=0x6000000 with_min_malloced=0x2000000 with_time_to_clean_up=7200 Index: src/settings/bat =================================================================== --- src/settings/bat (Revision 2505) +++ src/settings/bat (Arbeitskopie) @@ -65,7 +65,7 @@ with_compiler_stack_size=600 with_max_user_trace=120 with_max_trace=125 -with_max_malloced=0 +with_hard_malloc_limit=0 with_max_cost=20000000 with_catch_reserved_cost=150000 Index: src/settings/silberland =================================================================== --- src/settings/silberland (Revision 2505) +++ src/settings/silberland (Arbeitskopie) @@ -38,4 +38,4 @@ enable_use_parse_command=no enable_share_variables=no -with_max_malloced=0x5000000 +with_hard_malloc_limit=0x5000000 Index: src/settings/beutelland =================================================================== --- src/settings/beutelland (Revision 2505) +++ src/settings/beutelland (Arbeitskopie) @@ -18,7 +18,7 @@ with_reserved_user_size=0x800000 with_reserved_master_size=0x50000 with_reserved_system_size=0x100000 -with_max_malloced=0x16000000 +with_hard_malloc_limit=0x16000000 # --- Interpreter --- with_max_cost=1000000 Index: src/settings/dragonfire =================================================================== --- src/settings/dragonfire (Revision 2505) +++ src/settings/dragonfire (Arbeitskopie) @@ -41,7 +41,7 @@ --with-portno=1999 \ --with-udp-port=2000 \ --with-max-cost=2100000 \ ---with-max-malloced=0 \ +--with-hard-malloc-limit=0 \ --with-min-malloced=0x80000 \ --with-min-small-malloced=0x80000 \ --with-otable-size=8192 \ Index: src/settings/avalon =================================================================== --- src/settings/avalon (Revision 2505) +++ src/settings/avalon (Arbeitskopie) @@ -40,7 +40,7 @@ with_htable_size=65536 with_otable_size=8192 -with_max_malloced=0x23000000 +with_hard_malloc_limit=0x23000000 with_max_array_size=10000 with_max_mapping_keys=40000 Index: src/settings/pkmud =================================================================== --- src/settings/pkmud (Revision 2505) +++ src/settings/pkmud (Arbeitskopie) @@ -46,5 +46,5 @@ enable_share_variables=no with_min_malloced=0x80000 -with_max_malloced=0x5000000 +with_hard_malloc_limit=0x5000000 enable_dynamic_costs=yes Index: src/settings/default =================================================================== --- src/settings/default (Revision 2505) +++ src/settings/default (Arbeitskopie) @@ -127,7 +127,7 @@ # This value gives the upper limits for the total allocated memory. # A value of 0 means 'unlimited'. -with_max_malloced=0x4000000 +with_hard_malloc_limit=0x4000000 # If these values are >0, the driver will reserve this amount of memory # on startup for large resp. small blocks, reducing the block fragmentation. Index: src/settings/traumland =================================================================== --- src/settings/traumland (Revision 2505) +++ src/settings/traumland (Arbeitskopie) @@ -31,7 +31,7 @@ with_reserved_user_size=0x1000000 with_reserved_master_size=0x100000 with_reserved_system_size=0x400000 -with_max_malloced=0x10000000 +with_hard_malloc_limit=0x10000000 with_min_malloced=0x1000000 with_min_small_malloced=0x400000 Index: src/settings/unitopia =================================================================== --- src/settings/unitopia (Revision 2505) +++ src/settings/unitopia (Arbeitskopie) @@ -30,7 +30,7 @@ with_reserved_user_size=0x400000 with_reserved_master_size=0x100000 with_reserved_system_size=0x200000 -with_max_malloced=0x60000000 +with_hard_malloc_limit=0x60000000 enable_min_malloced=yes with_min_malloced=0x8000000 enable_min_small_malloced=yes Index: src/settings/morgengrauen =================================================================== --- src/settings/morgengrauen (Revision 2505) +++ src/settings/morgengrauen (Arbeitskopie) @@ -59,7 +59,7 @@ with_max_byte_transfer=200000 with_min_malloced=0xfa00000 with_min_small_malloced=0x8200000 -with_max_malloced=0x7fffffff +with_hard_malloc_limit=0x7fffffff with_pcre_recursion_limit=20000 with_optimize=med Index: src/settings/tubmud =================================================================== --- src/settings/tubmud (Revision 2505) +++ src/settings/tubmud (Arbeitskopie) @@ -31,7 +31,7 @@ # --- Memory --- with_reserved_user_size=0x100000 -with_max_malloced=0x06000000 +with_hard_malloc_limit=0x06000000 # --- Interpreter --- enable_strict_euids=no Index: src/settings/finalfrontier =================================================================== --- src/settings/finalfrontier (Revision 2505) +++ src/settings/finalfrontier (Arbeitskopie) @@ -32,7 +32,7 @@ with_reserved_user_size=0x400000 with_reserved_master_size=0x100000 with_reserved_system_size=0x200000 -with_max_malloced=0x16000000 +with_hard_malloc_limit=0x16000000 enable_min_malloced=yes with_min_malloced=0x8000000 enable_min_small_malloced=yes Index: src/settings/wunderland =================================================================== --- src/settings/wunderland (Revision 2505) +++ src/settings/wunderland (Arbeitskopie) @@ -106,7 +106,7 @@ --with-malloc=default \ --with-min-malloced=0 \ --with-min-small-malloced=0 \ ---with-max-malloced=0x6000000 \ +--with-hard-malloc-limit=0x6000000 \ --with-total-trace-length=0x1000 \ --with-wizlist-file=WIZLIST \ $* Index: src/smalloc.c =================================================================== --- src/smalloc.c (Revision 2505) +++ src/smalloc.c (Arbeitskopie) @@ -3039,7 +3039,7 @@ ) ) { - static const char mess[] = "MAX_MALLOCED limit reached.\n"; + static const char mess[] = "HARD_MALLOC_LIMIT reached.\n"; writes(2, mess); ptr = NULL; Index: src/xalloc.c =================================================================== --- src/xalloc.c (Revision 2505) +++ src/xalloc.c (Arbeitskopie) @@ -126,10 +126,19 @@ mp_int reserved_master_size = RESERVED_MASTER_SIZE; mp_int reserved_system_size = RESERVED_SYSTEM_SIZE; -mp_int min_malloced = MIN_MALLOCED; /* Allocation limits */ -mp_int min_small_malloced = MIN_SMALL_MALLOCED; /* Allocation limits */ -mp_int max_malloced = MAX_MALLOCED; +/* at startup reserve these amounts of memory for large and small blocks */ +mp_int min_malloced = MIN_MALLOCED; +mp_int min_small_malloced = MIN_SMALL_MALLOCED; +/* this is the hard limit for memory allocations. */ +static mp_int max_malloced = HARD_MALLOC_LIMIT_DEFAULT; +/* this is a soft limit for memory allocations. It serves as a kind of low + * watermark. If exceeded, the game driver will inform the mudlib by calling + * low_memory() in the master. */ +static mp_int soft_malloc_limit = SOFT_MALLOC_LIMIT_DEFAULT; +/* Was the low_memory() already called in the master`*/ +static Bool low_memory_applied = FALSE; + int stack_direction = 0; /* 0: Unknown stack behaviour * +1: Stack grows upward * -1: Stack grows downward @@ -180,7 +189,7 @@ /* Forward declarations */ #ifdef MALLOC_LPC_TRACE -static void write_lpc_trace (int d, word_t *p, int oneline); +static void write_lpc_trace (int d, word_t *p, int oneline) __attribute__((nonnull(2))); #endif #ifdef GC_SUPPORT @@ -518,7 +527,7 @@ #ifndef NO_MEM_BLOCK_SIZE if (max_malloced > 0 && (mp_int)xalloc_stat.size > max_malloced) { - static const char mess[] = "MAX_MALLOCED limit reached.\n"; + static const char mess[] = "HARD_MALLOC_LIMIT reached.\n"; writes(2, mess); if (malloc_privilege < MALLOC_SYSTEM) return MY_TRUE; @@ -1663,4 +1672,126 @@ return p; } /* string_copy_traced() */ +/*-------------------------------------------------------------------------*/ +void +notify_lowmemory_condition(short what) +/* Calls low_memory(what, , , ) + * in the master. + */ +{ + short reservestate = 0; + push_number(inter_sp, what); + if (what == SOFT_MALLOC_LIMIT_EXCEEDED) + push_number(inter_sp, soft_malloc_limit); + else if (what == HARD_MALLOC_LIMIT_EXCEEDED) + push_number(inter_sp, max_malloced); + else + push_number(inter_sp, 0); + push_number(inter_sp, xalloc_stat.size); + if (reserved_user_area) + reservestate |= USER_RESERVE_AVAILABLE; + if (reserved_master_area) + reservestate |= MASTER_RESERVE_AVAILABLE; + if (reserved_system_area) + reservestate |= SYSTEM_RESERVE_AVAILABLE; + push_number(inter_sp, reservestate); + callback_master(STR_LOW_MEMORY, 4); +} /* inform_lowmemory_condition */ + +/*-------------------------------------------------------------------------*/ +void +check_for_soft_malloc_limit (void) +/* If soft_malloc_limit is set, check if the allocated memory exceeds it. + * If yes and the master was not notified until now, low_memory() is called + * in the mudlib master and low_memory_applied ist set to prevent any further + * notifications. + * If the limit is not exceeded, low_memory_applied is reset. + * Should be called from the backend. + */ +{ +#ifndef NO_MEM_BLOCK_SIZE + if (soft_malloc_limit > 0) + { + if ((mp_int)xalloc_stat.size > soft_malloc_limit) + { + if (!low_memory_applied) + { + /* call low_memory(malloced_memory) in the master but first + * set the flag to prevent calling every backend cycle in case + * of errors. */ + low_memory_applied = TRUE; + notify_lowmemory_condition(SOFT_MALLOC_LIMIT_EXCEEDED); + } + } + else if (low_memory_applied) + { + /* OK, memory consumption shrunk below the soft limit. Reset the + * warning, so that the next time the limit is exceeded, + * the master apply is done again. */ + low_memory_applied = FALSE; + } + } +#endif +} /* check_for_soft_malloc_limit() */ + +/*-------------------------------------------------------------------------*/ +Bool +set_memory_limit(short what, mp_int limit) +/* Sets the memory limit to . + * for SOFT_MLIMIT has to be < HARD_MLIMIT. + * return TRUE on success and FALSE otherwise. + * If the current memory allocation is smaller than a new soft limit, the flag + * low_memory_applied is reset. + */ +{ +#ifndef NO_MEM_BLOCK_SIZE + // limits smaller than the sum of reserves (and some more) are harmful and + // lead anyway to immediate crashes... But we ignore this here, because + // reserve_memory() will deal with the needed sizes for the reserves and the + // minimum allocations. And later on in the game we will just prevent to + // set the limit smaller then the already allocated memory. + + if (what == MALLOC_SOFT_LIMIT) + { + if (limit >= max_malloced || limit < 0) + return FALSE; + + soft_malloc_limit = limit; + /* reset flag if appropriate. */ + if ((mp_int)xalloc_stat.size < soft_malloc_limit + && low_memory_applied) + low_memory_applied = FALSE; + } + else + { + // setting the limit below the currently allocated memory seems to be + // a very bad idea. + if (limit && limit <= (mp_int)xalloc_stat.size) + return FALSE; + + max_malloced = limit; + /* TODO: or disable it altogether? */ + if (soft_malloc_limit > max_malloced) + soft_malloc_limit = max_malloced - 1 ; + } + return TRUE; +#else + return FALSE; +#endif // NO_MEM_BLOCK_SIZE +} /* set_memory_limit */ + +/*-------------------------------------------------------------------------*/ +mp_int +get_memory_limit(short what) +/* Return the value of limit . */ +{ +#ifndef NO_MEM_BLOCK_SIZE + if (what == MALLOC_SOFT_LIMIT) + return soft_malloc_limit; + else + return max_malloced; +#else + return 0; +#endif +} /***************************************************************************/ Index: src/main.c =================================================================== --- src/main.c (Revision 2505) +++ src/main.c (Arbeitskopie) @@ -1040,7 +1040,8 @@ , cHBInterval /* --heart-interval */ , cHostname /* --hostname */ , cHostaddr /* --hostaddr */ - , cMaxMalloc /* --max-malloc */ + , cMaxMalloc /* --hard-malloc-limit */ + , cSoftMallocLimit /* --soft-malloc-limit */ , cMaxArray /* --max-array */ , cMaxBytes /* --max-bytes */ , cMaxCallouts /* --max-callouts */ @@ -1364,13 +1365,22 @@ " Reuse free space in the swap file immediately.\n" } - , { 0, "max-malloc", cMaxMalloc, MY_TRUE - , " --max-malloc \n" - , " --max-malloc \n" - " Restrict total memory allocations to bytes. A of 0\n" + , { 0, "hard-malloc-limit", cMaxMalloc, MY_TRUE + , " --hard-malloc-lmit \n" + , " --hard-malloc-limit \n" + " Restrict total memory allocation to bytes. A of 0\n" " or 'unlimited' removes any restriction.\n" } + , { 0, "soft-malloc-limit", cSoftMallocLimit, MY_TRUE + , " --soft-malloc-lmit \n" + , " --soft-malloc-limit \n" + " If total memory allocation exceeds bytes, inform the mudlib\n" + " master about a developing low memory situation. A of 0\n" + " or 'unlimited' removes the threshold. must be smaller than\n" + " --hard-malloc-limit.\n" + } + , { 0, "min-malloc", cMinMalloc, MY_TRUE , " --min-malloc \n" , " --min-malloc \n" @@ -1972,12 +1982,18 @@ , MIN_SMALL_MALLOCED ); - printf(" max allocation: "); - if (MAX_MALLOCED > 0) - printf("%9d\n", MAX_MALLOCED); + printf(" hard memory allocation limit: "); + if (HARD_MALLOC_LIMIT_DEFAULT > 0) + printf("%9d\n", HARD_MALLOC_LIMIT_DEFAULT); else printf("unlimited\n"); - + + printf(" soft memory allocation limit: "); + if (SOFT_MALLOC_LIMIT_DEFAULT > 0) + printf("%9d\n", SOFT_MALLOC_LIMIT_DEFAULT); + else + printf("unlimited\n"); + printf("Internal tables: shared string hash: %6d entries\n" " object hash: %6d entries\n" " reserved name hash: %6d entries\n" @@ -2513,19 +2529,33 @@ case cMaxMalloc: if (!strcasecmp(pValue, "unlimited")) { - max_malloced = 0; + set_memory_limit(MALLOC_HARD_LIMIT, 0); } else { - max_malloced = strtol(pValue, (char **)0, 0); - if (max_malloced < 0) + if (!set_memory_limit(MALLOC_HARD_LIMIT, strtol(pValue, (char **)0, 0))) { - fprintf(stderr, "Illegal value '%s' for --max-malloc\n", pValue); + fprintf(stderr, "Illegal value '%s' for --hard-malloc-limit\n", pValue); return hrError; } } break; + case cSoftMallocLimit: + if (!strcasecmp(pValue, "unlimited")) + { + set_memory_limit(MALLOC_SOFT_LIMIT, 0); + } + else + { + if (!set_memory_limit(MALLOC_SOFT_LIMIT, strtol(pValue, (char **)0, 0))) + { + fprintf(stderr, "Illegal value '%s' for --soft-malloc-limit\n", pValue); + return hrError; + } + } + break; + case cMudlib: if (chdir(pValue) == -1) { fprintf(stderr, "Bad mudlib directory: %s\n", pValue); Index: src/xalloc.h =================================================================== --- src/xalloc.h (Revision 2505) +++ src/xalloc.h (Arbeitskopie) @@ -67,10 +67,29 @@ /* --- Constants --- */ /* Allocation privilege levels */ +enum malloc_privileges { + MALLOC_USER = 0, + MALLOC_MASTER = 1, + MALLOC_SYSTEM = 2, +}; -#define MALLOC_USER (0) -#define MALLOC_MASTER (1) -#define MALLOC_SYSTEM (2) +/* memory limits */ +enum memory_limit_types { + MALLOC_SOFT_LIMIT = 1, + MALLOC_HARD_LIMIT = 2, +}; +/* low memory conditions */ +enum low_memory_conditions { + NO_MALLOC_LIMIT_EXCEEDED = 0, + SOFT_MALLOC_LIMIT_EXCEEDED = MALLOC_SOFT_LIMIT, + HARD_MALLOC_LIMIT_EXCEEDED = MALLOC_HARD_LIMIT, +}; +/* Flags for available reserves */ +enum available_reserve_flags { + USER_RESERVE_AVAILABLE = 1, + MASTER_RESERVE_AVAILABLE = 2, + SYSTEM_RESERVE_AVAILABLE = 4, +}; /* --- Variables --- */ @@ -84,7 +103,6 @@ extern mp_int reserved_system_size; extern mp_int min_malloced; extern mp_int min_small_malloced; -extern mp_int max_malloced; extern int stack_direction; @@ -122,43 +140,49 @@ #define xalloc_pass(size) xalloc_traced((size) MTRACE_PASS) #define rexalloc_pass(old,size) rexalloc_traced((old),(size) MTRACE_PASS) -extern size_t xalloced_size (POINTER p); +extern size_t xalloced_size (POINTER p) __attribute__((nonnull(1))); extern size_t xalloc_overhead (void); -extern POINTER xalloc_traced(size_t size MTRACE_DECL) - MALLOC __attribute__ ((warn_unused_result)); + +extern POINTER xalloc_traced(size_t size MTRACE_DECL) + MALLOC __attribute__ ((warn_unused_result)); + extern void xfree(POINTER); -extern POINTER rexalloc_traced(POINTER, size_t MTRACE_DECL) - MALLOC __attribute__ ((warn_unused_result)); -extern POINTER pxalloc_traced(size_t MTRACE_DECL) - MALLOC __attribute__ ((warn_unused_result)); -extern POINTER prexalloc_traced(POINTER, size_t MTRACE_DECL) - MALLOC __attribute__ ((warn_unused_result)); + +extern POINTER rexalloc_traced(POINTER, size_t size MTRACE_DECL) + MALLOC __attribute__((warn_unused_result)); + +extern POINTER pxalloc_traced(size_t size MTRACE_DECL) + MALLOC __attribute__ ((warn_unused_result)); +extern POINTER prexalloc_traced(POINTER, size_t size MTRACE_DECL) + MALLOC __attribute__((warn_unused_result)); + extern void pfree(POINTER); -extern void * malloc_increment_size (void *vp, size_t size); +extern void * malloc_increment_size (void *vp, size_t size) + __attribute__((nonnull(1))); #ifdef GC_SUPPORT -extern void x_clear_ref (POINTER p); -extern int x_mark_ref (POINTER p); -extern Bool x_test_ref (POINTER p); +extern void x_clear_ref (POINTER p) __attribute__((nonnull(1))); +extern int x_mark_ref (POINTER p) __attribute__((nonnull(1))); +extern Bool x_test_ref (POINTER p) __attribute__((nonnull(1))); #endif /* GC_SUPPORT */ #ifdef MALLOC_TRACE extern void store_print_block_dispatch_info(void *block, void (*func)(int, void *, int) ); -extern Bool is_freed(void *p, p_uint minsize); +extern Bool is_freed(void *p, p_uint minsize) __attribute__((nonnull(1))); #endif /* MALLOC_TRACE */ #ifdef CHECK_OBJECT_GC_REF -extern void note_object_allocation_info ( void *block ); -extern void note_program_allocation_info ( void *block ); -extern Bool is_object_allocation ( void *block ); -extern Bool is_program_allocation ( void *block ); +extern void note_object_allocation_info ( void *block ) __attribute__((nonnull(1))); +extern void note_program_allocation_info ( void *block ) __attribute__((nonnull(1))); +extern Bool is_object_allocation ( void *block ) __attribute__((nonnull(1))); +extern Bool is_program_allocation ( void *block ) __attribute__((nonnull(1))); #endif /* CHECK_OBJECT_RC_REF */ /* Functions directly exported from the allocator: */ -extern void mem_dump_data(strbuf_t *sbuf); -extern void mem_dump_extdata(strbuf_t *sbuf); -extern void mem_dinfo_data(svalue_t *svp, int value); +extern void mem_dump_data(strbuf_t *sbuf) __attribute__((nonnull(1))); +extern void mem_dump_extdata(strbuf_t *sbuf) __attribute__((nonnull(1))); +extern void mem_dinfo_data(svalue_t *svp, int value) __attribute__((nonnull(1))); extern void mem_consolidate (Bool force); extern Bool mem_dump_memory(int fd); #ifdef MALLOC_EXT_STATISTICS @@ -178,13 +202,19 @@ #define string_copy(s) string_copy_traced(s) #endif -extern char * string_copy_traced(const char *str MTRACE_DECL) MALLOC; -extern void dump_lpc_trace (int d, void *p); -extern void dump_malloc_trace (int d, void *adr); +extern char * string_copy_traced(const char *str MTRACE_DECL) MALLOC + __attribute__((nonnull(1))) __attribute__((warn_unused_result)); +extern void dump_lpc_trace (int d, void *p) __attribute__((nonnull(2))); +extern void dump_malloc_trace (int d, void *adr) __attribute__((nonnull(2))); extern void get_stack_direction (void); extern void assert_stack_gap(void); extern void reserve_memory (void); extern void reallocate_reserved_areas(void); +extern void check_for_soft_malloc_limit(void); +extern void notify_lowmemory_condition(short what); +extern Bool set_memory_limit(short what, mp_int limit); +extern mp_int get_memory_limit(short what); + #endif /* XALLOC_H__ */ Index: src/lex.c =================================================================== --- src/lex.c (Revision 2505) +++ src/lex.c (Arbeitskopie) @@ -804,7 +804,7 @@ sprintf(mtext, "%d", ERQ_MAX_REPLY); add_permanent_define("__ERQ_MAX_REPLY__", -1, string_copy(mtext), MY_FALSE); #endif - sprintf(mtext, "%"PRIdMPINT, max_malloced); + sprintf(mtext, "%"PRIdMPINT, get_memory_limit(MALLOC_HARD_LIMIT)); add_permanent_define("__MAX_MALLOC__", -1, string_copy(mtext), MY_FALSE); sprintf(mtext, "%"PRId32, def_eval_cost); add_permanent_define("__MAX_EVAL_COST__", -1, string_copy(mtext), MY_FALSE); Index: src/slaballoc.c =================================================================== --- src/slaballoc.c (Revision 2505) +++ src/slaballoc.c (Arbeitskopie) @@ -3254,7 +3254,7 @@ ) ) { - static const char mess[] = "MAX_MALLOCED limit reached.\n"; + static const char mess[] = "HARD_MALLOC_LIMIT reached.\n"; writes(2, mess); ptr = NULL; Index: src/autoconf/configure.in =================================================================== --- src/autoconf/configure.in (Revision 2505) +++ src/autoconf/configure.in (Arbeitskopie) @@ -217,7 +217,8 @@ AC_MY_ARG_WITH(malloc,default,[default/smalloc/slaballoc/sysmalloc/ptmalloc],[memory manager to use]) AC_MY_ARG_WITH(min-malloced,0,,) AC_MY_ARG_WITH(min-small-malloced,0,,) -AC_MY_ARG_WITH(max-malloced,0x4000000,,) +AC_MY_ARG_WITH(hard-malloc-limit,0x4000000,,) +AC_MY_ARG_WITH(soft-malloc-limit,0,,) AC_MY_ARG_WITH(total-trace-length,0x1000,,) AC_MY_ARG_WITH(pcre-recursion-limit,3000,,[maximum number of recursions in PCRE package]) AC_MY_ARG_WITH(wizlist-file,WIZLIST,,[name of the wizlist file]) @@ -462,7 +463,8 @@ AC_INT_VAL_FROM_WITH(set_buffer_size_max) AC_INT_VAL_FROM_WITH(min_malloced) AC_INT_VAL_FROM_WITH(min_small_malloced) -AC_INT_VAL_FROM_WITH(max_malloced) +AC_INT_VAL_FROM_WITH(hard_malloc_limit) +AC_INT_VAL_FROM_WITH(soft_malloc_limit) AC_INT_VAL_FROM_WITH(total_trace_length) AC_INT_VAL_FROM_WITH(pcre_recursion_limit) AC_INT_VAL_FROM_WITH(max_net_connects) @@ -2820,7 +2822,8 @@ AC_SUBST(val_malloc) AC_SUBST(val_min_malloced) AC_SUBST(val_min_small_malloced) -AC_SUBST(val_max_malloced) +AC_SUBST(val_hard_malloc_limit) +AC_SUBST(val_soft_malloc_limit) AC_SUBST(val_total_trace_length) AC_SUBST(val_wizlist_file) AC_SUBST(val_pcre_recursion_limit) Index: src/config.h.in =================================================================== --- src/config.h.in (Revision 2505) +++ src/config.h.in (Arbeitskopie) @@ -137,10 +137,17 @@ /* This value gives the upper limit for the total allocated memory * (useful for systems with no functioning process limit). * A value of 0 means 'unlimited'. - * TODO: This should be named 'MAX_MALLOC' - ditto in configure. */ -#define MAX_MALLOCED @val_max_malloced@ +#define HARD_MALLOC_LIMIT_DEFAULT @val_hard_malloc_limit@ +/* This value gives a soft limit of the allocated memory (kind of low + * watermark). If this value is exceeded, the driver will call low_memory() in + * the master to inform the mudlib about the (potenntially) developing low + * memory situation. + * A value of 0 means 'unlimited'. + */ +#define SOFT_MALLOC_LIMIT_DEFAULT @val_soft_malloc_limit@ + /* --- Random Number Generator (SFMT) --- */ /* Set the period length of the SFMT. * Default is a period length of 2^19937 - 1 Index: src/backend.c =================================================================== --- src/backend.c (Revision 2505) +++ src/backend.c (Arbeitskopie) @@ -490,6 +490,8 @@ check_for_out_connections(); + check_for_soft_malloc_limit(); + if (prevent_object_cleanup) { if (num_listed_objs >= num_destructed/2) @@ -541,6 +543,11 @@ write(1, buf, strlen(buf)); command_giver = NULL; current_object = NULL; + /* if the GC was not requested by an efun call, low_memory() + * in the master is called to inform the game. */ + notify_lowmemory_condition(gc_request == gcEfun ? + NO_MALLOC_LIMIT_EXCEEDED : + HARD_MALLOC_LIMIT_EXCEEDED); garbage_collection(); } else Index: src/string_spec =================================================================== --- src/string_spec (Revision 2505) +++ src/string_spec (Arbeitskopie) @@ -147,6 +147,7 @@ INHERIT_FILE "inherit_file" LOG_ERROR "log_error" LOGON "logon" +LOW_MEMORY "low_memory" PRELOAD "preload" PREP_DEST "prepare_destruct" PRINTF_OBJ_NAME "printf_obj_name" Index: mudlib/sys/rtlimits.h =================================================================== --- mudlib/sys/rtlimits.h (Revision 2505) +++ mudlib/sys/rtlimits.h (Arbeitskopie) @@ -21,4 +21,18 @@ #define LIMIT_KEEP (-1) /* Keep the old limit setting */ #define LIMIT_DEFAULT (-2) /* Use the default setting */ +/* memory limits */ +#define MALLOC_SOFT_LIMIT 1 +#define MALLOC_HARD_LIMIT 2 + +/* low memory conditions */ +#define NO_MALLOC_LIMIT_EXCEEDED 0 +#define SOFT_MALLOC_LIMIT_EXCEEDED MALLOC_SOFT_LIMIT +#define HARD_MALLOC_LIMIT_EXCEEDED MALLOC_HARD_LIMIT + +/* Flags for available reserves */ +#define USER_RESERVE_AVAILABLE 1 +#define MASTER_RESERVE_AVAILABLE 2 +#define SYSTEM_RESERVE_AVAILABLE 4 + #endif /* LPC_RTLIMITS_H_ */