Quelle  prmem.c   Sprache: C

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/*
** Thread safe versions of malloc, free, realloc, calloc and cfree.
*/

#include "primpl.h"

#ifdef _PR_ZONE_ALLOCATOR

/*
** The zone allocator code must use native mutexes and cannot
** use PRLocks because PR_NewLock calls PR_Calloc, resulting
** in cyclic dependency of initialization.
*/

#  include <string.h>

union memBlkHdrUn;

typedef struct MemoryZoneStr {
  union memBlkHdrUn* head; /* free list */
  pthread_mutex_t lock;
  size_t blockSize;    /* size of blocks on this free list */
  PRUint32 locked;     /* current state of lock */
  PRUint32 contention; /* counter: had to wait for lock */
  PRUint32 hits;       /* allocated from free list */
  PRUint32 misses;     /* had to call malloc */
  PRUint32 elements;   /* on free list */
} MemoryZone;

typedef union memBlkHdrUn {
  unsigned char filler[48]; /* fix the size of this beast */
  struct memBlkHdrStr {
    union memBlkHdrUn* next;
    MemoryZone* zone;
    size_t blockSize;
    size_t requestedSize;
    PRUint32 magic;
  } s;
} MemBlockHdr;

#  define MEM_ZONES 7
#  define THREAD_POOLS 11 /* prime number for modulus */
#  define ZONE_MAGIC 0x0BADC0DE

static MemoryZone zones[MEM_ZONES][THREAD_POOLS];

static PRBool use_zone_allocator = PR_FALSE;

static void pr_ZoneFree(void* ptr);

void _PR_DestroyZones(void) {
  int i, j;

  if (!use_zone_allocator) {
    return;
  }

  for (j = 0; j < THREAD_POOLS; j++) {
    for (i = 0; i < MEM_ZONES; i++) {
      MemoryZone* mz = &zones[i][j];
      pthread_mutex_destroy(&mz->lock);
      while (mz->head) {
        MemBlockHdr* hdr = mz->head;
        mz->head = hdr->s.next; /* unlink it */
        free(hdr);
        mz->elements--;
      }
    }
  }
  use_zone_allocator = PR_FALSE;
}

/*
** pr_FindSymbolInProg
**
** Find the specified data symbol in the program and return
** its address.
*/

#  ifdef HAVE_DLL

#    if defined(USE_DLFCN) && !defined(NO_DLOPEN_NULL)

#      include <dlfcn.h>

static void* pr_FindSymbolInProg(const char* name) {
  void* h;
  void* sym;

  h = dlopen(0, RTLD_LAZY);
  if (h == NULL) {
    return NULL;
  }
  sym = dlsym(h, name);
  (void)dlclose(h);
  return sym;
}

#    elif defined(USE_HPSHL)

#      include <dl.h>

static void* pr_FindSymbolInProg(const char* name) {
  shl_t h = NULL;
  void* sym;

  if (shl_findsym(&h, name, TYPE_DATA, &sym) == -1) {
    return NULL;
  }
  return sym;
}

#    elif defined(USE_MACH_DYLD) || defined(NO_DLOPEN_NULL)

static void* pr_FindSymbolInProg(const char* name) {
  /* FIXME: not implemented */
  return NULL;
}

#    else

#      error "The zone allocator is not supported on this platform"

#    endif

#  else /* !defined(HAVE_DLL) */

static void* pr_FindSymbolInProg(const char* name) {
  /* can't be implemented */
  return NULL;
}

#  endif /* HAVE_DLL */

