Changeset 11265 for trunk/psLib/src/sys/psMemory.c

Timestamp:

Jan 24, 2007, 12:14:48 PM (19 years ago)

Author:

jhoblitt

Message:

merge jch-memory branch - overhaul of memory subsystem

File:

• trunk/psLib/src/sys/psMemory.c (modified) (33 diffs)

trunk/psLib/src/sys/psMemory.c

@@ -3 +3 @@
 *  @brief Contains the definitions for the memory management system
 *
-*  psMemory.h has additional information and documentation of the routines found in this file.
+*  psMemory.h has additional information and documentation of the routines
+*  found in this file.
 *
 *  @author Robert DeSonia, MHPCC
 *  @author Robert Lupton, Princeton University
+*  @author Joshua Hoblitt, University of Hawaii
 *
-*  @version $Revision: 1.88 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2006-12-08 11:35:54 $
+*  @version $Revision: 1.89 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2007-01-24 22:14:48 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
 */
+
+#if HAVE_CONFIG_H
+# include "config.h"
+#endif
 
 #define PS_ALLOW_MALLOC                    // we're allowed to call malloc()
@@ -22 +28 @@
 #include <assert.h>
 
+#if defined(PS_MEM_BACKTRACE) && defined(HAVE_BACKTRACE)
+# include <execinfo.h>
+#endif
+
 #include "psMemory.h"
-#include "psError.h"
-#include "psAssert.h"
-#include "psAbort.h"
-#include "psLogMsg.h"
-#include "psBitSet.h"
-#include "psFits.h"
-#include "psPixels.h"
-#include "psSphereOps.h"
-#include "psMinimizeLMM.h"
-#include "psImageConvolve.h"
-#include "psTime.h"
-#include "psLine.h"
-#include "psRegion.h"
-#include "psHistogram.h"
-
-#define P_PS_LARGE_BLOCK_SIZE 65536        // size where under, we try to recycle
-
-static psS32 checkMemBlock(const psMemBlock* m, const char *funcName);
-static psMemBlock* lastMemBlockAllocated = NULL;
+#include "psError.h"    // for psErrorStackPrint() only
+
+#define MUTEX_LOCK(mutexPtr) \
+if (safeThreads) { \
+    pthread_mutex_lock(mutexPtr); \
+}
+
+#define MUTEX_UNLOCK(mutexPtr) \
+if (safeThreads) { \
+    pthread_mutex_unlock(mutexPtr); \
+}
+
+// psAbort() calls functions that call psAlloc() so it is *UNSAFE* to use it
+// from within the memory subsystem.  Previous implementations tried to do
+// this and would deadlock while trying to allocate memory.
+//
+// Note that psError() is also *UNSAFE* to use from within the memory
+// subsystem.
+#define PS_MEM_ABORT(name, ...) \
+P_PS_MEM_ABORT(__FILE__, __LINE__, __func__, name, __VA_ARGS__)
+
+// psErrorStackPrint() was specifically modified to be safe to call from inside
+// psMemory.c.
+#define P_PS_MEM_ABORT(filename, lineno, func, name, ...) \
+fprintf(stderr, "%s (%s:%d) ", func, filename, lineno); \
+fprintf(stderr, __VA_ARGS__);\
+psErrorStackPrint(stderr, "\nAborting.  Error stack:\n"); \
+fprintf(stderr, "\n");\
+abort();
+
+#define HANDLE_BAD_BLOCK(memBlock, file, lineo, func) \
+if (isBadMemBlock(stderr, memBlock, file, lineo, func)) { \
+    PS_MEM_ABORT(__func__, "Unsafe to Continue\n"); \
+}
+
+static bool isBadMemBlock(FILE *output, const psMemBlock *memBlock, const char *file, unsigned int lineo, const char *func);
+
+// pointer to the last mem block that was allocated
+static psMemBlock *lastMemBlockAllocated = NULL;
+
+// memBlockListMutex protects access to:
+//      lastMemBlockAllocated
+//      safeThreads
+//      memid
+//      memory_is_persistent
+//      "the linked list of mem blocks"
+//      p_psMemAllocID
+//      p_psMemFreeID
+//      memAllocCallback
+//      memFreeCallback
+//      memExhaustedCallback
+//
+// This is a fair ammount of stuff to protect with a single mutex but most of
+// these items are *VERY* low contention items.  The only item that should be
+// performance issue is "the linked list of mem blocks".  If this does become a
+// problem in production use of the list should be disabled as it is really a
+// debugging feature.
+//
+// XXX make the mem block list a build time option
+//
 static pthread_mutex_t memBlockListMutex = PTHREAD_MUTEX_INITIALIZER;
-static pthread_mutex_t memIdMutex = PTHREAD_MUTEX_INITIALIZER;
 
 //private boolean for enabling/disabling thread safety.  Default = enabled.
@@ -51 +101 @@
 static bool memory_is_persistent = false;
 
