emacs: src/gmalloc.c comparison

comparison src/gmalloc.c @ 78051:2c30fdff6890

[HAVE_GTK_AND_PTHREAD] Check this after including config.h. (_aligned_blocks_mutex) [USE_PTHREAD]: New variable. (LOCK_ALIGNED_BLOCKS, UNLOCK_ALIGNED_BLOCKS): New macros. (_free_internal, memalign): Use them. (_malloc_mutex, _aligned_blocks_mutex) [USE_PTHREAD]: Initialize to PTHREAD_MUTEX_INITIALIZER. (malloc_initialize_1) [USE_PTHREAD]: Don't use recursive mutex. (morecore_nolock): Rename from morecore. All uses changed. Use only nolock versions of internal allocation functions. (_malloc_internal_nolock, _realloc_internal_nolock) (_free_internal_nolock): New functions created from _malloc_internal, _realloc_internal, and _free_internal. (_malloc_internal, _realloc_internal, _free_internal): Use them. Copy hook value to automatic variable before its use. (memalign): Copy hook value to automatic variable before its use.

author	YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
date	Tue, 26 Jun 2007 03:29:05 +0000
parents	2bb28b957639
children	77430fdfce38

comparison

equal deleted inserted replaced

-:74d45d6140ca
+:2c30fdff6890
 /* This file is no longer automatically generated from libc.  */
 #define _MALLOC_INTERNAL
-#ifdef HAVE_GTK_AND_PTHREAD
-#define USE_PTHREAD
-#endif
 /* The malloc headers and source files from the C library follow here.  */
 /* Declarations for `malloc' and friends.
 Copyright (C) 1990, 1991, 1992, 1993, 1995, 1996, 1999, 2002, 2003, 2004,
 #ifdef _MALLOC_INTERNAL
 #ifdef	HAVE_CONFIG_H
 #include <config.h>
+#endif
+#ifdef HAVE_GTK_AND_PTHREAD
+#define USE_PTHREAD
 #endif
 #if ((defined __cplusplus || (defined (__STDC__) && __STDC__) \
 || defined STDC_HEADERS || defined PROTOTYPES) \
 && ! defined (BROKEN_PROTOTYPES))
 used when these functions need to call each other.
 They are the same but don't call the hooks.  */
 extern __ptr_t _malloc_internal PP ((__malloc_size_t __size));
 extern __ptr_t _realloc_internal PP ((__ptr_t __ptr, __malloc_size_t __size));
 extern void _free_internal PP ((__ptr_t __ptr));
+extern __ptr_t _malloc_internal_nolock PP ((__malloc_size_t __size));
+extern __ptr_t _realloc_internal_nolock PP ((__ptr_t __ptr, __malloc_size_t __size));
+extern void _free_internal_nolock PP ((__ptr_t __ptr));
 #ifdef USE_PTHREAD
-extern pthread_mutex_t _malloc_mutex;
+extern pthread_mutex_t _malloc_mutex, _aligned_blocks_mutex;
 #define LOCK()     pthread_mutex_lock (&_malloc_mutex)
 #define UNLOCK()   pthread_mutex_unlock (&_malloc_mutex)
+#define LOCK_ALIGNED_BLOCKS()     pthread_mutex_lock (&_aligned_blocks_mutex)
+#define UNLOCK_ALIGNED_BLOCKS()   pthread_mutex_unlock (&_aligned_blocks_mutex)
 #else
 #define LOCK()
 #define UNLOCK()