void _PR_InitZones(void) {
  int i, j;
  char* envp;
  PRBool* sym;

  if ((sym = (PRBool*)pr_FindSymbolInProg("nspr_use_zone_allocator")) != NULL) {
    use_zone_allocator = *sym;
  } else if ((envp = getenv("NSPR_USE_ZONE_ALLOCATOR")) != NULL) {
    use_zone_allocator = (atoi(envp) == 1);
  }

  if (!use_zone_allocator) {
    return;
  }

  for (j = 0; j < THREAD_POOLS; j++) {
    for (i = 0; i < MEM_ZONES; i++) {
      MemoryZone* mz = &zones[i][j];
      int rv = pthread_mutex_init(&mz->lock, NULL);
      PR_ASSERT(0 == rv);
      if (rv != 0) {
        goto loser;
      }
      mz->blockSize = 16 << (2 * i);
    }
  }
  return;

loser:
  _PR_DestroyZones();
  return;
}

PR_IMPLEMENT(void)
PR_FPrintZoneStats(PRFileDesc* debug_out) {
  int i, j;

  for (j = 0; j < THREAD_POOLS; j++) {
    for (i = 0; i < MEM_ZONES; i++) {
      MemoryZone* mz = &zones[i][j];
      MemoryZone zone = *mz;
      if (zone.elements || zone.misses || zone.hits) {
        PR_fprintf(debug_out,
                   "pool: %d, zone: %d, size: %d, free: %d, hit: %d, miss: %d, "
                   "contend: %d\n",
                   j, i, zone.blockSize, zone.elements, zone.hits, zone.misses,
                   zone.contention);
      }
    }
  }
}

static void* pr_ZoneMalloc(PRUint32 size) {
  void* rv;
  unsigned int zone;
  size_t blockSize;
  MemBlockHdr *mb, *mt;
  MemoryZone* mz;

  /* Always allocate a non-zero amount of bytes */
  if (size < 1) {
    size = 1;
  }
  for (zone = 0, blockSize = 16; zone < MEM_ZONES; ++zone, blockSize <<= 2) {
    if (size <= blockSize) {
      break;
    }
  }
  if (zone < MEM_ZONES) {
    pthread_t me = pthread_self();
    unsigned int pool = (PRUptrdiff)me % THREAD_POOLS;
    PRUint32 wasLocked;
    mz = &zones[zone][pool];
    wasLocked = mz->locked;
    pthread_mutex_lock(&mz->lock);
    mz->locked = 1;
    if (wasLocked) {
      mz->contention++;
    }
    if (mz->head) {
      mb = mz->head;
      PR_ASSERT(mb->s.magic == ZONE_MAGIC);
      PR_ASSERT(mb->s.zone == mz);
      PR_ASSERT(mb->s.blockSize == blockSize);
      PR_ASSERT(mz->blockSize == blockSize);

      mt = (MemBlockHdr*)(((char*)(mb + 1)) + blockSize);
      PR_ASSERT(mt->s.magic == ZONE_MAGIC);
      PR_ASSERT(mt->s.zone == mz);
      PR_ASSERT(mt->s.blockSize == blockSize);

      mz->hits++;
      mz->elements--;
      mz->head = mb->s.next; /* take off free list */
      mz->locked = 0;
      pthread_mutex_unlock(&mz->lock);

      mt->s.next = mb->s.next = NULL;
      mt->s.requestedSize = mb->s.requestedSize = size;

      rv = (void*)(mb + 1);
      return rv;
    }

    mz->misses++;
    mz->locked = 0;
    pthread_mutex_unlock(&mz->lock);

    mb = (MemBlockHdr*)malloc(blockSize + 2 * (sizeof *mb));
    if (!mb) {
      PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
      return NULL;
    }
    mb->s.next = NULL;
    mb->s.zone = mz;
    mb->s.magic = ZONE_MAGIC;
    mb->s.blockSize = blockSize;
    mb->s.requestedSize = size;

    mt = (MemBlockHdr*)(((char*)(mb + 1)) + blockSize);
    memcpy(mt, mb, sizeof *mb);

    rv = (void*)(mb + 1);
    return rv;
  }

  /* size was too big.  Create a block with no zone */
  blockSize = (size & 15) ? size + 16 - (size & 15) : size;
  mb = (MemBlockHdr*)malloc(blockSize + 2 * (sizeof *mb));
  if (!mb) {
    PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
    return NULL;
  }
  mb->s.next = NULL;
  mb->s.zone = NULL;
  mb->s.magic = ZONE_MAGIC;
  mb->s.blockSize = blockSize;
  mb->s.requestedSize = size;

  mt = (MemBlockHdr*)(((char*)(mb + 1)) + blockSize);
  memcpy(mt, mb, sizeof *mb);

  rv = (void*)(mb + 1);
  return rv;
}

