xemacs-beta: src/ralloc.c comparison

comparison src/ralloc.c @ 272:c5d627a313b1 r21-0b34

Import from CVS: tag r21-0b34

author	cvs
date	Mon, 13 Aug 2007 10:28:48 +0200
parents	084402c475ba
children	ca9a9ec9c1c1

comparison

equal deleted inserted replaced

-:c7b7086b0a39
+:c5d627a313b1
 Only relocate the blocs necessary for SIZE in r_alloc_sbrk,
 rather than all of them.  This means allowing for a possible
 hole between the first bloc and the end of malloc storage. */
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>  /* for getpagesize() */
+#endif
 #ifdef emacs
-#include <config.h>
+#include "lisp.h"
-#include "lisp.h"		/* Needed for VALBITS.  */
+#include <malloc.h>
-#undef NULL
 /* The important properties of this type are that 1) it's a pointer, and
 2) arithmetic on it should work as if the size of the object pointed
 to has a size of 1.  */
 #if 0 /* Arithmetic on void* is a GCC extension.  */
 typedef unsigned char *POINTER;
 typedef unsigned long SIZE;
 #ifdef DOUG_LEA_MALLOC
-#define M_TOP_PAD           -2
+#define M_TOP_PAD -2
-extern int mallopt ();
 #endif
 #include "getpagesize.h"
 #include <string.h>
+void refill_memory_reserve (void);
 #else	/* Not emacs.  */
 #include <stddef.h>
 #include <malloc.h>
 #include <string.h>
 #endif	/* emacs.  */
+void init_ralloc (void);
 #define safe_bcopy(x, y, z) memmove (y, x, z)
 #define NIL ((POINTER) 0)
 /* Declarations for working with the malloc, ralloc, and system breaks.  */
 /* Function to set the real break value. */
-static POINTER (*real_morecore) ();
+static POINTER (*real_morecore) (long size);
 /* The break value, as seen by malloc (). */
 static POINTER virtual_break_value;
 /* The break value, viewed by the relocatable blocs. */
 static POINTER break_value;
-/* The REAL (i.e., page aligned) break value of the process. */
-static POINTER page_break_value;
 /* This is the size of a page.  We round memory requests to this boundary.  */
 static int page_size;
 /* Whenever we get memory from the system, get this many extra bytes.  This
 but they never move.
 We try to make just one heap and make it larger as necessary.
 But sometimes we can't do that, because we can't get contiguous
 space to add onto the heap.  When that happens, we start a new heap.  */
 typedef struct heap
 {
 struct heap *next;
 struct heap *prev;
 /* Start of memory range of this heap.  */
 /* Functions to get and return memory from the system.  */
 /* Find the heap that ADDRESS falls within.  */
 static heap_ptr
-find_heap (address)
+find_heap (POINTER address)
-POINTER address;
 {
 heap_ptr heap;
 for (heap = last_heap; heap; heap = heap->prev)
 {
 }
 /* Return the total size in use by relocating allocator,
 above where malloc gets space.  */
+long r_alloc_size_in_use (void);
 long
 r_alloc_size_in_use ()
 {
 return break_value - virtual_break_value;
 }
 }
 /* Calculate new locations of blocs in the list beginning with BLOC,
 relocating it to start at ADDRESS, in heap HEAP.  If enough space is
 not presently available in our reserve, call obtain for
 more space.
 Store the new location of each bloc in its new_data field.
 Do not touch the contents of blocs or break_value.  */
 static int
-relocate_blocs (bloc, heap, address)
+relocate_blocs (bloc_ptr bloc, heap_ptr heap, POINTER address)
-bloc_ptr bloc;
-heap_ptr heap;
-POINTER address;
 {
 register bloc_ptr b = bloc;
 /* No need to ever call this if arena is frozen, bug somewhere!  */
 if (r_alloc_freeze_level)
 abort();
 while (b)
 {
 /* If bloc B won't fit within HEAP,
 	  register SIZE s = 0;
 	  /* Add up the size of all the following blocs.  */
 	  while (tb != NIL_BLOC)
 	    {
 	      if (tb->variable)
 		s += tb->size;
 	      tb = tb->next;
 	    }
 	}
 /* Record the new address of this bloc
 	 and update where the next bloc can start.  */
 b->new_data = address;
 if (b->variable)
 	address += b->size;
 b = b->next;
 }
 return 1;
 }
+#if 0 /* unused */
 /* Reorder the bloc BLOC to go before bloc BEFORE in the doubly linked list.
 This is necessary if we put the memory of space of BLOC
 before that of BEFORE.  */
 static void