+#define LOCK_ALIGNED_BLOCKS()
+#define UNLOCK_ALIGNED_BLOCKS()
 #endif
 #endif /* _MALLOC_INTERNAL.  */
 /* Given an address in the middle of a malloc'd object,
 _heapinfo[block + blocks].busy.info.size = -blocks;
 }
 #ifdef USE_PTHREAD
 static pthread_once_t malloc_init_once_control = PTHREAD_ONCE_INIT;
-pthread_mutex_t _malloc_mutex;
+pthread_mutex_t _malloc_mutex = PTHREAD_MUTEX_INITIALIZER;
+pthread_mutex_t _aligned_blocks_mutex = PTHREAD_MUTEX_INITIALIZER;
 #endif
 static void
 malloc_initialize_1 ()
 {
 #endif
 if (__malloc_initialize_hook)
 (*__malloc_initialize_hook) ();
-#ifdef USE_PTHREAD
+/* We don't use recursive mutex because pthread_mutexattr_init may
+call malloc internally.  */
+#if 0 /* defined (USE_PTHREAD) */
 {
 pthread_mutexattr_t attr;
 pthread_mutexattr_init (&attr);
 pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE);
 static int morecore_recursing;
 /* Get neatly aligned memory, initializing or
 growing the heap info table as necessary. */
-static __ptr_t morecore PP ((__malloc_size_t));
+static __ptr_t morecore_nolock PP ((__malloc_size_t));
 static __ptr_t