-#ifdef PS_MEM_USE_RECYCLE               // Only use recycling if this is set
-#define N_RECYCLE_BINS 14               // number of recycle bins
-#define MAX_RECYCLE 100                 // Maximum number permitted in a recycle bin
-static pthread_mutex_t recycleMemBlockListMutex = PTHREAD_MUTEX_INITIALIZER; // Mutex for recycle bins
-static const psS32 recycleBinSize[N_RECYCLE_BINS] = // Size of each bin
-    {
-        8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, P_PS_LARGE_BLOCK_SIZE
-    };
-// N.B. recycleBinSize should be terminated by P_PS_LARGE_BLOCK_SIZE (simplifies search loops)
-static psS32 recycleBinNums[N_RECYCLE_BINS] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; // Number in each bin
-static psMemBlock* recycleMemBlockList[N_RECYCLE_BINS] = // Contents of the bins
-    { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
-#endif // #ifdef PS_MEM_USE_RECYCLE
-
-#ifdef PS_MEM_DEBUG
-static psMemBlock* deadBlockList;       // a place to put dead memBlocks in debug mode.
-#endif // #ifdef PS_MEM_DEBUG
-
 /**
  * Unique ID for allocated blocks
@@ -79 +111 @@
 static psPtr memExhaustedCallbackDefault(size_t size)
 {
-    #if PS_MEM_USE_RECYCLE
-    psPtr ptr = NULL;
-    if (safeThreads) {
-        pthread_mutex_lock(&recycleMemBlockListMutex);
-    }
-    // Attempt to free up everything I can find so I can alloc my ptr
-    int bin = N_RECYCLE_BINS - 1;       // Recycle bin
-
-    while (bin >= 0 && ptr == NULL) {
-        while (recycleMemBlockList[bin] != NULL && ptr == NULL) {
-            psMemBlock *old = recycleMemBlockList[bin];
-            recycleMemBlockList[bin] = recycleMemBlockList[bin]->nextBlock;
-            free(old);
-            ptr = malloc(size);
-        }
-        bin--;
-    }
-
-    if (safeThreads) {
-        pthread_mutex_unlock(&recycleMemBlockListMutex);
-    }
-    return ptr;
-    #else  // #ifdef PS_MEM_USE_RECYCLE
-
     return NULL;
-    #endif // #ifdef PS_MEM_USE_RECYCLE
 }
 
@@ -113 +120 @@
  * isn't resignalled)
  */
-static psMemId memAllocCallbackDefault(const psMemBlock* ptr)
+static psMemId memAllocCallbackDefault(const psMemBlock *memBlock)
 {
     static psMemId incr = 0; // "p_psMemAllocID += incr"
@@ -120 +127 @@
 }
 
-static psMemId memFreeCallbackDefault(const psMemBlock* ptr)
+static psMemId memFreeCallbackDefault(const psMemBlock *memBlock)
 {
     static psMemId incr = 0; // "p_psMemFreeID += incr"
 
     return incr;
-}
-
-static void memProblemCallbackDefault(psMemBlock* ptr,
-                                      const char *file,
-                                      unsigned int lineno)
-{
-    if (ptr->refCounter < 1) {
-        psError(PS_ERR_MEMORY_CORRUPTION, false,
-                _("Block %lu, allocated at %s:%d, freed multiple times at %s:%d."),
-                (unsigned long)ptr->id, ptr->file, ptr->lineno, file, lineno);
-    }
-
-    if (lineno > 0) {
-        psAbort(__func__, "Detected a problem in the memory system at %s:%d", file, lineno);
-    }
 }
 
@@ -147 +139 @@
  * N.b. If the block wasn't allocated by psAlloc, it will appear corrupted
  */
-static psS32 checkMemBlock(const psMemBlock* m,
-                           const char *funcName)
-{
-    // n.b. since this is called by psMemCheckCorruption while the memblock list is mutex locked,
-    // we shouldn't call such things as p_psAlloc/p_psFree here.
-
-    if (m == NULL) {
-        psError(PS_ERR_MEMORY_CORRUPTION, true,
-                _("NULL memory block found."));
-        return 1;
-    }
-
-    if (m->refCounter == 0) {
+static bool isBadMemBlock(FILE *output, const psMemBlock *memBlock, const char *file, unsigned int lineno, const char *func)
+{
+    // n.b. since this is called by psMemCheckCorruption while the memblock
+    // list is mutex locked, we shouldn't call such things as
+    // p_psAlloc/p_psFree here.
+
+    bool bad = false;
+    bool blockPrinted = false;
+
+    if (memBlock == NULL) {
+        fprintf(output, _("NULL memory block.\n"
+                          "Caught in %s at (%s:%d.).\n\n"), func, file, lineno);
+        // return now as we can't do anything else
+        return true;
+    }
+
+    #if 0
+    // Currently psAlloc()/psRealloc() will blindly create memBlock's with a
+    // size of 0.  This test is in here to check if this is really
+    // happening/being use as a feature in the wild.
+    if (memBlock->userMemorySize < 1) {
+        psMemBlockPrint(output, memBlock);
+        blockPrinted = true;
+        fprintf(output, _("\n\tMemory block has a size of less than 1.\n"));
+        bad = true;
+    }
+    #endif
+
+    if (memBlock->refCounter < 1) {
         // using an unreferenced block of memory, are you?
-        psError(PS_ERR_MEMORY_CORRUPTION, true,
-                _("Memory block %lu was freed but still being used."),
-                (unsigned long)m->id);
-        return 1;
-    }
-
-    if (m->startblock != P_PS_MEMMAGIC || m->endblock != P_PS_MEMMAGIC) {
-        psError(PS_ERR_MEMORY_CORRUPTION, true,
-                _("Memory block %lu is corrupted; buffer underflow detected."),
-                (unsigned long)m->id);
-        return 1;
-    }
-    if (*(psPtr *)((int8_t *) (m + 1) + m->userMemorySize) != P_PS_MEMMAGIC) {
-        psError(PS_ERR_MEMORY_CORRUPTION, true,
-                _("Memory block %lu is corrupted; buffer overflow detected."),
-                (unsigned long)m->id);
-        return 1;
-    }
-
-    return 0;
+        psMemBlockPrint(output, memBlock);
+        blockPrinted = true;
+        fprintf(output, _("\n\tMemory block was freed but still being used.\n"));
+        bad = true;
+    }
+
+    if (memBlock->startblock != P_PS_MEMMAGIC || memBlock->endblock != P_PS_MEMMAGIC) {
+        if (!blockPrinted) {
+            psMemBlockPrint(output, memBlock);
+            blockPrinted = true;
+        }
+        fprintf(output, _("\n\tMemory block is corrupted; buffer underflow detected.\n"));
+        bad = true;
+    }
+
+    if (*(psU32 *)((char *)(memBlock + 1) + memBlock->userMemorySize) != P_PS_MEMMAGIC) {
+        if (!blockPrinted) {
+            psMemBlockPrint(output, memBlock);
+            blockPrinted = true;
+        }
+        fprintf(output, _("\n\tMemory block is corrupted; buffer overflow detected.\n"));
+        bad = true;
+    }
+
+    //  XXX ->nextBlock, & -> prevousBlock really should not be looked at by
+    //  this function as they may be changed out from underneath us by new
+    //  memory allocation.  However, the memBlock itself shouldn't go away (end
+    //  users responsiblity) so all we're really risking is a garbage value.
+
+    if (memBlock == memBlock->nextBlock) {
+        if (!blockPrinted) {
+            psMemBlockPrint(output, memBlock);
+            blockPrinted = true;
+        }
+        fprintf(output, _("\n\tMemory block's ->nextBlock pointer refers to itself.\n"));
+        bad = true;
+    }
+
+    if (memBlock == memBlock->previousBlock) {
+        if (!blockPrinted) {
+            psMemBlockPrint(output, memBlock);
+            blockPrinted = true;
+        }
+        fprintf(output, _("\n\tMemory block's ->previousBlock pointer refers to itself.\n"));
+        bad = true;
+    }
+
+    if (bad) {
+        fprintf(output, _("\tCaught in %s at (%s:%d).\n\n"), func, file, lineno);
+    }
+
+    return bad;
 }
 
@@ -188 +228 @@
  * with psMem{Alloc,Free}CallbackSet
  */
-static psMemId memAllocCallbackCheckCorruption(const psMemBlock *ptr)
+static psMemId memAllocCallbackCheckCorruption(const psMemBlock *memBlock)
 {
     static psMemId incr = 10; // "p_psMemAllocID += incr"
-    bool abort_on_error = false;
-
-    if (psMemCheckCorruption(abort_on_error) > 0) {
-        fprintf(stderr,"Detected memory corruption\n"); // somewhere to set a breakpoint
+
+    if (psMemCheckCorruption(stderr, false) > 0) {
+        fprintf(stderr, "Detected memory corruption\n"); // somewhere to set a breakpoint
     }
 
@@ -205 +244 @@
 static psMemAllocCallback memAllocCallback = memAllocCallbackDefault;
 static psMemFreeCallback memFreeCallback = memFreeCallbackDefault;
-static psMemProblemCallback memProblemCallback = memProblemCallbackDefault;
 static psMemExhaustedCallback memExhaustedCallback = memExhaustedCallbackDefault;
 
 psMemExhaustedCallback psMemExhaustedCallbackSet(psMemExhaustedCallback func)
 {
+    MUTEX_LOCK(&memBlockListMutex);
+
     psMemExhaustedCallback old = memExhaustedCallback;
 
@@ -218 +258 @@
     }
 
-    return old;
-}
-
-psMemProblemCallback psMemProblemCallbackSet(psMemProblemCallback func)
-{
-    psMemProblemCallback old = memProblemCallback;
-
-    if (func != NULL) {
-        memProblemCallback = func;
-    } else {
-        memProblemCallback = memProblemCallbackDefault;
-    }
+    MUTEX_UNLOCK(&memBlockListMutex);
 
     return old;
@@ -244 +273 @@
 psMemId psMemAllocCallbackSetID(psMemId id)
 {
+    MUTEX_LOCK(&memBlockListMutex);
+
     psMemId old = p_psMemAllocID;
 
@@ -253 +284 @@
     p_psMemAllocID = id;
 
+    MUTEX_UNLOCK(&memBlockListMutex);
+
     return old;
 }
@@ -258 +291 @@
 psMemId psMemFreeCallbackSetID(psMemId id)
 {
+    MUTEX_LOCK(&memBlockListMutex);
+
     psMemId old = p_psMemFreeID;
 
     p_psMemFreeID = id;
 
+    MUTEX_UNLOCK(&memBlockListMutex);
+
     return old;
 }
@@ -267 +304 @@
 psMemAllocCallback psMemAllocCallbackSet(psMemAllocCallback func)
 {
+    MUTEX_LOCK(&memBlockListMutex);
+
     psMemFreeCallback old = memAllocCallback;
 
@@ -275 +314 @@
     }
 
+    MUTEX_UNLOCK(&memBlockListMutex);
+
     return old;
 }
@@ -280 +321 @@
 psMemFreeCallback psMemFreeCallbackSet(psMemFreeCallback func)
 {
+    MUTEX_LOCK(&memBlockListMutex);
+
     psMemFreeCallback old = memFreeCallback;
 
@@ -288 +331 @@
     }
 
+    MUTEX_UNLOCK(&memBlockListMutex);
+
     return old;
 }
@@ -301 +346 @@
 psMemId psMemGetLastId(void)
 {
-    if (safeThreads) {
-        pthread_mutex_lock(&memIdMutex);
-    }
+    MUTEX_LOCK(&memBlockListMutex);
 
     psMemId id = memid;
 
-    if (safeThreads) {
-        pthread_mutex_unlock(&memIdMutex);
-    }
+    MUTEX_UNLOCK(&memBlockListMutex);
 
     return id;
 }
 
-int psMemCheckCorruption(bool abort_on_error)
-{
+int psMemCheckCorruption(FILE *output, bool abort_on_error)
+{
+    // get exclusive access to the memBlock list to avoid it changing on us
+    // while we use it.
+    MUTEX_LOCK(&memBlockListMutex);
+
     psS32 nbad = 0;               // number of bad blocks
-    psBool failure = false;
-
-    // get exclusive access to the memBlock list to avoid it changing on us while we use it.
-    //    pthread_mutex_lock(&memBlockListMutex);
-
-    for (psMemBlock* iter = lastMemBlockAllocated; iter != NULL; iter = iter->nextBlock) {
-        if (safeThreads) {
-            pthread_mutex_unlock(&memBlockListMutex);
-        }
-        failure = checkMemBlock(iter, __func__);
-        if (safeThreads) {
-            pthread_mutex_lock(&memBlockListMutex);
-        }
-        if ( failure ) {
+    for (psMemBlock *memBlock = lastMemBlockAllocated; memBlock != NULL; memBlock = memBlock->nextBlock) {
+        if (isBadMemBlock(output, memBlock, __FILE__, __LINE__, __func__)) {
             nbad++;
-
-            memProblemCallback(iter, __func__, __LINE__);
 
             if (abort_on_error) {
                 // release the lock on the memblock list
-                if (safeThreads) {
-                    pthread_mutex_unlock(&memBlockListMutex);
-                }
-                psAbort(__func__, "Detected memory corruption");
+                MUTEX_UNLOCK(&memBlockListMutex);
+                PS_MEM_ABORT(__func__, "Detected memory corruption");
                 return nbad;
             }
@@ -347 +376 @@
 
     // release the lock on the memblock list
-    if (safeThreads) {
-        pthread_mutex_unlock(&memBlockListMutex);
-    }
+    MUTEX_UNLOCK(&memBlockListMutex);
+
     return nbad;
 }
@@ -358 +386 @@
 bool p_psMemAllocatePersistent(bool is_persistent)
 {
+    MUTEX_LOCK(&memBlockListMutex);
+
     const bool old = memory_is_persistent;
     memory_is_persistent = is_persistent;
 
+    MUTEX_UNLOCK(&memBlockListMutex);
+
     return old;
 }
-
-#ifdef PS_MEM_USE_RECYCLE
-// Return the appropriate recycle bin number
-static int getRecycleBin(size_t size)
-{
-    if (size >= P_PS_LARGE_BLOCK_SIZE) {
-        return N_RECYCLE_BINS;
-    }
-    int binNum = 0;                     // Recycle bin number
-    while (size > recycleBinSize[binNum]) {
-        binNum++;
-    }
-    return binNum;
-}
-
-// Push a pointer onto the recycle bin
-static void recyclePush(psMemBlock *mb, // Pointer to push
-                        int bin         // Recycling bin
-                       )
-{
-    assert(mb);
-    assert(bin < N_RECYCLE_BINS);
-
-    mb->previousBlock = NULL;
-
-    if (safeThreads) {
-        pthread_mutex_lock(&recycleMemBlockListMutex);
-    }
-
-    mb->nextBlock = recycleMemBlockList[bin];
-    if (recycleMemBlockList[bin] != NULL) {
-        recycleMemBlockList[bin]->previousBlock = mb;
-    }
-    recycleMemBlockList[bin] = mb;
-    recycleBinNums[bin]++;
-
-    if (safeThreads) {
-        pthread_mutex_unlock(&recycleMemBlockListMutex);
-    }
-
-    return;
-}
-
-// Pop a pointer from the recycle bin
-static psMemBlock *recyclePop(int bin   // Recycling bin
-                             )
-{
-    if (bin >= N_RECYCLE_BINS) {
-        return NULL;
-    }
-
-    if (safeThreads) {
-        pthread_mutex_lock(&recycleMemBlockListMutex);
-    }
-
-    psMemBlock *mb = recycleMemBlockList[bin]; // Pointer popped from recycle bin
-
-    if (mb) {
-        // We pull it off the list
-        recycleMemBlockList[bin] = mb->nextBlock;
-        if (recycleMemBlockList[bin] != NULL) {
-            recycleMemBlockList[bin]->previousBlock = NULL;
-        }
-        recycleBinNums[bin]--;
-    }
-
-    if (safeThreads) {
-        pthread_mutex_unlock(&recycleMemBlockListMutex);
-    }
-
-    return mb;
-}
-#endif // #ifdef PS_MEM_USE_RECYCLE
 
 /*
@@ -442 +401 @@
 psPtr p_psAlloc(size_t size,
                 const char *file,
-                unsigned int lineno)
-{
-
-    psMemBlock *ptr = NULL;
-
-    #ifdef PS_MEM_USE_RECYCLE
-    // Are we in one of the recycle bins?
-    int bin = getRecycleBin(size);
-    if (bin < N_RECYCLE_BINS) {
-        size = recycleBinSize[bin];     // round-up size to next sized bin.
-        ptr = recyclePop(bin);          // grab out of the recycle bin
-    }
-    #endif // #ifdef PS_MEM_USE_RECYCLE
-
-    if (ptr == NULL) {
-        ptr = malloc(sizeof(psMemBlock) + size + sizeof(psPtr ));
-
-        if (ptr == NULL) {
-            ptr = memExhaustedCallback(size);
-            if (ptr == NULL) {
-                psAbort(__func__, "Failed to allocate %zd bytes at %s:%d", size, file, lineno);
-            }
-        }
-
-        *(psPtr*)&ptr->startblock = P_PS_MEMMAGIC;
-        *(psPtr*)&ptr->endblock = P_PS_MEMMAGIC;
-        ptr->userMemorySize = size;
-        if (safeThreads) {
-            pthread_mutex_init(&ptr->refCounterMutex, NULL);
-        }
-    }
-    // increment the memory id safely.
-    if (safeThreads) {
-        pthread_mutex_lock(&memBlockListMutex);
-    }
-    *(psMemId* ) & ptr->id = ++memid;
-    if (safeThreads) {
-        pthread_mutex_unlock(&memBlockListMutex);
-    }
-    ptr->file = file;
-    ptr->freeFunc = NULL;
-    ptr->persistent = memory_is_persistent;
-    *(psU32 *)&ptr->lineno = lineno;
-    *(psPtr *)((int8_t *) (ptr + 1) + size) = P_PS_MEMMAGIC;
-    ptr->previousBlock = NULL;
-
-    ptr->refCounter = 1;                   // one user so far
+                unsigned int lineno,
+                const char *func)
+{
+
+    psMemBlock *memBlock = malloc(sizeof(psMemBlock) + size + sizeof(psPtr));
+    if (memBlock == NULL) {
+        MUTEX_LOCK(&memBlockListMutex);
+        memBlock = memExhaustedCallback(size);
+        MUTEX_UNLOCK(&memBlockListMutex);
+        if (memBlock == NULL) {
+            PS_MEM_ABORT(__func__, "Failed to allocate %zd bytes at %s (%s:%d)", size, func, file, lineno);
+        }
+    }
+
+    // posts
+    *(psU32 *)&memBlock->startblock = P_PS_MEMMAGIC;
+    *(psU32 *)&memBlock->endblock   = P_PS_MEMMAGIC;
+    *(psU32 *)((char *) (memBlock + 1) + size) = P_PS_MEMMAGIC;
+
+    // size of memory allocated
+    memBlock->userMemorySize = size;
+
+    // alloc request by:
+    // thread
+    *(pthread_t *)&memBlock->tid = pthread_self();
+    // file
+    memBlock->file = file;
+    // line number
+    *(unsigned int *)&memBlock->lineno = (unsigned int)lineno;
+    // function
+    memBlock->func = func;
+
+    #if defined(PS_MEM_BACKTRACE) && defined(HAVE_BACKTRACE)
+    #define BACKTRACE_BUFFER_SIZE 32
+    // psMemBlock.func is a 'const char *', so basically we're going to abuse
+    // that and treat it as a void ** to carry around backtrace information.
+    // psMemBlock is not ifdef'd to make sure that psMemBlock is always the
+    // same size & layout reguardless of the pslib .so that's being linked
+    // against
+    void **bt = malloc(BACKTRACE_BUFFER_SIZE * sizeof(void *));
+    if (bt == NULL) {
+        PS_MEM_ABORT(__func__, "Failed to allocate memmory for backtrace buffer: %zd bytes at %s (%s:%d)", 32 * sizeof(void *), func, file, lineno);
+    }
+    *(size_t *)&memBlock->backtraceSize = backtrace(bt, BACKTRACE_BUFFER_SIZE);
+    *(void ***)&memBlock->backtrace = bt;
+    #endif // ifdef HAVE_BACKTRACE
+
+    // free function
+    memBlock->freeFunc = NULL;
+
+    // persistent memory flag
+    memBlock->persistent = memory_is_persistent;
+
+    // this block will be add as the last mem block in the list
+    memBlock->previousBlock = NULL;
+
+    // ref count
+    memBlock->refCounter = 1;                   // one user so far
 
     // need exclusive access of the memory block list now...
-    if (safeThreads) {
-        pthread_mutex_lock(&memBlockListMutex);
-    }
+    MUTEX_LOCK(&memBlockListMutex);
+
+    // increment the memory id only after we've grabbed the memBlockListMutex
+    *(psMemId* )&memBlock->id = ++memid;
 
     // insert the new block to the front of the memBlock linked-list
-    ptr->nextBlock = lastMemBlockAllocated;
-    if (ptr->nextBlock != NULL) {
-        ptr->nextBlock->previousBlock = ptr;
-    }
-    lastMemBlockAllocated = ptr;
-
-    if (safeThreads) {
-        pthread_mutex_unlock(&memBlockListMutex);
-    }
+    memBlock->nextBlock = lastMemBlockAllocated;
+    if (memBlock->nextBlock != NULL) {
+        memBlock->nextBlock->previousBlock = memBlock;
+    }
+    lastMemBlockAllocated = memBlock;
 
     // Did the user ask to be informed about this allocation?
-    if (ptr->id == p_psMemAllocID) {
-        p_psMemAllocID += memAllocCallback(ptr);
-    }
+    if (memBlock->id == p_psMemAllocID) {
+        // p_psMemAllocID can only be changed while the memBlockList mutex is
+        // held
+        p_psMemAllocID += memAllocCallback(memBlock);
+    }
+
+    MUTEX_UNLOCK(&memBlockListMutex);
+
     // And return the user the memory that they allocated
-    return ptr + 1;                        // user memory
-}
-
-psPtr p_psRealloc(psPtr vptr,
+    return memBlock + 1;                        // user memory
+}
+
+psPtr p_psRealloc(psPtr ptr,
                   size_t size,
                   const char *file,
-                  unsigned int lineno)
-{
-    if (vptr == NULL) {
-        return p_psAlloc(size, file, lineno);
-    }
-
-    psMemBlock *ptr = ((psMemBlock*)vptr) - 1;
-
-    if (checkMemBlock(ptr, __func__) != 0) {
-        memProblemCallback(ptr, file, lineno);
-        psAbort(file, "Realloc detected a memory corruption (id %lu @ %s:%d).",
-                (unsigned long)ptr->id, ptr->file, ptr->lineno);
-    }
-
-    #ifdef PS_MEM_USE_RECYCLE
-    // Ensure the size matches that of the recycle bin
-    int bin = getRecycleBin(size);
-    if (bin < N_RECYCLE_BINS) {
-        size = recycleBinSize[bin];     // round-up size to next sized bin.
-    }
-    #endif // #ifdef PS_MEM_USE_RECYCLE
-
-    if (size == ptr->userMemorySize) {
+                  unsigned int lineno,
+                  const char *func)
+{
+    if (ptr == NULL) {
+        return p_psAlloc(size, file, lineno, func);
+    }
+
+    psMemBlock *memBlock = ((psMemBlock *)ptr) - 1;
+
+    HANDLE_BAD_BLOCK(memBlock, file, lineno, func);
+
+    if (size == memBlock->userMemorySize) {
         // Nothing to do
-        return vptr;
+        return ptr;
     }
 
     // Reallocate the memory
 
-    if (safeThreads) {
-        pthread_mutex_lock(&memBlockListMutex);
-    }
-
-    bool isBlockLast = (ptr == lastMemBlockAllocated); // Is this the last block we allocated?
-    ptr = (psMemBlock *)realloc(ptr, sizeof(psMemBlock) + size + sizeof(psPtr));
-    if (ptr == NULL) {
-        ptr = memExhaustedCallback(size);
-        if (ptr == NULL) {
-            psAbort(__func__, "Failed to reallocate %zd bytes at %s:%d", size, file, lineno);
-        }
-    }
-
-    ptr->userMemorySize = size;
-    *(psPtr *)((int8_t *) (ptr + 1) + size) = P_PS_MEMMAGIC;
-
+    // Is this the last block we allocated?  If it is, we need to keep track of
+    // this fact and update lastMemBlockAllocated *after* the realloc or
+    // lastMemBlockAllocated will be left with a bogus value
+    bool isBlockLast = (memBlock == lastMemBlockAllocated);
+
+    memBlock = (psMemBlock *)realloc(memBlock, sizeof(psMemBlock) + size + sizeof(psPtr));
+    if (memBlock== NULL) {
+        MUTEX_LOCK(&memBlockListMutex);
+        memBlock = memExhaustedCallback(size);
+        if (memBlock == NULL) {
+            MUTEX_UNLOCK(&memBlockListMutex);
+            psMemBlockPrint(stderr,  ((psMemBlock *)ptr) - 1);
+            fprintf(stderr, "Problem reallocating block\n");
+            PS_MEM_ABORT(__func__, "Failed to reallocate to %zd bytes at %s (%s:%d)", size, func, file, lineno);
+        }
+    }
+
+    // realloc() successed so need to update lastMemBlockAllocated if we just
+    // mucked with the last mem block
     if (isBlockLast) {
-        lastMemBlockAllocated = ptr;
+        lastMemBlockAllocated = memBlock;
+    }
+
+    memBlock->userMemorySize = size;
+    *(psU32 *)((char *)(memBlock + 1) + size) = P_PS_MEMMAGIC;
+
+    MUTEX_LOCK(&memBlockListMutex);
+
+    // Is this the last block we allocated?
+    if (memBlock== lastMemBlockAllocated) {
+        lastMemBlockAllocated = memBlock;
     }
 
     // the block location may have changed, so fix the linked list addresses.
-    if (ptr->nextBlock != NULL) {
-        ptr->nextBlock->previousBlock = ptr;
-    }
-    if (ptr->previousBlock != NULL) {
-        ptr->previousBlock->nextBlock = ptr;
-    }
-
-    if (safeThreads) {
-        pthread_mutex_unlock(&memBlockListMutex);
+    if (memBlock->nextBlock != NULL) {
+        memBlock->nextBlock->previousBlock = memBlock;
+    }
+    if (memBlock->previousBlock != NULL) {
+        memBlock->previousBlock->nextBlock = memBlock;
     }
 
     // Did the user ask to be informed about this allocation?
-    if (ptr->id == p_psMemAllocID) {
-        p_psMemAllocID += memAllocCallback(ptr);
-    }
-
-    return ptr + 1;                    // usr memory
-}
-
-void p_psFree(psPtr vptr,
-              const char *filename,
-              unsigned int lineno)
-{
-    if (vptr == NULL) {
-        return;
-    }
-    psMemBlock* ptr = ((psMemBlock* ) vptr) - 1;
-    if (ptr->refCounter < 1) {
-        psMemBlock* ptr = ((psMemBlock* ) vptr) - 1;
-
-        psAbort(__func__,_("Block %lu, allocated at %s:%d, freed multiple times at %s:%d."),
-                (unsigned long)ptr->id, ptr->file, ptr->lineno, filename, lineno);
-    }
-
-    if (checkMemBlock(ptr, __func__) != 0) {
-        memProblemCallback(ptr, filename, lineno);
-        psAbort(__func__,"Memory Corruption Detected.");
-    }
-
-    (void)p_psMemDecrRefCounter(vptr, filename, lineno);    // this handles the free, if required.
+    if (memBlock->id == p_psMemAllocID) {
+        p_psMemAllocID += memAllocCallback(memBlock);
+    }
+
+    MUTEX_UNLOCK(&memBlockListMutex);
+
+    return memBlock + 1;                    // usr memory
 }
 
@@ -619 +568 @@
     psS32 nleak = 0;
     psS32 j = 0;
-    psMemBlock* topBlock = lastMemBlockAllocated;
-
-    if (safeThreads) {
-        pthread_mutex_lock(&memBlockListMutex);
-    }
-
-    for (psMemBlock* iter = topBlock; iter != NULL; iter = iter->nextBlock) {
-        if ( (iter->refCounter > 0) &&
-                ( (persistence) || (!persistence && !iter->persistent) ) &&
-                (iter->id >= id0)) {
+    psMemBlock *topBlock = lastMemBlockAllocated;
+
+    MUTEX_LOCK(&memBlockListMutex);
+
+    // find the very first memblock
+    psMemBlock *memBlock = NULL;
+    for (memBlock = topBlock; memBlock->nextBlock != NULL; memBlock = memBlock->nextBlock) { }
+
+    // iterate through the block list starting with the oldest block
+    for (; memBlock != NULL; memBlock = memBlock->previousBlock) {
+        if ( (memBlock->refCounter > 0) &&
+                ( (persistence) || (!persistence && !memBlock->persistent) ) &&
+                (memBlock->id >= id0)) {
 
             nleak++;
@@ -634 +586 @@
             if (fd != NULL) {
                 if (nleak == 1) {
-                    fprintf(fd, "   %20s:line ID\n", "file");
+                    fprintf(fd, "# func at (file:line)  ID: X\n");
                 }
 
-                fprintf(fd, "   %20s:%-4d %lu\n", iter->file, (int)iter->lineno, (unsigned long)iter->id);
+                fprintf(fd, "%s at (%s:%d)  ID: %lu", memBlock->func, memBlock->file, (int)memBlock->lineno, (unsigned long)memBlock->id);
+                #if defined(PS_MEM_BACKTRACE) && defined(HAVE_BACKTRACE)
+
+                size_t size = memBlock->backtraceSize;
+                char **strings = backtrace_symbols((void *const *)memBlock->backtrace, size);
+
+                fprintf(fd, "  Alloc Call Depth: %zd\n", size);
+
+                for (int i = 0; i < size; i++) {
+                    // always ident
+                    int ident = 4;  // initial indent
+                    ident += 2 * i; // nesting depth
+                    fprintf(fd, "%*s", ident, "");
+
+                    // if the caller was an anon function then strchr won't
+                    // find a '(' in the string and will return NULL
+                    char *caller = caller = strchr(strings[i], '(');
+                    if (caller) {
+                        // skip over the '('
+                        caller++;
+                        // find the end of the symbol name
+                        size_t callerLength = abs(strchr(caller, '+') - caller);
+                        // print just the symbol name
+                        for (int i = 0; i < callerLength; i++) {
+                            fputc(caller[i],fd);
+                        }
+                        fprintf(fd, "\n");
+                    } else {
+                        fprintf(fd, "(unknown)\n");
+                    }
+                }
+
+                free (strings);
+                #else // ifdef HAVE_BACKTRACE
+                // \n after "Memory Block ID"
+                fprintf(fd, "\n");
+                #endif // ifdef HAVE_BACKTRACE
+
             }
         }
     }
 
-    if (safeThreads) {
-        pthread_mutex_unlock(&memBlockListMutex);
-    }
+    MUTEX_UNLOCK(&memBlockListMutex);
 
     if (nleak == 0 || array == NULL) {
@@ -650 +637 @@
     }
 
-    *array = p_psAlloc(nleak * sizeof(psMemBlock), __FILE__, __LINE__);
-    if (safeThreads) {
-        pthread_mutex_lock(&memBlockListMutex);
-    }
-
-    for (psMemBlock* iter = topBlock; iter != NULL; iter = iter->nextBlock) {
-        if ( (iter->refCounter > 0) &&
-                ( (persistence) || (!persistence && !iter->persistent) ) &&
-                (iter->id >= id0)) {
-
-            (*array)[j++] = iter;
+    *array = psAlloc(nleak * sizeof(psMemBlock));
+
+    MUTEX_LOCK(&memBlockListMutex);
+
+    for (psMemBlock *memBlock = topBlock; memBlock != NULL; memBlock = memBlock ->nextBlock) {
+        if ( (memBlock->refCounter > 0) &&
+                ( (persistence) || (!persistence && !memBlock->persistent) ) &&
+                (memBlock->id >= id0)) {
+
+            (*array)[j++] = memBlock;
             if (j == nleak) {              // found them all
                 break;
@@ -667 +653 @@
     }
 
-    if (safeThreads) {
-        pthread_mutex_unlock(&memBlockListMutex);
-    }
+    MUTEX_UNLOCK(&memBlockListMutex);
 
     return nleak;
@@ -679 +663 @@
 
 // return refCounter
-psReferenceCount psMemGetRefCounter(const psPtr ptr)
-{
-    psMemBlock* ptr2;
-    psU32 refCount;
-
+psReferenceCount p_psMemGetRefCounter(const psPtr ptr,
+                                      const char *file,
+                                      unsigned int lineno,
+                                      const char *func)
+{
     if (ptr == NULL) {
         return 0;
     }
 
-    ptr2 = ((psMemBlock* ) ptr) - 1;
-
-    if (checkMemBlock(ptr2, __func__) != 0) {
-        memProblemCallback(ptr2, __func__, __LINE__);
-    }
-
-    if (safeThreads) {
-        pthread_mutex_lock(&ptr2->refCounterMutex);
-    }
-    refCount = ptr2->refCounter;
-    if (safeThreads) {
-        pthread_mutex_unlock(&ptr2->refCounterMutex);
-    }
-
-    return refCount;
+    psMemBlock *memBlock = ((psMemBlock *) ptr) - 1;
+
+    HANDLE_BAD_BLOCK(memBlock, file, lineno, func);
+
+    return memBlock->refCounter;
 }
 
 // increment and return refCounter
-psPtr p_psMemIncrRefCounter(const psPtr vptr,
+psPtr p_psMemIncrRefCounter(const psPtr ptr,
                             const char *file,
-                            psS32 lineno)
-{
-    psMemBlock* ptr;
-
-    if (vptr == NULL) {
-        return vptr;
-    }
-
-    ptr = ((psMemBlock* ) vptr) - 1;
-
-    if (checkMemBlock(ptr, __func__)) {
-        memProblemCallback(ptr, file, lineno);
-    }
-
-    if (safeThreads) {
-        pthread_mutex_lock(&ptr->refCounterMutex);
-    }
-    ptr->refCounter++;
-    if (safeThreads) {
-        pthread_mutex_unlock(&ptr->refCounterMutex);
-    }
+                            unsigned int lineno,
+                            const char *func)
+{
+    if (ptr == NULL) {
+        return ptr;
+    }
+
+    psMemBlock* memBlock = ((psMemBlock *) ptr) - 1;
+
+    HANDLE_BAD_BLOCK(memBlock, file, lineno, func);
+
+    memBlock->refCounter++;
 
     // Did the user ask to be informed about this allocation?
-    if (ptr->id == p_psMemAllocID) {
-        p_psMemAllocID += memAllocCallback(ptr);
-    }
-
-    return vptr;
-}
-
+    MUTEX_LOCK(&memBlockListMutex);
+    if (memBlock->id == p_psMemAllocID) {
+        p_psMemAllocID += memAllocCallback(memBlock);
+    }
+    MUTEX_UNLOCK(&memBlockListMutex);
+
+    return ptr;
+}
+
+#if 0
 psPtr p_psMemSetRefCounter(psPtr vptr,
                            psReferenceCount count,
@@ -755 +723 @@
     ptr = ((psMemBlock* ) vptr) - 1;
 
-    if (checkMemBlock(ptr, __func__)) {
+    if (isBadMemBlock(ptr, __func__)) {
+        (void)p_psMemDecrRefCounter(vptr, filename, lineno);
         memProblemCallback(ptr, file, lineno);
     }
 
-    if (safeThreads) {
-        pthread_mutex_lock(&ptr->refCounterMutex);
-    }
     ptr->refCounter = count;
-    if (safeThreads) {
-        pthread_mutex_unlock(&ptr->refCounterMutex);
-    }
 
     if (count < 1) {
@@ -773 +736 @@
     return vptr;
 }
+#endif
 
 // decrement and return refCounter
-psPtr p_psMemDecrRefCounter(psPtr vptr,
+psPtr p_psMemDecrRefCounter(psPtr ptr,
                             const char *file,
-                            psS32 lineno)
-{
-    if (vptr == NULL) {
+                            unsigned int lineno,
+                            const char *func)
+{
+    if (ptr == NULL) {
         return NULL;
     }
 
-    psMemBlock* ptr = ((psMemBlock* ) vptr) - 1;
-
-    if (checkMemBlock(ptr, __func__) != 0) {
-        memProblemCallback(ptr, file, lineno);
-        return NULL;
-    }
+    psMemBlock *memBlock = ((psMemBlock *) ptr) - 1;
+
+    HANDLE_BAD_BLOCK(memBlock, file, lineno, func);
+
+    // if we have multiple references, just decrement the count and return.
+    if (memBlock->refCounter > 1) {
+        memBlock->refCounter--;
+
+        // Did the user ask to be informed about this deallocation?
+        MUTEX_LOCK(&memBlockListMutex);
+        if (memBlock->id == p_psMemFreeID) {
+            p_psMemFreeID += memFreeCallback(memBlock);
+        }
+        MUTEX_UNLOCK(&memBlockListMutex);
+
+        return ptr;
+    }
+
+    // we can't invoke freeFunc() while we're holding memBlockListMutex as it
+    // may invoke psFree() itself
+    if (memBlock->freeFunc != NULL) {
+        memBlock->freeFunc(ptr);
+    }
+
+    MUTEX_LOCK(&memBlockListMutex);
 
     // Did the user ask to be informed about this deallocation?
-    if (ptr->id == p_psMemFreeID) {
+    if (memBlock->id == p_psMemFreeID) {
         p_psMemFreeID += memFreeCallback(ptr);
     }
 
-    if (safeThreads) {
-        pthread_mutex_lock(&ptr->refCounterMutex);
-    }
-
-    if (ptr->refCounter > 1) {
-        ptr->refCounter--;                 // multiple references, just decrement the count.
-        if (safeThreads) {
-            pthread_mutex_unlock(&ptr->refCounterMutex);
-        }
-
-    } else {
-        if (safeThreads) {
-            pthread_mutex_unlock(&ptr->refCounterMutex);
-        }
-
-        if (ptr->freeFunc != NULL) {
-            ptr->freeFunc(vptr);
-        }
-
-        if (safeThreads) {
-            pthread_mutex_lock(&memBlockListMutex);
-        }
-
-        // cut the memBlock out of the memBlock list
-        if (ptr->nextBlock != NULL) {
-            ptr->nextBlock->previousBlock = ptr->previousBlock;
-        }
-        if (ptr->previousBlock != NULL) {
-            ptr->previousBlock->nextBlock = ptr->nextBlock;
-        }
-        if (lastMemBlockAllocated == ptr) {
-            lastMemBlockAllocated = ptr->nextBlock;
-        }
-
-        if (safeThreads) {
-            pthread_mutex_unlock(&memBlockListMutex);
-        }
-
-        #ifdef PS_MEM_USE_RECYCLE
-        // do we recycle?
-        int bin = getRecycleBin(ptr->userMemorySize);
-        if (bin < N_RECYCLE_BINS && recycleBinNums[bin] < MAX_RECYCLE) {
-            ptr->refCounter = 0;
-            recyclePush(ptr, bin);
-        } else
-            #endif  // #ifdef PS_MEM_USE_RECYCLE
-            {
-                // memory is larger than I want to recycle.
-                #ifdef PS_MEM_DEBUG
-                (void)p_psRealloc(vptr, 0, file, lineno);
-                ptr->previousBlock = NULL;
-                ptr->nextBlock = deadBlockList;
-                if (deadBlockList != NULL) {
-                deadBlockList->previous = ptr;
-            }
-        deadBlockList = ptr;
-        #else // #ifdef PS_MEM_DEBUG
-
-        if (safeThreads) {
-            pthread_mutex_destroy(&ptr->refCounterMutex);
-            }
-            free(ptr);
-            #endif // #else - #ifdef PS_MEM_DEBUG
-
-        }
-
-        vptr = NULL;                       // since we freed it, make sure we return NULL.
-    }
-
-    return vptr;
-}
-
-void psMemSetDeallocator(psPtr ptr,
-                         psFreeFunc freeFunc)
+    // cut the memBlock out of the memBlock list
+    if (memBlock->nextBlock != NULL) {
+        memBlock->nextBlock->previousBlock = memBlock->previousBlock;
+    }
+    if (memBlock->previousBlock != NULL) {
+        memBlock->previousBlock->nextBlock = memBlock->nextBlock;
+    }
+    if (lastMemBlockAllocated == memBlock) {
+        lastMemBlockAllocated = memBlock->nextBlock;
+    }
+
+    MUTEX_UNLOCK(&memBlockListMutex);
+
+    // invoke free only after we've released the block list lock as free()
+    // could take awhile.  We can get away with this as at this point the
+    // memBlock is no longer part of the mem block list.
+    #if defined(PS_MEM_BACKTRACE) && defined(HAVE_BACKTRACE)
+
+    free(memBlock->backtrace);
+    #endif
+
+    free(memBlock);
+
+    // since we freed it, make sure we return NULL.
+    return NULL;
+}
+
+void p_psMemSetDeallocator(psPtr ptr,
+                           psFreeFunc freeFunc,
+                           const char *file,
+                           unsigned int lineno,
+                           const char *func)
 {
     if (ptr == NULL) {
@@ -874 +816 @@
     }
 
-    psMemBlock* PTR = ((psMemBlock* ) ptr) - 1;
-
-    if (checkMemBlock(PTR, __func__) != 0) {
-        memProblemCallback(PTR, __func__, __LINE__);
-    }
-
-    PTR->freeFunc = freeFunc;
-
-}
-
-psFreeFunc psMemGetDeallocator(const psPtr ptr)
+    psMemBlock* memBlock = ((psMemBlock *)ptr) - 1;
+
+    HANDLE_BAD_BLOCK(memBlock, file, lineno, func);
+
+    memBlock->freeFunc = freeFunc;
+}
+
+psFreeFunc p_psMemGetDeallocator(const psPtr ptr,
+                                 const char *file,
+                                 unsigned int lineno,
+                                 const char *func)
 {
     if (ptr == NULL) {
@@ -890 +832 @@
     }
 
-    psMemBlock* PTR = ((psMemBlock* ) ptr) - 1;
-
-    if (checkMemBlock(PTR, __func__) != 0) {
-        memProblemCallback(PTR, __func__, __LINE__);
-    }
-
-    return PTR->freeFunc;
-}
-
-bool psMemCheckType(psDataType type,
-                    psPtr ptr)
-{
-    PS_ASSERT_PTR(ptr, false);
-
-    switch(type) {
-    case PS_DATA_ARRAY:
-        if ( psMemCheckArray(ptr) )
-            return true;
-        else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                    "Incorrect pointer.  Datatypes do not match.\n");
-            break;
-        }
-    case PS_DATA_BITSET:
-        if ( psMemCheckBitSet(ptr) )
-            return true;
-        else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                    "Incorrect pointer.  Datatypes do not match.\n");
-            break;
-        }
-    case PS_DATA_CUBE:
-        if ( psMemCheckCube(ptr) )
-            return true;
-        else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                    "Incorrect pointer.  Datatypes do not match.\n");
-            break;
-        }
-    case PS_DATA_FITS:
-        if ( psMemCheckFits(ptr) )
-            return true;
-        else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                    "Incorrect pointer.  Datatypes do not match.\n");
-            break;
-        }
-    case PS_DATA_HASH:
-        if ( psMemCheckHash(ptr) )
-            return true;
-        else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                    "Incorrect pointer.  Datatypes do not match.\n");
-            break;
-        }
-    case PS_DATA_HISTOGRAM:
-        if ( psMemCheckHistogram(ptr) )
-            return true;
-        else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                    "Incorrect pointer.  Datatypes do not match.\n");
-            break;
-        }
-    case PS_DATA_IMAGE:
-        if ( psMemCheckImage(ptr) )
-            return true;
-        else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                    "Incorrect pointer.  Datatypes do not match.\n");
-            break;
-        }
-    case PS_DATA_KERNEL:
-        if ( psMemCheckKernel(ptr) )
-            return true;
-        else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                    "Incorrect pointer.  Datatypes do not match.\n");
-            break;
-        }
-    case PS_DATA_LINE:
-        if ( psMemCheckLine(ptr) )
-            return true;
-        else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                    "Incorrect pointer.  Datatypes do not match.\n");
-            break;
-        }
-    case PS_DATA_LIST:
-        if ( psMemCheckList(ptr) )
-            return true;
-        else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                    "Incorrect pointer.  Datatypes do not match.\n");
-            break;
-        }
-    case PS_DATA_LOOKUPTABLE:
-        if ( psMemCheckLookupTable(ptr) )
-            return true;
-        else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                    "Incorrect pointer.  Datatypes do not match.\n");
-            break;
-        }
-    case PS_DATA_METADATA:
-        if ( psMemCheckMetadata(ptr) )
-            return true;
-        else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                    "Incorrect pointer.  Datatypes do not match.\n");
-            break;
-        }
-    case PS_DATA_METADATAITEM:
-        if ( psMemCheckMetadataItem(ptr) )
-            return true;
-        else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                    "Incorrect pointer.  Datatypes do not match.\n");
-            break;
-        }
-    case PS_DATA_MINIMIZATION:
-        if ( psMemCheckMinimization(ptr) )
-            return true;
-        else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                    "Incorrect pointer.  Datatypes do not match.\n");
-            break;
-        }
-    case PS_DATA_PIXELS:
-        if ( psMemCheckPixels(ptr) )
-            return true;
-        else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                    "Incorrect pointer.  Datatypes do not match.\n");
-            break;
-        }
-    case PS_DATA_PLANE:
-        if ( psMemCheckPlane(ptr) )
-            return true;
-        else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                    "Incorrect pointer.  Datatypes do not match.\n");
-            break;
-        }
-    case PS_DATA_PLANEDISTORT:
-        if ( psMemCheckPlaneDistort(ptr) )
-            return true;
-        else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                    "Incorrect pointer.  Datatypes do not match.\n");
-            break;
-        }
-    case PS_DATA_PLANETRANSFORM:
-        if ( psMemCheckPlaneTransform(ptr) )
-            return true;
-        else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                    "Incorrect pointer.  Datatypes do not match.\n");
-            break;
-        }
-    case PS_DATA_POLYNOMIAL1D:
-        if ( psMemCheckPolynomial1D(ptr) )
-            return true;
-        else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                    "Incorrect pointer.  Datatypes do not match.\n");
-            break;
-        }
-    case PS_DATA_POLYNOMIAL2D:
-        if ( psMemCheckPolynomial2D(ptr) )
-            return true;
-        else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                    "Incorrect pointer.  Datatypes do not match.\n");
-            break;
-        }
-    case PS_DATA_POLYNOMIAL3D:
-        if ( psMemCheckPolynomial3D(ptr) )
-            return true;
-        else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                    "Incorrect pointer.  Datatypes do not match.\n");
-            break;
-        }
-    case PS_DATA_POLYNOMIAL4D:
-        if ( psMemCheckPolynomial4D(ptr) )
-            return true;
-        else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                    "Incorrect pointer.  Datatypes do not match.\n");
-            break;
-        }
-    case PS_DATA_PROJECTION:
-        if ( psMemCheckProjection(ptr) )
-            return true;
-        else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                    "Incorrect pointer.  Datatypes do not match.\n");
-            break;
-        }
-    case PS_DATA_REGION:
-        if ( psMemCheckRegion(ptr) )
-            return true;
-        else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                    "Incorrect pointer.  Datatypes do not match.\n");
-            break;
-        }
-    case PS_DATA_SCALAR:
-        if ( psMemCheckScalar(ptr) )
-            return true;
-        else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                    "Incorrect pointer.  Datatypes do not match.\n");
-            break;
-        }
-    case PS_DATA_SPHERE:
-        if ( psMemCheckSphere(ptr) )
-            return true;
-        else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                    "Incorrect pointer.  Datatypes do not match.\n");
-            break;
-        }
-    case PS_DATA_SPHEREROT:
-        if ( psMemCheckSphereRot(ptr) )
-            return true;
-        else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                    "Incorrect pointer.  Datatypes do not match.\n");
-            break;
-        }
-    case PS_DATA_SPLINE1D:
-        if ( psMemCheckSpline1D(ptr) )
-            return true;
-        else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                    "Incorrect pointer.  Datatypes do not match.\n");
-            break;
-        }
-    case PS_DATA_STATS:
-        if ( psMemCheckStats(ptr) )
-            return true;
-        else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                    "Incorrect pointer.  Datatypes do not match.\n");
-            break;
-        }
-    case PS_DATA_STRING:
-        if ( psMemCheckString(ptr) )
-            return true;
-        else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                    "Incorrect pointer.  Datatypes do not match.\n");
-            break;
-        }
-    case PS_DATA_TIME:
-        if ( psMemCheckTime(ptr) )
-            return true;
-        else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                    "Incorrect pointer.  Datatypes do not match.\n");
-            break;
-        }
-    case PS_DATA_VECTOR:
-        if ( psMemCheckVector(ptr) )
-            return true;
-        else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                    "Incorrect pointer.  Datatypes do not match.\n");
-            break;
-        }
-    default:
-        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                "Invalid datatype specified.\n");
-    }
-    return false;
+    psMemBlock* memBlock = ((psMemBlock *)ptr) - 1;
+
+    HANDLE_BAD_BLOCK(memBlock, file, lineno, func);
+
+    return memBlock->freeFunc;
 }
 
 bool psMemSetThreadSafety(bool safe)
 {
-    bool out = safeThreads;
+    MUTEX_LOCK(&memBlockListMutex);
+
+    bool oldState = safeThreads;
     safeThreads = safe;
-    return out;
+
+    MUTEX_UNLOCK(&memBlockListMutex);
+
+    return oldState;
 }
 
 bool psMemGetThreadSafety(void)
 {
-    return safeThreads;
-}
-
-bool p_psMemGetPersistent(psPtr vptr)
-{
-    if (vptr == NULL) {
+    MUTEX_LOCK(&memBlockListMutex);
+
+    bool oldState = safeThreads;
+
+    MUTEX_UNLOCK(&memBlockListMutex);
+
+    return oldState;
+}
+
+bool p_psMemGetPersistent(psPtr ptr,
+                          const char *file,
+                          unsigned int lineno,
+                          const char *func)
+{
+    if (ptr == NULL) {
         return NULL;
     }
 
-    psMemBlock* ptr = ((psMemBlock* ) vptr) - 1;
-
-    if (checkMemBlock(ptr, __func__) != 0) {
-        memProblemCallback(ptr, __func__, __LINE__);
-    }
-
-    return ptr->persistent;
-}
-
-void p_psMemSetPersistent(psPtr vptr,
-                          bool value)
-{
-    if (vptr == NULL) {
+    psMemBlock* memBlock = ((psMemBlock *) ptr) - 1;
+
+    HANDLE_BAD_BLOCK(memBlock, file, lineno, func);
+
+    return memBlock->persistent;
+}
+
+void p_psMemSetPersistent(psPtr ptr,
+                          bool value,
+                          const char *file,
+                          unsigned int lineno,
+                          const char *func)
+{
+    if (ptr == NULL) {
         return;
     }
 
-    psMemBlock* ptr = ((psMemBlock* ) vptr) - 1;
-
-    if (checkMemBlock(ptr, __func__) != 0) {
-        memProblemCallback(ptr, __func__, __LINE__);
-    }
-
-    ptr->persistent = value;
+    psMemBlock* memBlock = ((psMemBlock *) ptr) - 1;
+
+    HANDLE_BAD_BLOCK(memBlock, file, lineno, func);
+
+    memBlock->persistent = value;
 }
 
@@ -1221 +905 @@
 size_t psMemStats(const bool print, // print details as they're found?
                   size_t *allocated, // memory that's currently allocated (but not persistent)
-                  size_t *persistent, // persistent memory that's currently allocated
-                  size_t *freelist) // memory that's waiting to be recycled
+                  size_t *persistent) // persistent memory that's currently allocated
 {
     const size_t overhead = sizeof(psMemBlock) + sizeof(psPtr); // overhead on each allocation
@@ -1230 +913 @@
     }
 
-    if (safeThreads) {
-        pthread_mutex_lock(&memBlockListMutex);
-    }
+    MUTEX_LOCK(&memBlockListMutex);
     /*
      * All memory that's currently allocated, whether persistent or not
@@ -1264 +945 @@
         printf("Persistent %6s  %10zd %8zd\n", "", persist, npersist);
     }
-    /*
-     * Count the memory on the free list
-     */
-    size_t freelist_s;
-    if (freelist == NULL) {
-        freelist = &freelist_s;
-    }
-
-    *freelist = 0;
-    int nblock_tot = 0;
-    #ifdef PS_MEM_USE_RECYCLE
-
-    for (int i = 0; recycleBinSize[i] < P_PS_LARGE_BLOCK_SIZE; i++) {
-        size_t bin_contents = 0;
-        size_t nblock = 0;
-        for (const psMemBlock *ptr = recycleMemBlockList[i]; ptr != NULL; ptr = ptr->nextBlock) {
-            nblock++;
-            bin_contents += ptr->userMemorySize + overhead;
-        }
-        *freelist += bin_contents;
-        nblock_tot += nblock;
-
-        if (print) {
-            printf("Freelist   %6d  %10d %8d\n", recycleBinSize[i], bin_contents, nblock);
-        }
-    }
-    #endif // #ifdef PS_MEM_USE_RECYCLE
-
-    if (print) {
-        printf("Freelist   %6s  %10zd %8d\n", "", *freelist, nblock_tot);
-    }
-
-
-    if (safeThreads) {
-        pthread_mutex_unlock(&memBlockListMutex);
-    }
-
-    return *freelist + *allocated + *persistent;
-}
+
+    MUTEX_UNLOCK(&memBlockListMutex);
+
+    return *allocated + *persistent;
+}
+
+int psMemBlockPrint(FILE *output, const psMemBlock *memBlock)
+{
+    return fprintf(output,
+                   "Memory Block ID: %lu @ %p\n"
+                   "\tPrevious Block: %p Next Block: %p\n"
+                   "\tFree function: %p\n"
+                   "\tSize: %zd Reference count: %lu Persistent: %s\n"
+                   "\tPosts: %x %x %x\n"
+                   "\tAllocated in %s at (%s:%d)\n"
+                   "\t\tby Thread ID %lu\n",
+                   memBlock->id, memBlock,
+                   memBlock->previousBlock, memBlock->nextBlock,
+                   memBlock->freeFunc,
+                   memBlock->userMemorySize, memBlock->refCounter, (memBlock->persistent ? "Yes" : "No"),
+                   memBlock->startblock, memBlock->endblock,
+                   *(psU32 *)((char *) (memBlock + 1) + memBlock->userMemorySize),
+                   memBlock->func, memBlock->file, memBlock->lineno, memBlock->tid);
+}