xemacs-beta: src/ralloc.c comparison

comparison src/ralloc.c @ 440:8de8e3f6228a r21-2-28

Import from CVS: tag r21-2-28

author	cvs
date	Mon, 13 Aug 2007 11:33:38 +0200
parents	3ecd8885ac67
children	abe6d1db359e

comparison

equal deleted inserted replaced

-:357dd071b03c
+:8de8e3f6228a
 #endif /* 0 */
 /* Unconditionally use unsigned char * for this.  */
 typedef unsigned char *POINTER;
-typedef unsigned long SIZE;
 #ifdef DOUG_LEA_MALLOC
 #define M_TOP_PAD -2
 #include <malloc.h>
 #endif
 #else	/* Not emacs.  */
 #include <stddef.h>
-typedef size_t SIZE;
 typedef void *POINTER;
 #include <unistd.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)
 #if !defined(HAVE_MMAP) || defined(DOUG_LEA_MALLOC)
 {
 struct bp *next;
 struct bp *prev;
 POINTER *variable;
 POINTER data;
-SIZE size;
+size_t size;
 POINTER new_data;		/* temporarily used for relocation */
 struct heap *heap; 		/* Heap this bloc is in.  */
 } *bloc_ptr;
 #define NIL_BLOC ((bloc_ptr) 0)
 Return the address of the space if all went well, or zero if we couldn't
 allocate the memory.  */
 static POINTER