-morecore (size)
+morecore_nolock (size)
 __malloc_size_t size;
 {
 __ptr_t result;
 malloc_info *newinfo, *oldinfo;
 __malloc_size_t newsize;
 	     extend it in place or relocate it to existing sufficient core,
 	     we will get called again, and the code above will notice the
 	     `morecore_recursing' flag and return null.  */
 	  int save = errno;	/* Don't want to clobber errno with ENOMEM.  */
 	  morecore_recursing = 1;
-	  newinfo = (malloc_info *) _realloc_internal
+	  newinfo = (malloc_info *) _realloc_internal_nolock
 	    (_heapinfo, newsize * sizeof (malloc_info));
 	  morecore_recursing = 0;
 	  if (newinfo == NULL)
 	    errno = save;
 	  else
 register_heapinfo ();
 /* Reset _heaplimit so _free_internal never decides
 	 it can relocate or resize the info table.  */
 _heaplimit = 0;
-_free_internal (oldinfo);
+_free_internal_nolock (oldinfo);
 PROTECT_MALLOC_STATE (0);
 /* The new heap limit includes the new table just allocated.  */
 _heaplimit = BLOCK ((char *) newinfo + heapsize * sizeof (malloc_info));
 return result;
 return result;
 }
 /* Allocate memory from the heap.  */
 __ptr_t
-_malloc_internal (size)
+_malloc_internal_nolock (size)
 __malloc_size_t size;
 {
 __ptr_t result;
 __malloc_size_t block, blocks, lastblocks, start;
 register __malloc_size_t i;
 #if	0
 if (size == 0)
 return NULL;
 #endif
-LOCK ();
 PROTECT_MALLOC_STATE (0);
 if (size < sizeof (struct list))
 size = sizeof (struct list);
 else
 	{
 	  /* No free fragments of the desired size, so get a new block
 	     and break it into fragments, returning the first.  */
 #ifdef GC_MALLOC_CHECK
-	  result = _malloc_internal (BLOCKSIZE);
+	  result = _malloc_internal_nolock (BLOCKSIZE);
 	  PROTECT_MALLOC_STATE (0);
+#elif defined (USE_PTHREAD)
+	  result = _malloc_internal_nolock (BLOCKSIZE);
 #else
 	  result = malloc (BLOCKSIZE);
 #endif
 	  if (result == NULL)
 	    {
 		  _heapinfo[block].free.size += (wantblocks - lastblocks);
 		  _bytes_free += (wantblocks - lastblocks) * BLOCKSIZE;
 		  _heaplimit += wantblocks - lastblocks;
 		  continue;
 		}
-	      result = morecore (wantblocks * BLOCKSIZE);
+	      result = morecore_nolock (wantblocks * BLOCKSIZE);
 	      if (result == NULL)
 		goto out;
 	      block = BLOCK (result);
 	      /* Put the new block at the end of the free list.  */
 	      _heapinfo[block].free.size = wantblocks;
 	_heapinfo[block + blocks].busy.info.size = -blocks;
 }
 PROTECT_MALLOC_STATE (1);
 out:
+return result;
+}
+__ptr_t
+_malloc_internal (size)
+__malloc_size_t size;
+{
+__ptr_t result;
+LOCK ();
+result = _malloc_internal_nolock (size);
 UNLOCK ();
 return result;
 }
 __ptr_t
 malloc (size)
 __malloc_size_t size;
 {
+__ptr_t (*hook) (__malloc_size_t);
 if (!__malloc_initialized && !__malloc_initialize ())
 return NULL;
-return (__malloc_hook != NULL ? *__malloc_hook : _malloc_internal) (size);
+/* Copy the value of __malloc_hook to an automatic variable in case
+__malloc_hook is modified in another thread between its
+NULL-check and the use.
+Note: Strictly speaking, this is not a right solution.  We should
+use mutexes to access non-read-only variables that are shared
+among multiple threads.  We just leave it for compatibility with
+glibc malloc (i.e., assignments to __malloc_hook) for now.  */
+hook = __malloc_hook;
+return (hook != NULL ? *hook : _malloc_internal) (size);
 }
 #ifndef _LIBC
 /* On some ANSI C systems, some libc functions call _malloc, _free
 /* List of blocks allocated by memalign.  */
 struct alignlist *_aligned_blocks = NULL;
 /* Return memory to the heap.
-Like `free' but don't call a __free_hook if there is one.  */
+Like `_free_internal' but don't lock mutex.  */
 void
-_free_internal (ptr)
+_free_internal_nolock (ptr)
 __ptr_t ptr;
 {
 int type;
 __malloc_size_t block, blocks;
 register __malloc_size_t i;
 register struct alignlist *l;
 if (ptr == NULL)
 return;
-LOCK ();
 PROTECT_MALLOC_STATE (0);
+LOCK_ALIGNED_BLOCKS ();
 for (l = _aligned_blocks; l != NULL; l = l->next)
 if (l->aligned == ptr)
 {
 	l->aligned = NULL;	/* Mark the slot in the list as free.  */
 	ptr = l->exact;
 	break;
 }
+UNLOCK_ALIGNED_BLOCKS ();
 block = BLOCK (ptr);
 type = _heapinfo[block].busy.type;
 switch (type)
 	      /* Free the old info table, clearing _heaplimit to avoid
 		 recursion into this code.  We don't want to return the
 		 table's blocks to the system before we have copied them to
 		 the new location.  */
 	      _heaplimit = 0;
-	      _free_internal (_heapinfo);
+	      _free_internal_nolock (_heapinfo);
 	      _heaplimit = oldlimit;
 	      /* Tell malloc to search from the beginning of the heap for
 		 free blocks, so it doesn't reuse the ones just freed.  */
 	      _heapindex = 0;
 	      /* Allocate new space for the info table and move its data.  */
-	      newinfo = (malloc_info *) _malloc_internal (info_blocks
+	      newinfo = (malloc_info *) _malloc_internal_nolock (info_blocks
-							  * BLOCKSIZE);
+								 * BLOCKSIZE);
 	      PROTECT_MALLOC_STATE (0);
 	      memmove (newinfo, _heapinfo, info_blocks * BLOCKSIZE);
 	      _heapinfo = newinfo;
 	      /* We should now have coalesced the free block with the
 	  ++_chunks_used;
 	  _bytes_used += BLOCKSIZE;
 	  _chunks_free -= BLOCKSIZE >> type;
 	  _bytes_free -= BLOCKSIZE;
-#ifdef GC_MALLOC_CHECK
+#if defined (GC_MALLOC_CHECK) || defined (USE_PTHREAD)
-	  _free_internal (ADDRESS (block));
+	  _free_internal_nolock (ADDRESS (block));
 #else
 	  free (ADDRESS (block));
 #endif
 	}
 else if (_heapinfo[block].busy.info.frag.nfree != 0)
 	}
 break;
 }
 PROTECT_MALLOC_STATE (1);
+}
+/* Return memory to the heap.
+Like `free' but don't call a __free_hook if there is one.  */
+void
+_free_internal (ptr)
+__ptr_t ptr;
+{
+LOCK ();
+_free_internal_nolock (ptr);
 UNLOCK ();
 }
 /* Return memory to the heap.  */
 FREE_RETURN_TYPE
 free (ptr)
 __ptr_t ptr;
 {
-if (__free_hook != NULL)
+void (*hook) (__ptr_t) = __free_hook;
-(*__free_hook) (ptr);
+if (hook != NULL)
+(*hook) (ptr);
 else
 _free_internal (ptr);
 }
 /* Define the `cfree' alias for `free'.  */
 some benchmarks seem to indicate that greater compactness is
 achieved by unconditionally allocating and copying to a
 new region.  This module has incestuous knowledge of the
 internals of both free and malloc. */
 __ptr_t
-_realloc_internal (ptr, size)
+_realloc_internal_nolock (ptr, size)
 __ptr_t ptr;
 __malloc_size_t size;
 {
 __ptr_t result;
 int type;
 __malloc_size_t block, blocks, oldlimit;
 if (size == 0)
 {
-_free_internal (ptr);
+_free_internal_nolock (ptr);
-return _malloc_internal (0);
+return _malloc_internal_nolock (0);
 }
 else if (ptr == NULL)
-return _malloc_internal (size);
+return _malloc_internal_nolock (size);
 block = BLOCK (ptr);
-LOCK ();
 PROTECT_MALLOC_STATE (0);
 type = _heapinfo[block].busy.type;
 switch (type)
 {
 case 0:
 /* Maybe reallocate a large block to a small fragment.  */
 if (size <= BLOCKSIZE / 2)
 	{
-	  result = _malloc_internal (size);
+	  result = _malloc_internal_nolock (size);
 	  if (result != NULL)
 	    {
 	      memcpy (result, ptr, size);
-	      _free_internal (ptr);
+	      _free_internal_nolock (ptr);
 	      goto out;
 	    }
 	}
 /* The new size is a large allocation as well;
 	  _heapinfo[block].busy.info.size = blocks;
 	  /* We have just created a new chunk by splitting a chunk in two.
 	     Now we will free this chunk; increment the statistics counter
 	     so it doesn't become wrong when _free_internal decrements it.  */
 	  ++_chunks_used;
-	  _free_internal (ADDRESS (block + blocks));
+	  _free_internal_nolock (ADDRESS (block + blocks));
 	  result = ptr;
 	}
 else if (blocks == _heapinfo[block].busy.info.size)
 	/* No size change necessary.  */
 	result = ptr;
 	     adjacent free space to grow without moving. */
 	  blocks = _heapinfo[block].busy.info.size;
 	  /* Prevent free from actually returning memory to the system.  */
 	  oldlimit = _heaplimit;
 	  _heaplimit = 0;
-	  _free_internal (ptr);
+	  _free_internal_nolock (ptr);
-	  result = _malloc_internal (size);
+	  result = _malloc_internal_nolock (size);
 	  PROTECT_MALLOC_STATE (0);
 	  if (_heaplimit == 0)
 	    _heaplimit = oldlimit;
 	  if (result == NULL)
 	    {
 	      /* Now we're really in trouble.  We have to unfree
 		 the thing we just freed.  Unfortunately it might
 		 have been coalesced with its neighbors.  */
 	      if (_heapindex == block)
-	        (void) _malloc_internal (blocks * BLOCKSIZE);
+	        (void) _malloc_internal_nolock (blocks * BLOCKSIZE);
 	      else
 		{
 		  __ptr_t previous
-		    = _malloc_internal ((block - _heapindex) * BLOCKSIZE);
+		    = _malloc_internal_nolock ((block - _heapindex) * BLOCKSIZE);
-		  (void) _malloc_internal (blocks * BLOCKSIZE);
+		  (void) _malloc_internal_nolock (blocks * BLOCKSIZE);
-		  _free_internal (previous);
+		  _free_internal_nolock (previous);
 		}
 	      goto out;
 	    }
 	  if (ptr != result)
 	    memmove (result, ptr, blocks * BLOCKSIZE);
 	result = ptr;
 else
 	{
 	  /* The new size is different; allocate a new space,
 	     and copy the lesser of the new size and the old. */
-	  result = _malloc_internal (size);
+	  result = _malloc_internal_nolock (size);
 	  if (result == NULL)
 	    goto out;
 	  memcpy (result, ptr, min (size, (__malloc_size_t) 1 << type));
-	  _free_internal (ptr);
+	  _free_internal_nolock (ptr);
 	}
 break;
 }
 PROTECT_MALLOC_STATE (1);
 out:
+return result;
+}
+__ptr_t
+_realloc_internal (ptr, size)
+__ptr_t ptr;
+__malloc_size_t size;
+{
+__ptr_t result;
+LOCK();
+result = _realloc_internal_nolock (ptr, size);
 UNLOCK ();
 return result;
 }
 __ptr_t
 realloc (ptr, size)
 __ptr_t ptr;
 __malloc_size_t size;
 {
+__ptr_t (*hook) (__ptr_t, __malloc_size_t);
 if (!__malloc_initialized && !__malloc_initialize ())
 return NULL;
-return (__realloc_hook != NULL ? *__realloc_hook : _realloc_internal)
+hook = __realloc_hook;
-(ptr, size);
+return (hook != NULL ? *hook : _realloc_internal) (ptr, size);
 }
 /* Copyright (C) 1991, 1992, 1994 Free Software Foundation, Inc.
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License as
 __malloc_size_t alignment;
 __malloc_size_t size;
 {
 __ptr_t result;
 unsigned long int adj, lastadj;
+__ptr_t (*hook) (__malloc_size_t, __malloc_size_t) = __memalign_hook;
-if (__memalign_hook)
-return (*__memalign_hook) (alignment, size);
+if (hook)
+return (*hook) (alignment, size);
 /* Allocate a block with enough extra space to pad the block with up to
 (ALIGNMENT - 1) bytes if necessary.  */
 result = malloc (size + alignment - 1);
 if (result == NULL)
 /* Record this block in the list of aligned blocks, so that `free'
 	 can identify the pointer it is passed, which will be in the middle
 	 of an allocated block.  */
 struct alignlist *l;
+LOCK_ALIGNED_BLOCKS ();
 for (l = _aligned_blocks; l != NULL; l = l->next)
 	if (l->aligned == NULL)
 	  /* This slot is free.  Use it.  */
 	  break;
 if (l == NULL)
 	{
 	  l = (struct alignlist *) malloc (sizeof (struct alignlist));
-	  if (l == NULL)
+	  if (l != NULL)
 	    {
-	      free (result);
+	      l->next = _aligned_blocks;
-	      return NULL;
+	      _aligned_blocks = l;
 	    }
-	  l->next = _aligned_blocks;
+	}
-	  _aligned_blocks = l;
+if (l != NULL)
-	}
+	{
-l->exact = result;
+	  l->exact = result;
-result = l->aligned = (char *) result + alignment - adj;
+	  result = l->aligned = (char *) result + alignment - adj;
+	}
+UNLOCK_ALIGNED_BLOCKS ();
+if (l == NULL)
+	{
+	  free (result);
+	  result = NULL;
+	}
 }
 return result;
 }

Mercurial > emacs

comparison src/gmalloc.c @ 78051:2c30fdff6890