static void* pr_ZoneCalloc(PRUint32 nelem, PRUint32 elsize) {
  PRUint32 size = nelem * elsize;
  void* p = pr_ZoneMalloc(size);
  if (p) {
    memset(p, 0, size);
  }
  return p;
}

static void* pr_ZoneRealloc(void* oldptr, PRUint32 bytes) {
  void* rv;
  MemBlockHdr* mb;
  int ours;
  MemBlockHdr phony;

  if (!oldptr) {
    return pr_ZoneMalloc(bytes);
  }
  mb = (MemBlockHdr*)((char*)oldptr - (sizeof *mb));
  if (mb->s.magic != ZONE_MAGIC) {
    /* Maybe this just came from ordinary malloc */
#  ifdef DEBUG
    fprintf(stderr,
            "Warning: reallocing memory block %p from ordinary malloc\n",
            oldptr);
#  endif
    /*
     * We are going to realloc oldptr.  If realloc succeeds, the
     * original value of oldptr will point to freed memory.  So this
     * function must not fail after a successfull realloc call.  We
     * must perform any operation that may fail before the realloc
     * call.
     */
    rv = pr_ZoneMalloc(bytes); /* this may fail */
    if (!rv) {
      return rv;
    }

    /* We don't know how big it is.  But we can fix that. */
    oldptr = realloc(oldptr, bytes);
    /*
     * If realloc returns NULL, this function loses the original
     * value of oldptr.  This isn't a leak because the caller of
     * this function still has the original value of oldptr.
     */
    if (!oldptr) {
      if (bytes) {
        PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
        pr_ZoneFree(rv);
        return oldptr;
      }
    }
    phony.s.requestedSize = bytes;
    mb = &phony;
    ours = 0;
  } else {
    size_t blockSize = mb->s.blockSize;
    MemBlockHdr* mt = (MemBlockHdr*)(((char*)(mb + 1)) + blockSize);

    PR_ASSERT(mt->s.magic == ZONE_MAGIC);
    PR_ASSERT(mt->s.zone == mb->s.zone);
    PR_ASSERT(mt->s.blockSize == blockSize);

    if (bytes <= blockSize) {
      /* The block is already big enough. */
      mt->s.requestedSize = mb->s.requestedSize = bytes;
      return oldptr;
    }
    ours = 1;
    rv = pr_ZoneMalloc(bytes);
    if (!rv) {
      return rv;
    }
  }

  if (oldptr && mb->s.requestedSize) {
    memcpy(rv, oldptr, mb->s.requestedSize);
  }
  if (ours) {
    pr_ZoneFree(oldptr);
  } else if (oldptr) {
    free(oldptr);
  }
  return rv;
}

static void pr_ZoneFree(void* ptr) {
  MemBlockHdr *mb, *mt;
  MemoryZone* mz;
  size_t blockSize;
  PRUint32 wasLocked;

  if (!ptr) {
    return;
  }

  mb = (MemBlockHdr*)((char*)ptr - (sizeof *mb));

  if (mb->s.magic != ZONE_MAGIC) {
    /* maybe this came from ordinary malloc */
#  ifdef DEBUG
    fprintf(stderr, "Warning: freeing memory block %p from ordinary malloc\n",
            ptr);
#  endif
    free(ptr);
    return;
  }

  blockSize = mb->s.blockSize;
  mz = mb->s.zone;
  mt = (MemBlockHdr*)(((char*)(mb + 1)) + blockSize);
  PR_ASSERT(mt->s.magic == ZONE_MAGIC);
  PR_ASSERT(mt->s.zone == mz);
  PR_ASSERT(mt->s.blockSize == blockSize);
  if (!mz) {
    PR_ASSERT(blockSize > 65536);
    /* This block was not in any zone.  Just free it. */
    free(mb);
    return;
  }
  PR_ASSERT(mz->blockSize == blockSize);
  wasLocked = mz->locked;
  pthread_mutex_lock(&mz->lock);
  mz->locked = 1;
  if (wasLocked) {
    mz->contention++;
  }
  mt->s.next = mb->s.next = mz->head; /* put on head of list */
  mz->head = mb;
  mz->elements++;
  mz->locked = 0;
  pthread_mutex_unlock(&mz->lock);
}

