xemacs-beta: src/ralloc.c comparison

comparison src/ralloc.c @ 185:3d6bfa290dbd r20-3b19

Import from CVS: tag r20-3b19

author	cvs
date	Mon, 13 Aug 2007 09:55:28 +0200
parents	0132846995bd
children	084402c475ba

comparison

equal deleted inserted replaced

-:bcd2674570bf
+:3d6bfa290dbd
 /* Block-relocating memory allocator.
 Copyright (C) 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
 This file is part of XEmacs.
 XEmacs is free software; you can redistribute it and/or modify it
 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
 must be a multiple of page_size.  */
 static int extra_bytes;
 /* Macros for rounding.  Note that rounding to any value is possible
 by changing the definition of PAGE. */
 int excess;
 break_value -= size;
 new_page_break = (POINTER) ROUNDUP (break_value);
 excess = (char *) page_break_value - (char *) new_page_break;
 if (excess > extra_bytes * 2)
 {
 /* Keep extra_bytes worth of empty space.
 	 And don't free anything unless we can free at least extra_bytes.  */
 if ((*real_morecore) (extra_bytes - excess) == 0)
 if (bloc != NIL_BLOC)
 {
 SIZE offset = address - bloc->data;
 SIZE data_size = 0;
 bloc_ptr b;
 for (b = bloc; b != NIL_BLOC; b = b->next)
 	{
 	  data_size += b->size;
 	  b->data += offset;
 	  *b->variable = b->data;
 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)
 {
 /* This is the first address not currently available for the heap.  */
 POINTER top;
 /* Amount of empty space below that.  */
 virtual_break_value = break_value = page_break_value;
 use_relocatable_buffers = 1;
 }
 #else /* HAVE_MMAP */
 /*
 A relocating allocator built using the mmap(2) facility available
 in some OSes.  Based on another version written by Paul Flinders,
 from which code (and comments) are snarfed.
 The OS should support mmap() with MAP_ANONYMOUS attribute, or have
 Paul Flinders wrote a version which works well for systems that
 allow callers to specify (virtual) addresses to mmap().
 Unfortunately, such a scheme doesn't work for certain systems like
 HP-UX that have a system-wide virtual->real address map, and
 consequently impose restrictions on the virtual address values
 permitted.
 NB: The mapping scheme in HP-UX is motivated by the inverted page
 table design in some HP processors.
 This alternate implementation allows for the addresses to be
 if (prev == h || nex == h)	/* In fact, this should be && */
 {				/* We're the singleton dll */
 UNDERLYING_FREE( h );		/* Free the sole item */
 mmap_start = 0; return;
 }
 else if (h == mmap_start)
 {
 mmap_start = nex;		/* Make sure mmap_start isn't bogus. */
 }
 prev->right = nex;
 nex->left = prev;
 static void
 init_MHASH_table (void)
 {
 int i = 0;
 for (; i < MHASH_PRIME; i++)
 {
 MHASH_HITS[i].n_hits = 0;
 MHASH_HITS[i].addr = 0;
 MHASH_HITS[i].handle = 0;
 }
 #if (LONGBITS == 64)
 unsigned long int addr_shift = (unsigned long int)(addr) >> USELESS_LOWER_ADDRESS_BITS;
 #else
 unsigned int addr_shift = (unsigned int)(addr) >> USELESS_LOWER_ADDRESS_BITS;
 #endif
 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. */
 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-pages-mapped: number of pages mapped by r_alloc calls only.
 mmap-times-unmapped: number of times r_free was called.
 mmap-times-remapped: number of times r_re_alloc was called.
 mmap-didnt-copy: number of times  re-alloc didn\'t have to move the block.
 mmap-pages-copied: total number of pages copied.
 mmap-average-bumpval: average increase in size demanded to re-alloc.
 mmap-wastage: total number of bytes allocated, but not currently in use.
 return result;
 }
 #else /* !MMAP_METERING */
 #define MEMMETER(x)
 #define MVAL(x)
 #endif /* MMAP_METERING */
 static MMAP_HANDLE
 case 0:
 MEMMETER( MVAL( M_Hash_Worked )++ )
 return 0;
 case 1:
 if (*alias == MHASH_HITS[kval].addr)
 	{
 	  MEMMETER( MVAL( M_Hash_Worked) ++ );
 	  return MHASH_HITS[kval].handle;
 	}
 /* FALL THROUGH */
 default:
 return find_mmap_handle_lsearch( alias );
 } /* switch */
 }
 /*
 Some kernels don't like being asked to pick addresses for mapping
 themselves---IRIX is known to become extremely slow if mmap is
 passed a ZERO as the first argument.  In such cases, we use an
 address map which is managed local to the XEmacs process.  The
 address map maintains an ordered linked list of (address, size,
 static ADDRESS_CHAIN addr_chain = 0;
 /* 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()
 {
 MEMMETER( MVAL( M_Addrlist_Size )++)
 addr_chain = (ADDRESS_CHAIN) UNDERLYING_MALLOC( sizeof( ADDRESS_BLOCK ));
 	  np = p->next;
 	  if (p->flag == occupied) break; /* No cigar */
 	  /* Check if the addresses are contiguous. */
 	  if (p->addr + p->sz != np->addr) break;
 	  MEMMETER( MVAL( M_Addrlist_Size )--)
 	  /* We can coalesce these two. */
 	  p->sz += np->sz;
 	  p->next = np->next;
 	  assert( np != addr_chain ); /* We're not freeing the head of the list. */
 	  remainder->flag = empty;
 	  remainder->addr = p->addr + sz;
 	  remainder->sz = p->sz - sz;
 	  MEMMETER( MVAL( M_Addrlist_Size )++)
 	  /* Now make p become an occupied block with the appropriate size */
 	  p->next = remainder;
 	  p->sz = sz;
 	  new_addr = mmap( (VM_ADDR) p->addr, p->sz, PROT_READ|PROT_WRITE,
 			   MAP_FLAGS, DEV_ZERO_FD, 0 );
 	  munmap( (VM_ADDR) p->addr, p->sz );
 	  p->flag = empty;
 	  break;
 	}
 }
 if (!p) abort(); /* Can't happen... we've got a block to free which is not in
 		      the address list. */
 Coalesce_Addr_Blocks();
 }
 #else /* !MMAP_GENERATE_ADDRESSES */
 /* This is an alternate (simpler) implementation in cases where the
 /* Nothing. */
 }
 static VM_ADDR New_Addr_Block( SIZE sz )
 {
-return mmap( 0, sz, PROT_READ|PROT_WRITE, MAP_FLAGS,
+return mmap (0, sz, PROT_READ|PROT_WRITE, MAP_FLAGS,
 	       DEV_ZERO_FD, 0 );
 }
 static void Free_Addr_Block( VM_ADDR addr, SIZE sz )
 {
-munmap( addr, 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
 address aliased to the first parameter.
 */
 POINTER r_alloc (POINTER *ptr, SIZE size);
 POINTER
 r_alloc (POINTER *ptr, SIZE size)
 {
 MMAP_HANDLE mh;
 switch(r_alloc_initialized)
 {
 case 0:
 abort();
 case 1:
 	    return 0;		/* ralloc failed due to mmap() failure. */
 	  }
 	  MHASH_ADD( mh->vm_addr, mh );
 	  mh->space_for = mmapped_size;
 	  mh->aliased_address = ptr;
-	  *ptr = mh->vm_addr;
+	  *ptr = (POINTER) mh->vm_addr;
 	}
 else
 	*ptr = 0;		/* Malloc of block failed */
 break;
 }
 MEMMETER(MVAL(M_Remap)++)
 if (h->space_for > sz)	/* We've got some more room */
 	{			/* Also, if a shrinkage was asked for. */
 	  MEMMETER( MVAL(M_Didnt_Copy)++ )
 MEMMETER( MVAL(M_Wastage) -= (sz - h->size))
 	  /* We're pretty dumb at handling shrinkage.  We should check for
 	     a larger gap than the standard hysteresis allowable, and if so,
 	     shrink the number of pages.  Right now, we simply reset the size
 	     component and return. */
 	  h->size = sz;
 	  return *ptr;
 	}
 new_vm_addr = New_Addr_Block( actual_sz );
 if (new_vm_addr == VM_FAILURE_ADDR)
 	{/* Failed to realloc. */
 /* *ptr = 0; */
 	  return 0;
 	}
 /* Update block datastructure. */
 h->space_for = actual_sz;	/* New total space */
 h->size = sz;		/* New (requested) size */
 h->vm_addr = new_vm_addr;	/* New VM start address */
 h->aliased_address = ptr;	/* Change alias to reflect block relocation. */
-*ptr = h->vm_addr;
+*ptr = (POINTER) h->vm_addr;
 return *ptr;
 }
 }
 void
 vars_of_ralloc (void)
 {
 DEFVAR_INT ("mmap-hysteresis", &mmap_hysteresis /*
 Extra room left at the end of an allocated arena,
 so that a re-alloc requesting extra space smaller than this
 does not actually cause a new arena to be allocated.
 A negative value is considered equal to zero.  This is the
 minimum amount of space guaranteed to be left at the end of
 the arena.  Because allocation happens in multiples of the OS
 page size, it is possible for more space to be left unused.
 */ );
 mmap_hysteresis = 0;
 }

Mercurial > hg > xemacs-beta

comparison src/ralloc.c @ 185:3d6bfa290dbd r20-3b19