-obtain (POINTER address, SIZE size)
+obtain (POINTER address, size_t size)
 {
 heap_ptr heap;
-SIZE already_available;
+size_t already_available;
 /* Find the heap that ADDRESS falls within.  */
 for (heap = last_heap; heap; heap = heap->prev)
 {
 if (heap->start <= address && address <= heap->end)
 /* If we can't fit them within any existing heap,
 get more space.  */
 if (heap == NIL_HEAP)
 {
 POINTER new = (*real_morecore)(0);
-SIZE get;
+size_t get;
 already_available = (char *)last_heap->end - (char *)address;
 if (new != last_heap->end)
 	{
 #if 0
 /* Obtain SIZE bytes of space and return a pointer to the new area.
 If we could not allocate the space, return zero.  */
 static POINTER
-get_more_space (SIZE size)
+get_more_space (size_t size)
 {
 POINTER ptr = break_value;
 if (obtain (size))
 return ptr;
 else
 /* 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 ()
+r_alloc_size_in_use (void)
 {
 return break_value - virtual_break_value;
 }
 /* The meat - allocating, freeing, and relocating blocs.  */
 /* Allocate a bloc of SIZE bytes and append it to the chain of blocs.
 Returns a pointer to the new bloc, or zero if we couldn't allocate
 memory for the new block.  */
 static bloc_ptr
-get_bloc (SIZE size)
+get_bloc (size_t size)
 {
 register bloc_ptr new_bloc;
 register heap_ptr heap;
 if (! (new_bloc = (bloc_ptr) malloc (BLOC_PTR_SIZE))
 /* If BLOC won't fit in any heap,
 	 get enough new space to hold BLOC and all following blocs.  */
 if (heap == NIL_HEAP)
 	{
 	  register bloc_ptr tb = b;
-	  register SIZE s = 0;
+	  register size_t s = 0;
 	  /* Add up the size of all the following blocs.  */
 	  while (tb != NIL_BLOC)
 	    {
 	      if (tb->variable)
 /* Resize BLOC to SIZE bytes.  This relocates the blocs
 that come after BLOC in memory.  */
 static int
-resize_bloc (bloc_ptr bloc, SIZE size)
+resize_bloc (bloc_ptr bloc, size_t size)
 {
 register bloc_ptr b;
 heap_ptr heap;
 POINTER address;
-SIZE old_size;
+size_t old_size;
 /* No need to ever call this if arena is frozen, bug somewhere!  */
 if (r_alloc_freeze_level)
 abort();
 	      b->size = 0;
 	      b->data = b->new_data;
 }
 	  else
 	    {
-	      safe_bcopy (b->data, b->new_data, b->size);
+	      memmove (b->new_data, b->data, b->size);
 	      *b->variable = b->data = b->new_data;
 }
 	}
 if (!bloc->variable)
 	{
 	  bloc->size = 0;
 	  bloc->data = bloc->new_data;
 	}
 else
 	{
-	  safe_bcopy (bloc->data, bloc->new_data, old_size);
+	  memmove (bloc->new_data, bloc->data, old_size);
 	  memset (bloc->new_data + old_size, 0, size - old_size);
 	  *bloc->variable = bloc->data = bloc->new_data;
 	}
 }
 else
 	      b->size = 0;
 	      b->data = b->new_data;
 }
 	  else
 	    {
-	      safe_bcopy (b->data, b->new_data, b->size);
+	      memmove (b->new_data, b->data, b->size);
 	      *b->variable = b->data = b->new_data;
 	    }
 	}
 }
 /* Allocate a page-aligned space.  GNU malloc would reclaim an
 	 extra space if we passed an unaligned one.  But we could
 	 not always find a space which is contiguous to the previous.  */
 POINTER new_bloc_start;
 heap_ptr h = first_heap;
-SIZE get = ROUNDUP (size);
+size_t get = ROUNDUP (size);
 address = (POINTER) ROUNDUP (virtual_break_value);
 /* Search the list upward for a heap which is large enough.  */
 while ((char *) h->end < (char *) MEM_ROUNDUP ((char *)address + get))
 	  /* Note that (POINTER)(h+1) <= new_bloc_start since
 	     get >= page_size, so the following does not destroy the heap
 	     header.  */
 	  for (b = last_bloc; b != NIL_BLOC; b = b->prev)
 	    {
-	      safe_bcopy (b->data, b->new_data, b->size);
+	      memmove (b->new_data, b->data, b->size);
 	      *b->variable = b->data = b->new_data;
 	    }
 	  h->bloc_start = new_bloc_start;
 memset (address, 0, size);
 }
 else /* size < 0 */
 {
-SIZE excess = (char *)first_heap->bloc_start
+size_t excess = (char *)first_heap->bloc_start
 		      - ((char *)virtual_break_value + size);
 address = virtual_break_value;
 if (r_alloc_freeze_level == 0 && excess > 2 * extra_bytes)
 	  relocate_blocs (first_bloc, first_heap, first_heap->bloc_start);
 	  for (b = first_bloc; b != NIL_BLOC; b = b->next)
 	    {
-	      safe_bcopy (b->data, b->new_data, b->size);
+	      memmove (b->new_data, b->data, b->size);
 	      *b->variable = b->data = b->new_data;
 	    }
 	}
 if ((char *)virtual_break_value + size < (char *)first_heap->start)
 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_t size);
 POINTER
-r_alloc (POINTER *ptr, SIZE size)
+r_alloc (POINTER *ptr, size_t size)
 {
 bloc_ptr new_bloc;
 if (! r_alloc_initialized)
 init_ralloc ();
 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_t size);
 POINTER
-r_re_alloc (POINTER *ptr, SIZE size)
+r_re_alloc (POINTER *ptr, size_t size)
 {
 register bloc_ptr bloc;
 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
+and memmove 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)
 for (b = first_bloc; b; b = b->next)
 {
 assert (b->prev == pb);
 assert ((POINTER) MEM_ROUNDUP (b->data) == b->data);
-assert ((SIZE) MEM_ROUNDUP (b->size) == b->size);
+assert ((size_t) MEM_ROUNDUP (b->size) == b->size);
 ph = 0;
 for (h = first_heap; h; h = h->next)
 	{
 	  if (h->bloc_start <= b->data && b->data + b->size <= h->end)
 /* Initialization procedure for address picking scheme */
 static void Addr_Block_initialize(void);
 /* Get a suitable VM_ADDR via mmap */
-static VM_ADDR New_Addr_Block( SIZE sz );
+static VM_ADDR New_Addr_Block (size_t sz);
 /* Free a VM_ADDR allocated via New_Addr_Block */
-static void Free_Addr_Block( VM_ADDR addr, SIZE sz );
+static void Free_Addr_Block (VM_ADDR addr, size_t sz);
 #ifdef MMAP_GENERATE_ADDRESSES
 /* Implementation of the three calls for address picking when XEmacs is incharge */
 /* The enum denotes the status of the following block. */
 typedef enum { empty = 0, occupied, unavailable } addr_status;
 typedef struct addr_chain
 {
 POINTER addr;
-SIZE sz;
+size_t sz;
 addr_status flag;
 struct addr_chain *next;
 } ADDRESS_BLOCK, *ADDRESS_CHAIN;
 /* NB: empty and unavailable blocks are concatenated. */
 /* Start off the address block chain with a humongous address block
 which is empty to start with.  Note that addr_chain is invariant
 WRT the addition/deletion of address blocks because of the assert
 in Coalesce() and the strict ordering of blocks by their address
 */
-static void Addr_Block_initialize()
+static void
+Addr_Block_initialize (void)
 {
 MEMMETER( MVAL( M_Addrlist_Size )++)
 addr_chain = (ADDRESS_CHAIN) UNDERLYING_MALLOC( sizeof( ADDRESS_BLOCK ));
 addr_chain->next = 0;		/* Last block in chain */
 addr_chain->sz = 0x0c000000;	/* Size */
 addr_chain->flag = empty;
 }
 /* Coalesce address blocks if they are contiguous.  Only empty and
 unavailable slots are coalesced. */
-static void Coalesce_Addr_Blocks()
+static void
+Coalesce_Addr_Blocks (void)
 {
 ADDRESS_CHAIN p;
 for (p = addr_chain; p; p = p->next)
 {
 while (p->next && p->flag == p->next->flag)
 	}
 } /* for all p */
 }
 /* Get an empty address block of specified size. */
-static VM_ADDR New_Addr_Block( SIZE sz )
+static VM_ADDR
+New_Addr_Block (size_t sz)
 {
 ADDRESS_CHAIN p = addr_chain;
 VM_ADDR new_addr = VM_FAILURE_ADDR;
 for (; p; p = p->next)
 {
 return new_addr;
 }
 /* Free an address block.  We mark the block as being empty, and attempt to
 do any coalescing that may have resulted from this. */
-static void Free_Addr_Block( VM_ADDR addr, SIZE sz )
+static void
+Free_Addr_Block (VM_ADDR addr, size_t sz)
 {
 ADDRESS_CHAIN p = addr_chain;
 for (; p; p = p->next )
 {
 if (p->addr == addr)
 }
 #else /* !MMAP_GENERATE_ADDRESSES */
 /* This is an alternate (simpler) implementation in cases where the
 address is picked by the kernel. */
-static void Addr_Block_initialize(void)
+static void
+Addr_Block_initialize (void)
 {
 /* Nothing. */
 }
-static VM_ADDR New_Addr_Block( SIZE sz )
+static VM_ADDR
+New_Addr_Block (size_t sz)
 {
 return mmap (0, sz, PROT_READ|PROT_WRITE, MAP_FLAGS,
 	       DEV_ZERO_FD, 0 );
 }
-static void Free_Addr_Block( VM_ADDR addr, SIZE sz )
+static void
+Free_Addr_Block (VM_ADDR addr, size_t sz)
 {
 munmap ((caddr_t) addr, sz );
 }
 #endif /* MMAP_GENERATE_ADDRESSES */
 /* IMPLEMENTATION OF EXPORTED RELOCATOR INTERFACE */
 /*
-r_alloc( POINTER, SIZE ): Allocate a relocatable area with the start
+r_alloc (POINTER, SIZE): Allocate a relocatable area with the start
 address aliased to the first parameter.
 */
-POINTER r_alloc (POINTER *ptr, SIZE size);
+POINTER r_alloc (POINTER *ptr, size_t size);
 POINTER
-r_alloc (POINTER *ptr, SIZE size)
+r_alloc (POINTER *ptr, size_t size)
 {
 MMAP_HANDLE mh;
 switch(r_alloc_initialized)
 {
 break;
 default:
 mh = new_mmap_handle( size );
 if (mh)
 	{
-	  SIZE hysteresis = (mmap_hysteresis > 0 ?  mmap_hysteresis  : 0);
+	  size_t hysteresis = (mmap_hysteresis > 0 ?  mmap_hysteresis  : 0);
-	  SIZE  mmapped_size = ROUNDUP( size + hysteresis );
+	  size_t mmapped_size = ROUNDUP( size + hysteresis );
 	  MEMMETER( MVAL(M_Map)++ )
 	  MEMMETER( MVAL(M_Pages_Map) += (mmapped_size/page_size) )
 	  MEMMETER( MVAL(M_Wastage) += mmapped_size - size )
 MEMMETER( MVAL(M_Live_Pages) += (mmapped_size/page_size) )
 	  mh->vm_addr = New_Addr_Block( mmapped_size );
 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 sz);
+POINTER r_re_alloc (POINTER *ptr, size_t sz);
 POINTER
-r_re_alloc (POINTER *ptr, SIZE sz)
+r_re_alloc (POINTER *ptr, size_t sz)
 {
 if (r_alloc_initialized == 0)
 {
 abort ();
 return 0; /* suppress compiler warning */
 	*ptr = tmp;
 return tmp;
 }
 else
 {
-SIZE hysteresis = (mmap_hysteresis > 0 ?  mmap_hysteresis : 0);
+size_t hysteresis = (mmap_hysteresis > 0 ?  mmap_hysteresis : 0);
-SIZE actual_sz = ROUNDUP( sz + hysteresis );
+size_t actual_sz = ROUNDUP( sz + hysteresis );
 MMAP_HANDLE h = find_mmap_handle( ptr );
 VM_ADDR new_vm_addr;
 if ( h == 0 )		/* Was allocated using malloc. */
 	{

Mercurial > hg > xemacs-beta

comparison src/ralloc.c @ 440:8de8e3f6228a r21-2-28