PR_IMPLEMENT(void*) PR_Malloc(PRUint32 size) {
  if (!_pr_initialized) {
    _PR_ImplicitInitialization();
  }

  return use_zone_allocator ? pr_ZoneMalloc(size) : malloc(size);
}

PR_IMPLEMENT(void*) PR_Calloc(PRUint32 nelem, PRUint32 elsize) {
  if (!_pr_initialized) {
    _PR_ImplicitInitialization();
  }

  return use_zone_allocator ? pr_ZoneCalloc(nelem, elsize)
                            : calloc(nelem, elsize);
}

PR_IMPLEMENT(void*) PR_Realloc(void* ptr, PRUint32 size) {
  if (!_pr_initialized) {
    _PR_ImplicitInitialization();
  }

  return use_zone_allocator ? pr_ZoneRealloc(ptr, size) : realloc(ptr, size);
}

PR_IMPLEMENT(void) PR_Free(void* ptr) {
  if (use_zone_allocator) {
    pr_ZoneFree(ptr);
  } else {
    free(ptr);
  }
}

#else /* !defined(_PR_ZONE_ALLOCATOR) */

/*
** The PR_Malloc, PR_Calloc, PR_Realloc, and PR_Free functions simply
** call their libc equivalents now.  This may seem redundant, but it
** ensures that we are calling into the same runtime library.  On
** Win32, it is possible to have multiple runtime libraries (e.g.,
** objects compiled with /MD and /MDd) in the same process, and
** they maintain separate heaps, which cannot be mixed.
*/
PR_IMPLEMENT(void*) PR_Malloc(PRUint32 size) { return malloc(size); }

PR_IMPLEMENT(void*) PR_Calloc(PRUint32 nelem, PRUint32 elsize) {
  return calloc(nelem, elsize);
}

PR_IMPLEMENT(void*) PR_Realloc(void* ptr, PRUint32 size) {
  return realloc(ptr, size);
}

PR_IMPLEMENT(void) PR_Free(void* ptr) { free(ptr); }

#endif /* _PR_ZONE_ALLOCATOR */

/*
** Complexity alert!
**
** If malloc/calloc/free (etc.) were implemented to use pr lock's then
** the entry points could block when called if some other thread had the
** lock.
**
** Most of the time this isn't a problem. However, in the case that we
** are using the thread safe malloc code after PR_Init but before
** PR_AttachThread has been called (on a native thread that nspr has yet
** to be told about) we could get royally screwed if the lock was busy
** and we tried to context switch the thread away. In this scenario
**  PR_CURRENT_THREAD() == NULL
**
** To avoid this unfortunate case, we use the low level locking
** facilities for malloc protection instead of the slightly higher level
** locking. This makes malloc somewhat faster so maybe it's a good thing
** anyway.
*/
#ifdef _PR_OVERRIDE_MALLOC

/* Imports */
extern void* _PR_UnlockedMalloc(size_t size);
extern void* _PR_UnlockedMemalign(size_t alignment, size_t size);
extern void _PR_UnlockedFree(void* ptr);
extern void* _PR_UnlockedRealloc(void* ptr, size_t size);
extern void* _PR_UnlockedCalloc(size_t n, size_t elsize);

static PRBool _PR_malloc_initialised = PR_FALSE;

#  ifdef _PR_PTHREADS
static pthread_mutex_t _PR_MD_malloc_crustylock;