-reorder_bloc (bloc, before)
+reorder_bloc (bloc_ptr bloc, bloc_ptr before)
-bloc_ptr bloc, before;
 {
 bloc_ptr prev, next;
 /* Splice BLOC out from where it is.  */
 prev = bloc->prev;
 bloc->prev = prev;
 before->prev = bloc;
 bloc->next = before;
 }
+#endif /* unused */
 /* Update the records of which heaps contain which blocs, starting
 with heap HEAP and bloc BLOC.  */
 static void
-update_heap_bloc_correspondence (bloc, heap)
+update_heap_bloc_correspondence (bloc_ptr bloc, heap_ptr heap)
-bloc_ptr bloc;
-heap_ptr heap;
 {
 register bloc_ptr b;
 /* Initialize HEAP's status to reflect blocs before BLOC.  */
 if (bloc != NIL_BLOC && bloc->prev != NIL_BLOC && bloc->prev->heap == heap)
 /* Resize BLOC to SIZE bytes.  This relocates the blocs
 that come after BLOC in memory.  */
 static int
-resize_bloc (bloc, size)
+resize_bloc (bloc_ptr bloc, SIZE size)
-bloc_ptr bloc;
-SIZE size;
 {
 register bloc_ptr b;
 heap_ptr heap;
 POINTER address;
 SIZE old_size;
 /* No need to ever call this if arena is frozen, bug somewhere!  */
 if (r_alloc_freeze_level)
 abort();
 if (bloc == NIL_BLOC || size == bloc->size)
 return 1;
 	{
 	  if (!b->variable)
 	    {
 	      b->size = 0;
 	      b->data = b->new_data;
 }
 	  else
 	    {
 	      safe_bcopy (b->data, b->new_data, b->size);
 	      *b->variable = b->data = b->new_data;
 }
 	}
 	{
 	  if (!b->variable)
 	    {
 	      b->size = 0;
 	      b->data = b->new_data;
 }
 	  else
 	    {
 	      safe_bcopy (b->data, b->new_data, b->size);
 	      *b->variable = b->data = b->new_data;
 	    }
 	}
 if (r_alloc_freeze_level)
 {
 bloc->variable = (POINTER *) NIL;
 return;
 }
 resize_bloc (bloc, 0);
 if (bloc == first_bloc && bloc == last_bloc)
 {
 first_bloc = last_bloc = NIL_BLOC;
 If we're out of memory, we should return zero, to imitate the other
 __morecore hook values - in particular, __default_morecore in the
 GNU malloc package.  */
+POINTER r_alloc_sbrk (long size);
 POINTER
 r_alloc_sbrk (long size)
 {
 register bloc_ptr b;
 POINTER address;
 new_bloc_start = (POINTER) MEM_ROUNDUP ((char *)address + get);
 if (first_heap->bloc_start < new_bloc_start)
 	{
 	  /* This is no clean solution - no idea how to do it better.  */
 	  if (r_alloc_freeze_level)
 	    return NIL;
 	  /* There is a bug here: if the above obtain call succeeded, but the
 	     relocate_blocs call below does not succeed, we need to free
 	     the memory that we got with obtain.  */
 before allocating a new area.  Not yet done.
 If we can't allocate the necessary memory, set *PTR to zero, and
 return zero.  */
+POINTER r_alloc (POINTER *ptr, SIZE size);
 POINTER
 r_alloc (POINTER *ptr, SIZE size)
 {
 bloc_ptr new_bloc;
 }
 /* Free a bloc of relocatable storage whose data is pointed to by PTR.
 Store 0 in *PTR to show there's no block allocated.  */
+void r_alloc_free (POINTER *ptr);
 void
 r_alloc_free (POINTER *ptr)
 {
 register bloc_ptr dead_bloc;
 Change *PTR to reflect the new bloc, and return this value.
 If more memory cannot be allocated, then leave *PTR unchanged, and
 return zero.  */
+POINTER r_re_alloc (POINTER *ptr, SIZE size);
 POINTER
 r_re_alloc (POINTER *ptr, SIZE size)
 {
 register bloc_ptr bloc;
 if (! r_alloc_initialized)
 init_ralloc ();
 if (!*ptr)
 return r_alloc (ptr, size);
 if (!size)
 {
 r_alloc_free (ptr);
 return r_alloc (ptr, 0);
 }
 bloc = find_bloc (ptr);
 if (bloc == NIL_BLOC)
 abort ();
 if (size < bloc->size)
 {
 /* Wouldn't it be useful to actually resize the bloc here?  */
 /* I think so too, but not if it's too expensive...  */
 if ((bloc->size - MEM_ROUNDUP (size) >= page_size)
 && r_alloc_freeze_level == 0)
 	{
 	  resize_bloc (bloc, MEM_ROUNDUP (size));
 	  /* Never mind if this fails, just do nothing...  */
 	  /* It *should* be infallible!  */
 	}
 	      bloc->variable = (POINTER *) NIL;
 	    }
 else
 	    return NIL;
 	}
 else
 	{
 	  if (! resize_bloc (bloc, MEM_ROUNDUP (size)))
 	    return NIL;
 }
 }
 /* Disable relocations, after making room for at least SIZE bytes
 of non-relocatable heap if possible.  The relocatable blocs are
 guaranteed to hold still until thawed, even if this means that
 malloc must return a null pointer.  */
+void r_alloc_freeze (long size);
 void
-r_alloc_freeze (size)
+r_alloc_freeze (long size)
-long size;
 {
 if (! r_alloc_initialized)
 init_ralloc ();
 /* If already frozen, we can't make any more room, so don't try.  */
 ++r_alloc_freeze_level;
 if (size > 0)
 r_alloc_sbrk (-size);
 }
+void r_alloc_thaw (void);
 void
 r_alloc_thaw ()
 {
 if (! r_alloc_initialized)
 init_ralloc ();
 if (--r_alloc_freeze_level < 0)
 abort ();
 /* This frees all unused blocs.  It is not too inefficient, as the resize
 and bcopy is done only once.  Afterwards, all unreferenced blocs are
 already shrunk to zero size.  */
 if (!r_alloc_freeze_level)
 {
 bloc_ptr *b = &first_bloc;
 while (*b)
 	if (!(*b)->variable)
 	  free_bloc (*b);
 	else
 	  b = &(*b)->next;
 }
 }
 /* The hook `malloc' uses for the function which gets more space
 from the system.  */
-extern POINTER (*__morecore) ();
+/* extern POINTER (*__morecore) (long size); */
 /* Initialize various things for memory allocation. */
+#define SET_FUN_PTR(fun_ptr, fun_val) \
+(*((void **) (&fun_ptr)) = ((void *) (fun_val)))
 void
 init_ralloc (void)
 {
 if (r_alloc_initialized)
 return;
 r_alloc_initialized = 1;
-real_morecore = __morecore;
+SET_FUN_PTR (real_morecore, __morecore);
-__morecore = r_alloc_sbrk;
+SET_FUN_PTR (__morecore, r_alloc_sbrk);
 first_heap = last_heap = &heap_base;
 first_heap->next = first_heap->prev = NIL_HEAP;
 first_heap->start = first_heap->bloc_start
 = virtual_break_value = break_value = (*real_morecore) (0);
 #if defined (emacs) && defined (DOUG_LEA_MALLOC)
 /* Reinitialize the morecore hook variables after restarting a dumped
 Emacs.  This is needed when using Doug Lea's malloc from GNU libc.  */
+void r_alloc_reinit (void);
 void
 r_alloc_reinit ()
 {
 /* Only do this if the hook has been reset, so that we don't get an
 infinite loop, in case Emacs was linked statically.  */
-if (__morecore != r_alloc_sbrk)
+if ( ((void*) __morecore) !=  (void *) (r_alloc_sbrk))
 {
-real_morecore = __morecore;
+SET_FUN_PTR (real_morecore, __morecore);
-__morecore = r_alloc_sbrk;
+SET_FUN_PTR (__morecore, r_alloc_sbrk);
 }
 }
 #if 0
 #ifdef DEBUG
 /* We settle for a standard doubly-linked-list.  The dynarr type isn't
 very amenable to deletion of items in the middle, so we conjure up
 yet another stupid datastructure.  The structure is maintained as a
-ring, and the singleton ring has the sole element as it's left and
+ring, and the singleton ring has the sole element as its left and
 right neighbours. */
 static void init_MHASH_table (void); /* Forward reference */
 typedef struct alloc_dll
 /* Simple hash check. */
 struct {
 int n_hits;			/* How many addresses map to this? */
 MMAP_HANDLE handle;		/* What is the current handle? */
-VM_ADDR addr;			/* What is it's VM address? */
+VM_ADDR addr;			/* What is its VM address? */
 } MHASH_HITS[ MHASH_PRIME ];
 static void
 init_MHASH_table (void)
 {
 int hval = addr_shift % MHASH_PRIME; /* We could have addresses which are -ve
 					  when converted to signed ints */
 return ((hval >= 0) ? hval : MHASH_PRIME + hval);
 }
-/* Add a VM address with it's corresponding handle to the table. */
+/* Add a VM address with its corresponding handle to the table. */
 static void
 MHASH_ADD (VM_ADDR addr, MMAP_HANDLE h)
 {
 int kVal = MHASH( addr );
 if (MHASH_HITS[kVal].n_hits++ == 0)
 /* Metering malloc performance. */
 #ifdef MMAP_METERING
 /* If we're metering, we introduce some extra symbols to aid the noble
 cause of bloating XEmacs core size. */
-Lisp_Object Qmm_times_mapped;
+static Lisp_Object Qmmap_times_mapped;
-Lisp_Object Qmm_pages_mapped;
+static Lisp_Object Qmmap_pages_mapped;
-Lisp_Object Qmm_times_unmapped;
+static Lisp_Object Qmmap_times_unmapped;
-Lisp_Object Qmm_times_remapped;
+static Lisp_Object Qmmap_times_remapped;
-Lisp_Object Qmm_didnt_copy;
+static Lisp_Object Qmmap_didnt_copy;
-Lisp_Object Qmm_pages_copied;
+static Lisp_Object Qmmap_pages_copied;
-Lisp_Object Qmm_average_bumpval;
+static Lisp_Object Qmmap_average_bumpval;
-Lisp_Object Qmm_wastage;
+static Lisp_Object Qmmap_wastage;
-Lisp_Object Qmm_live_pages;
+static Lisp_Object Qmmap_live_pages;
-Lisp_Object Qmm_addr_looked_up;
+static Lisp_Object Qmmap_addr_looked_up;
-Lisp_Object Qmm_hash_worked;
+static Lisp_Object Qmmap_hash_worked;
-Lisp_Object Qmm_addrlist_size;
+static Lisp_Object Qmmap_addrlist_size;
 #define M_Map 0			/* How many times allocated? */
 #define M_Pages_Map 1		/* How many pages allocated? */
 #define M_Unmap 2		/* How many times freed? */
 #define M_Remap 3		/* How many times increased in size? */
 static int meter[N_Meterables];
 DEFUN ("mmap-allocator-status", Fmmap_allocator_status, 0, 0, 0, /*
 Return some information about mmap-based allocator.
-mmap-addrlist-size: number of entries in address picking list.
+mmap-times-mapped:    number of times r_alloc was called.
-mmap-times-mapped: number of times r_alloc was called.
+mmap-pages-mapped:    number of pages mapped by r_alloc calls only.
-mmap-pages-mapped: number of pages mapped by r_alloc calls only.
+mmap-times-unmapped:  number of times r_free was called.
-mmap-times-unmapped: number of times r_free was called.
+mmap-times-remapped:  number of times r_re_alloc was called.
-mmap-times-remapped: number of times r_re_alloc was called.
+mmap-didnt-copy:      number of times re-alloc did NOT have to move the block.
-mmap-didnt-copy: number of times  re-alloc didn\'t have to move the block.
+mmap-pages-copied:    total number of pages copied.
-mmap-pages-copied: total number of pages copied.
+mmap-average-bumpval: average increase in size demanded to re-alloc.
-mmap-average-bumpval: average increase in size demanded to re-alloc.
+mmap-wastage:         total number of bytes allocated, but not currently in use.
-mmap-wastage: total number of bytes allocated, but not currently in use.
+mmap-live-pages:      total number of pages live.
-mmap-live-pages: total number of pages live.
+mmap-addr-looked-up:  total number of times needed to check if addr is in block.
+mmap-hash-worked:     total number of times the simple hash check worked.
+mmap-addrlist-size:   number of entries in address picking list.
 */
 ())
 {
-Lisp_Object result;
+Lisp_Object result = Qnil;
-result = Fcons (Fcons (Qmm_addrlist_size, MLVAL (M_Addrlist_Size)), Qnil);
+result = cons3 (Qmmap_addrlist_size,	MLVAL (M_Addrlist_Size),   result);
-result = Fcons (Fcons (Qmm_hash_worked, MLVAL (M_Hash_Worked)), result);
+result = cons3 (Qmmap_hash_worked,	MLVAL (M_Hash_Worked),	   result);
-result = Fcons (Fcons (Qmm_addr_looked_up, MLVAL (M_Address_Lookup)), result);
+result = cons3 (Qmmap_addr_looked_up,	MLVAL (M_Address_Lookup),  result);
-result = Fcons (Fcons (Qmm_live_pages, MLVAL (M_Live_Pages)), result);
+result = cons3 (Qmmap_live_pages,	MLVAL (M_Live_Pages),	   result);
-result = Fcons (Fcons (Qmm_wastage, MLVAL (M_Wastage)), result);
+result = cons3 (Qmmap_wastage,	MLVAL (M_Wastage),	   result);
-result = Fcons (Fcons (Qmm_average_bumpval, MLVAL (M_Average_Bumpval)),
+result = cons3 (Qmmap_average_bumpval,MLVAL (M_Average_Bumpval), result);
-		  result);
+result = cons3 (Qmmap_pages_copied,	MLVAL (M_Copy_Pages),	   result);
-result = Fcons (Fcons (Qmm_pages_copied, MLVAL (M_Copy_Pages)), result);
+result = cons3 (Qmmap_didnt_copy,	MLVAL (M_Didnt_Copy),	   result);
-result = Fcons (Fcons (Qmm_didnt_copy, MLVAL (M_Didnt_Copy)), result);
+result = cons3 (Qmmap_times_remapped,	MLVAL (M_Remap),	   result);
-result = Fcons (Fcons (Qmm_times_remapped, MLVAL (M_Remap)), result);
+result = cons3 (Qmmap_times_unmapped,	MLVAL (M_Unmap),	   result);
-result = Fcons (Fcons (Qmm_times_unmapped, MLVAL (M_Unmap)), result);
+result = cons3 (Qmmap_pages_mapped,	MLVAL (M_Pages_Map),	   result);
-result = Fcons (Fcons (Qmm_pages_mapped, MLVAL (M_Pages_Map)), result);
+result = cons3 (Qmmap_times_mapped,	MLVAL (M_Map),		   result);
-result = Fcons (Fcons (Qmm_times_mapped, MLVAL (M_Map)), result);
 return result;
 }
 #else /* !MMAP_METERING */
 marked unavailable and not attempted thereafter.  The scheme will
 keep fragmenting the large empty block until it finds an address
 which can be successfully mmapped, or until there are no free
 blocks of the given size left.
-Note that this scheme, given it's first-fit strategy, is prone to
+Note that this scheme, given its first-fit strategy, is prone to
 fragmentation of the first part of memory earmarked for this
 purpose. [ACP Vol I].  We can't use the workaround of using a
 randomized first fit because we don't want to presume too much
 about the memory map.  Instead, we try to coalesce empty or
 unavailable blocks at any available opportunity.  */
 void
 syms_of_ralloc (void)
 {
 #ifdef MMAP_METERING
-defsymbol (&Qmm_times_mapped, "mmap-times-mapped");
+defsymbol (&Qmmap_times_mapped, "mmap-times-mapped");
-defsymbol (&Qmm_pages_mapped, "mmap-pages-mapped");
+defsymbol (&Qmmap_pages_mapped, "mmap-pages-mapped");
-defsymbol (&Qmm_times_unmapped, "mmap-times-unmapped");
+defsymbol (&Qmmap_times_unmapped, "mmap-times-unmapped");
-defsymbol (&Qmm_times_remapped, "mmap-times-remapped");
+defsymbol (&Qmmap_times_remapped, "mmap-times-remapped");
-defsymbol (&Qmm_didnt_copy, "mmap-didnt-copy");
+defsymbol (&Qmmap_didnt_copy, "mmap-didnt-copy");
-defsymbol (&Qmm_pages_copied, "mmap-pages-copied");
+defsymbol (&Qmmap_pages_copied, "mmap-pages-copied");
-defsymbol (&Qmm_average_bumpval, "mmap-average-bumpval");
+defsymbol (&Qmmap_average_bumpval, "mmap-average-bumpval");
-defsymbol (&Qmm_wastage, "mmap-wastage");
+defsymbol (&Qmmap_wastage, "mmap-wastage");
-defsymbol (&Qmm_live_pages, "mmap-live-pages");
+defsymbol (&Qmmap_live_pages, "mmap-live-pages");
-defsymbol (&Qmm_addr_looked_up, "mmap-had-to-look-up-address");
+defsymbol (&Qmmap_addr_looked_up, "mmap-addr-looked-up");
-defsymbol (&Qmm_hash_worked, "mmap-hash-table-worked");
+defsymbol (&Qmmap_hash_worked, "mmap-hash-worked");
-defsymbol (&Qmm_addrlist_size, "mmap-addrlist-size");
+defsymbol (&Qmmap_addrlist_size, "mmap-addrlist-size");
 DEFSUBR (Fmmap_allocator_status);
 #endif /* MMAP_METERING */
 }
 void

Mercurial > hg > xemacs-beta

comparison src/ralloc.c @ 272:c5d627a313b1 r21-0b34