#    define _PR_Lock_Malloc()                                 \
      {                                                       \
        if (PR_TRUE == _PR_malloc_initialised) {              \
          PRStatus rv;                                        \
          rv = pthread_mutex_lock(&_PR_MD_malloc_crustylock); \
          PR_ASSERT(0 == rv);                                 \
        }

#    define _PR_Unlock_Malloc()                               \
      if (PR_TRUE == _PR_malloc_initialised) {                \
        PRStatus rv;                                          \
        rv = pthread_mutex_unlock(&_PR_MD_malloc_crustylock); \
        PR_ASSERT(0 == rv);                                   \
      }                                                       \
      }
#  else /* _PR_PTHREADS */
static _MDLock _PR_MD_malloc_crustylock;

#    define _PR_Lock_Malloc()                                 \
      {                                                       \
        PRIntn _is;                                           \
        if (PR_TRUE == _PR_malloc_initialised) {              \
          if (_PR_MD_CURRENT_THREAD() &&                      \
              !_PR_IS_NATIVE_THREAD(_PR_MD_CURRENT_THREAD())) \
            _PR_INTSOFF(_is);                                 \
          _PR_MD_LOCK(&_PR_MD_malloc_crustylock);             \
        }

#    define _PR_Unlock_Malloc()                             \
      if (PR_TRUE == _PR_malloc_initialised) {              \
        _PR_MD_UNLOCK(&_PR_MD_malloc_crustylock);           \
        if (_PR_MD_CURRENT_THREAD() &&                      \
            !_PR_IS_NATIVE_THREAD(_PR_MD_CURRENT_THREAD())) \
          _PR_INTSON(_is);                                  \
      }                                                     \
      }
#  endif /* _PR_PTHREADS */

PR_IMPLEMENT(PRStatus) _PR_MallocInit(void) {
  PRStatus rv = PR_SUCCESS;

  if (PR_TRUE == _PR_malloc_initialised) {
    return PR_SUCCESS;
  }

#  ifdef _PR_PTHREADS
  {
    int status;
    pthread_mutexattr_t mattr;

    status = _PT_PTHREAD_MUTEXATTR_INIT(&mattr);
    PR_ASSERT(0 == status);
    status = _PT_PTHREAD_MUTEX_INIT(_PR_MD_malloc_crustylock, mattr);
    PR_ASSERT(0 == status);
    status = _PT_PTHREAD_MUTEXATTR_DESTROY(&mattr);
    PR_ASSERT(0 == status);
  }
#  else  /* _PR_PTHREADS */
  _MD_NEW_LOCK(&_PR_MD_malloc_crustylock);
#  endif /* _PR_PTHREADS */

  if (PR_SUCCESS == rv) {
    _PR_malloc_initialised = PR_TRUE;
  }

  return rv;
}

void* malloc(size_t size) {
  void* p;
  _PR_Lock_Malloc();
  p = _PR_UnlockedMalloc(size);
  _PR_Unlock_Malloc();
  return p;
}

void free(void* ptr) {
  _PR_Lock_Malloc();
  _PR_UnlockedFree(ptr);
  _PR_Unlock_Malloc();
}

void* realloc(void* ptr, size_t size) {
  void* p;
  _PR_Lock_Malloc();
  p = _PR_UnlockedRealloc(ptr, size);
  _PR_Unlock_Malloc();
  return p;
}

void* calloc(size_t n, size_t elsize) {
  void* p;
  _PR_Lock_Malloc();
  p = _PR_UnlockedCalloc(n, elsize);
  _PR_Unlock_Malloc();
  return p;
}

void cfree(void* p) {
  _PR_Lock_Malloc();
  _PR_UnlockedFree(p);
  _PR_Unlock_Malloc();
}

void _PR_InitMem(void) {
  PRStatus rv;
  rv = _PR_MallocInit();
  PR_ASSERT(PR_SUCCESS == rv);
}

#endif /* _PR_OVERRIDE_MALLOC */