Removes the memory allocation sanity checks feature (#2218)

* Removes the memory allocation sanity checks feature

* Committing clang-format changes

* Removes zero size checks for H5MM_(c|m)alloc()

* Explicitly return NULL when size == 0 in H5allocate_memory()

* Committing clang-format changes

* Format fix

Co-authored-by: github-actions <41898282+github-actions[bot]@users.noreply.github.com>

8 files changed, 22 insertions, 534 deletions

diff --git a/src/H5.c b/src/H5.c
index 956b60a..dbd109c 100644
--- a/src/H5.c
+++ b/src/H5.c
@@ -540,11 +540,6 @@ H5_term_library(void)
         (void)H5MM_free(tmp_open_stream);
     } /* end while */
 
-#if defined H5_MEMORY_ALLOC_SANITY_CHECK
-    /* Sanity check memory allocations */
-    H5MM_final_sanity_check();
-#endif /* H5_MEMORY_ALLOC_SANITY_CHECK */
-
     /* Reset flag indicating that the library is being shut down */
     H5_TERM_GLOBAL = FALSE;
 
@@ -716,46 +711,6 @@ done:
 } /* end H5get_free_list_sizes() */
 
 /*-------------------------------------------------------------------------
- * Function:    H5get_alloc_stats
- *
- * Purpose:    Gets the memory allocation statistics for the library, if the
- *    --enable-memory-alloc-sanity-check option was given when building the
- *      library.  Applications can check whether this option was enabled by
- *    detecting if the 'H5_MEMORY_ALLOC_SANITY_CHECK' macro is defined.  This
- *    option is enabled by default for debug builds of the library and
- *    disabled by default for non-debug builds.  If the option is not enabled,
- *    all the values returned with be 0.  These statistics are global for the
- *    entire library, but don't include allocations from chunked dataset I/O
- *    filters or non-native VOL connectors.
- *
- * Parameters:
- *  H5_alloc_stats_t *stats;            OUT: Memory allocation statistics
- *
- * Return:    Success:    non-negative
- *        Failure:    negative
- *
- * Programmer:  Quincey Koziol
- *              Saturday, March 7, 2020
- *
- *-------------------------------------------------------------------------
- */
-herr_t
-H5get_alloc_stats(H5_alloc_stats_t *stats /*out*/)
-{
-    herr_t ret_value = SUCCEED; /* Return value */
-
-    FUNC_ENTER_API(FAIL)
-    H5TRACE1("e", "x", stats);
-
-    /* Call the internal allocation stat routine to get the values */
-    if (H5MM_get_alloc_stats(stats) < 0)
-        HGOTO_ERROR(H5E_RESOURCE, H5E_CANTGET, FAIL, "can't get allocation stats")
-
-done:
-    FUNC_LEAVE_API(ret_value)
-} /* end H5get_alloc_stats() */
-
-/*-------------------------------------------------------------------------
  * Function:    H5__debug_mask
  *
  * Purpose:     Set runtime debugging flags according to the string S.  The
@@ -1207,9 +1162,10 @@ H5close(void)
  *
  * Return:
  *
- *      Success:    A pointer to the allocated buffer.
+ *      Success:    A pointer to the allocated buffer or NULL if the size
+ *                  parameter is zero.
  *
- *      Failure:    NULL
+ *      Failure:    NULL (but may also be NULL w/ size 0!)
  *
  *-------------------------------------------------------------------------
  */
@@ -1221,6 +1177,9 @@ H5allocate_memory(size_t size, hbool_t clear)
     FUNC_ENTER_API_NOINIT
     H5TRACE2("*x", "zb", size, clear);
 
+    if (0 == size)
+        return NULL;
+
     if (clear)
         ret_value = H5MM_calloc(size);
     else
diff --git a/src/H5MM.c b/src/H5MM.c
index 4213e0f..aa4c6ce 100644
--- a/src/H5MM.c
+++ b/src/H5MM.c
@@ -13,8 +13,6 @@
 /*-------------------------------------------------------------------------
  *
  * Created:     H5MM.c
- *              Jul 10 1997
- *              Robb Matzke
  *
  * Purpose:     Memory management functions
  *
@@ -35,45 +33,14 @@
 /****************/
 /* Local Macros */
 /****************/
-#if defined H5_MEMORY_ALLOC_SANITY_CHECK
-#define H5MM_SIG_SIZE        4
-#define H5MM_HEAD_GUARD_SIZE 8
-#define H5MM_TAIL_GUARD_SIZE 8
-#define H5MM_BLOCK_FROM_BUF(mem)                                                                             \
-    ((H5MM_block_t *)((void *)((unsigned char *)mem - (offsetof(H5MM_block_t, b) + H5MM_HEAD_GUARD_SIZE))))
-#endif /* H5_MEMORY_ALLOC_SANITY_CHECK */
 
 /******************/
 /* Local Typedefs */
 /******************/
 
-#if defined H5_MEMORY_ALLOC_SANITY_CHECK
-/* Memory allocation "block", wrapped around each allocation */
-struct H5MM_block_t; /* Forward declaration for typedef */
-typedef struct H5MM_block_t {
-    unsigned char
-        sig[H5MM_SIG_SIZE]; /* Signature for the block, to indicate it was allocated with H5MM* interface */
-    struct H5MM_block_t *next; /* Pointer to next block in the list of allocated blocks */
-    struct H5MM_block_t *prev; /* Pointer to previous block in the list of allocated blocks */
-    union {
-        struct {
-            size_t  size;   /* Size of allocated block */
-            hbool_t in_use; /* Whether the block is in use or is free */
-        } info;
-        double _align; /* Align following buffer (b) to double boundary (unused) */
-    } u;
-    unsigned char b[]; /* Buffer for caller (includes header and footer) */
-} H5MM_block_t;
-#endif /* H5_MEMORY_ALLOC_SANITY_CHECK */
-
 /********************/
 /* Local Prototypes */
 /********************/
-#if defined    H5_MEMORY_ALLOC_SANITY_CHECK
-static hbool_t H5MM__is_our_block(void *mem);
-static void    H5MM__sanity_check_block(const H5MM_block_t *block);
-static void    H5MM__sanity_check(void *mem);
-#endif /* H5_MEMORY_ALLOC_SANITY_CHECK */
 
 /*********************/
 /* Package Variables */
@@ -87,152 +54,6 @@ static void    H5MM__sanity_check(void *mem);
 /* Local Variables */
 /*******************/
 
-#if defined H5_MEMORY_ALLOC_SANITY_CHECK
-/* Constant strings for block signature, head & tail guards */
-static const char H5MM_block_signature_s[H5MM_SIG_SIZE]         = {'H', '5', 'M', 'M'};
-static const char H5MM_block_head_guard_s[H5MM_HEAD_GUARD_SIZE] = {'D', 'E', 'A', 'D', 'B', 'E', 'E', 'F'};
-static const char H5MM_block_tail_guard_s[H5MM_TAIL_GUARD_SIZE] = {'B', 'E', 'E', 'F', 'D', 'E', 'A', 'D'};
-
-/* Flag to indicate the the interface has been initialized */
-static hbool_t H5MM_init_s = FALSE;
-
-/* Head of the list of allocated blocks */
-static H5MM_block_t H5MM_block_head_s;
-
-/* Statistics about block allocations */
-static unsigned long long H5MM_total_alloc_bytes_s        = 0;
-static size_t             H5MM_curr_alloc_bytes_s         = 0;
-static size_t             H5MM_peak_alloc_bytes_s         = 0;
-static size_t             H5MM_max_block_size_s           = 0;
-static size_t             H5MM_total_alloc_blocks_count_s = 0;
-static size_t             H5MM_curr_alloc_blocks_count_s  = 0;
-static size_t             H5MM_peak_alloc_blocks_count_s  = 0;
-#endif /* H5_MEMORY_ALLOC_SANITY_CHECK */
-
-#if defined H5_MEMORY_ALLOC_SANITY_CHECK
-
-/*-------------------------------------------------------------------------
- * Function:    H5MM__is_our_block
- *
- * Purpose:     Try to determine if a memory buffer has been allocated through
- *              the H5MM* interface, instead of the system's malloc() routines.
- *
- * Return:      Success:    TRUE/FALSE
- *              Failure:    (Can't fail)
- *
- * Programmer:  Quincey Koziol
- *              Dec 30 2015
- *
- *-------------------------------------------------------------------------
- */
-static hbool_t
-H5MM__is_our_block(void *mem)
-{
-    H5MM_block_t *block = H5MM_BLOCK_FROM_BUF(mem);
-
-    return (0 == HDmemcmp(block->sig, H5MM_block_signature_s, H5MM_SIG_SIZE));
-}
-
-/*-------------------------------------------------------------------------
- * Function:    H5MM__sanity_check_block
- *
- * Purpose:     Check a block wrapper around a buffer to validate it.
- *
- * Return:      N/A (void)
- *
- * Programmer:  Quincey Koziol
- *              Dec 30 2015
- *
- *-------------------------------------------------------------------------
- */
-static void
-H5MM__sanity_check_block(const H5MM_block_t *block)
-{
-    HDassert(block->u.info.size > 0);
-    HDassert(block->u.info.in_use);
-    /* Check for head & tail guards, if not head of linked list */
-    if (block->u.info.size != SIZE_MAX) {
-        HDassert(0 == HDmemcmp(block->b, H5MM_block_head_guard_s, H5MM_HEAD_GUARD_SIZE));
-        HDassert(0 == HDmemcmp(block->b + H5MM_HEAD_GUARD_SIZE + block->u.info.size, H5MM_block_tail_guard_s,
-                               H5MM_TAIL_GUARD_SIZE));
-    }
-}
-
-/*-------------------------------------------------------------------------
- * Function:    H5MM__sanity_check
- *
- * Purpose:     Check a buffer to validate it (just calls
- *              H5MM__sanity_check_block after finding block for buffer)
- *
- * Return:      N/A (void)
- *
- * Programmer:  Quincey Koziol
- *              Dec 30 2015
- *
- *-------------------------------------------------------------------------
- */
-static void
-H5MM__sanity_check(void *mem)
-{
-    H5MM_block_t *block = H5MM_BLOCK_FROM_BUF(mem);
-
-    H5MM__sanity_check_block(block);
-}
-
-/*-------------------------------------------------------------------------
- * Function:    H5MM_sanity_check_all
- *
- * Purpose:     Sanity check all current memory allocations.
- *
- * Return:      N/A (void)
- *
- * Programmer:  Quincey Koziol
- *              Jan  5 2016
- *
- *-------------------------------------------------------------------------
- */
-void
-H5MM_sanity_check_all(void)
-{
-    H5MM_block_t *curr = NULL;
-
-    curr = H5MM_block_head_s.next;
-    while (curr != &H5MM_block_head_s) {
-        H5MM__sanity_check_block(curr);
-        curr = curr->next;
-    } /* end while */
-} /* end H5MM_sanity_check_all() */
-
-/*-------------------------------------------------------------------------
- * Function:    H5MM_final_sanity_check
- *
- * Purpose:     Final sanity checks on memory allocation.
- *
- * Return:      N/A (void)
- *
- * Programmer:  Quincey Koziol
- *              Jan  1 2016
- *
- *-------------------------------------------------------------------------
- */
-void
-H5MM_final_sanity_check(void)
-{
-    HDassert(0 == H5MM_curr_alloc_bytes_s);
-    HDassert(0 == H5MM_curr_alloc_blocks_count_s);
-    HDassert(H5MM_block_head_s.next == &H5MM_block_head_s);
-    HDassert(H5MM_block_head_s.prev == &H5MM_block_head_s);
-#ifdef H5MM_PRINT_MEMORY_STATS
-    HDfprintf(stderr, "%s: H5MM_total_alloc_bytes_s = %llu\n", __func__, H5MM_total_alloc_bytes_s);
-    HDfprintf(stderr, "%s: H5MM_peak_alloc_bytes_s = %zu\n", __func__, H5MM_peak_alloc_bytes_s);
-    HDfprintf(stderr, "%s: H5MM_max_block_size_s = %zu\n", __func__, H5MM_max_block_size_s);
-    HDfprintf(stderr, "%s: H5MM_total_alloc_blocks_count_s = %zu\n", __func__,
-              H5MM_total_alloc_blocks_count_s);
-    HDfprintf(stderr, "%s: H5MM_peak_alloc_blocks_count_s = %zu\n", __func__, H5MM_peak_alloc_blocks_count_s);
-#endif /* H5MM_PRINT_MEMORY_STATS */
-}
-#endif /* H5_MEMORY_ALLOC_SANITY_CHECK */
-
 /*-------------------------------------------------------------------------
  * Function:    H5MM_malloc
  *
@@ -246,10 +67,6 @@ H5MM_final_sanity_check(void)
  *
  * Return:      Success:    Pointer to new memory
  *              Failure:    NULL
- *
- * Programmer:  Quincey Koziol
- *              Nov  8 2003
- *
  *-------------------------------------------------------------------------
  */
 void *
@@ -260,60 +77,7 @@ H5MM_malloc(size_t size)
     /* Use FUNC_ENTER_NOAPI_NOINIT_NOERR here to avoid performance issues */
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
-#if defined H5_MEMORY_ALLOC_SANITY_CHECK
-    /* Initialize block list head singleton */
-    if (!H5MM_init_s) {
-        H5MM_memcpy(H5MM_block_head_s.sig, H5MM_block_signature_s, H5MM_SIG_SIZE);
-        H5MM_block_head_s.next          = &H5MM_block_head_s;
-        H5MM_block_head_s.prev          = &H5MM_block_head_s;
-        H5MM_block_head_s.u.info.size   = SIZE_MAX;
-        H5MM_block_head_s.u.info.in_use = TRUE;
-
-        H5MM_init_s = TRUE;
-    }  /* end if */
-#endif /* H5_MEMORY_ALLOC_SANITY_CHECK */
-
-    if (size) {
-#if defined H5_MEMORY_ALLOC_SANITY_CHECK
-        H5MM_block_t *block;
-        size_t        alloc_size = sizeof(H5MM_block_t) + size + H5MM_HEAD_GUARD_SIZE + H5MM_TAIL_GUARD_SIZE;
-
-        if (NULL != (block = (H5MM_block_t *)HDmalloc(alloc_size))) {
-            /* Set up block */
-            H5MM_memcpy(block->sig, H5MM_block_signature_s, H5MM_SIG_SIZE);
-            block->next            = H5MM_block_head_s.next;
-            H5MM_block_head_s.next = block;
-            block->next->prev      = block;
-            block->prev            = &H5MM_block_head_s;
-            block->u.info.size     = size;
-            block->u.info.in_use   = TRUE;
-            H5MM_memcpy(block->b, H5MM_block_head_guard_s, H5MM_HEAD_GUARD_SIZE);
-            H5MM_memcpy(block->b + H5MM_HEAD_GUARD_SIZE + size, H5MM_block_tail_guard_s,
-                        H5MM_TAIL_GUARD_SIZE);
-
-            /* Update statistics */
-            H5MM_total_alloc_bytes_s += size;
-            H5MM_curr_alloc_bytes_s += size;
-            if (H5MM_curr_alloc_bytes_s > H5MM_peak_alloc_bytes_s)
-                H5MM_peak_alloc_bytes_s = H5MM_curr_alloc_bytes_s;
-            if (size > H5MM_max_block_size_s)
-                H5MM_max_block_size_s = size;
-            H5MM_total_alloc_blocks_count_s++;
-            H5MM_curr_alloc_blocks_count_s++;
-            if (H5MM_curr_alloc_blocks_count_s > H5MM_peak_alloc_blocks_count_s)
-                H5MM_peak_alloc_blocks_count_s = H5MM_curr_alloc_blocks_count_s;
-
-            /* Set buffer to return */
-            ret_value = block->b + H5MM_HEAD_GUARD_SIZE;
-        } /* end if */
-        else
-            ret_value = NULL;
-#else  /* H5_MEMORY_ALLOC_SANITY_CHECK */
-        ret_value = HDmalloc(size);
-#endif /* H5_MEMORY_ALLOC_SANITY_CHECK */
-    }  /* end if */
-    else
-        ret_value = NULL;
+    ret_value = HDmalloc(size);
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5MM_malloc() */
@@ -330,13 +94,8 @@ H5MM_malloc(size_t size)
  *              considered an error condition since allocations of zero
  *              bytes usually indicate problems.
  *
- *
  * Return:      Success:    Pointer to new memory
  *              Failure:    NULL
- *
- * Programmer:	Quincey Koziol
- *              Nov  8 2003
- *
  *-------------------------------------------------------------------------
  */
 void *
@@ -347,16 +106,7 @@ H5MM_calloc(size_t size)
     /* Use FUNC_ENTER_NOAPI_NOINIT_NOERR here to avoid performance issues */
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
-    if (size) {
-#if defined H5_MEMORY_ALLOC_SANITY_CHECK
-        if (NULL != (ret_value = H5MM_malloc(size)))
-            HDmemset(ret_value, 0, size);
-#else  /* H5_MEMORY_ALLOC_SANITY_CHECK */
-        ret_value = HDcalloc((size_t)1, size);
-#endif /* H5_MEMORY_ALLOC_SANITY_CHECK */
-    }  /* end if */
-    else
-        ret_value = NULL;
+    ret_value = HDcalloc(1, size);
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5MM_calloc() */
@@ -377,10 +127,6 @@ H5MM_calloc(size_t size)
  * Return:      Success:    Ptr to new memory if size > 0
  *                          NULL if size is zero
  *              Failure:    NULL (input buffer is unchanged on failure)
- *
- * Programmer:  Robb Matzke
- *              Jul 10 1997
- *
  *-------------------------------------------------------------------------
  */
 void *
@@ -395,35 +141,12 @@ H5MM_realloc(void *mem, size_t size)
         /* Not defined in the standard, return NULL */
         ret_value = NULL;
     else {
-#if defined H5_MEMORY_ALLOC_SANITY_CHECK
-        if (size > 0) {
-            if (mem) {
-                if (H5MM__is_our_block(mem)) {
-                    H5MM_block_t *block    = H5MM_BLOCK_FROM_BUF(mem);
-                    size_t        old_size = block->u.info.size;
-
-                    H5MM__sanity_check(mem);
-
-                    ret_value = H5MM_malloc(size);
-                    H5MM_memcpy(ret_value, mem, MIN(size, old_size));
-                    H5MM_xfree(mem);
-                } /* end if */
-                else
-                    ret_value = HDrealloc(mem, size);
-            }
-            else
-                ret_value = H5MM_malloc(size);
-        }
-        else
-            ret_value = H5MM_xfree(mem);
-#else  /* H5_MEMORY_ALLOC_SANITY_CHECK */
         ret_value = HDrealloc(mem, size);
 
         /* Some platforms do not return NULL if size is zero. */
         if (0 == size)
             ret_value = NULL;
-#endif /* H5_MEMORY_ALLOC_SANITY_CHECK */
-    }  /* end else */
+    }
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5MM_realloc() */
@@ -436,9 +159,6 @@ H5MM_realloc(void *mem, size_t size)
  *
  * Return:      Success:    Pointer to a new string (NULL if s is NULL).
  *              Failure:    NULL
- *
- * Programmer:  Robb Matzke
- *              Jul 10 1997
  *-------------------------------------------------------------------------
  */
 char *
@@ -448,18 +168,9 @@ H5MM_xstrdup(const char *s)
 
     FUNC_ENTER_NOAPI(NULL)
 
-#if defined H5_MEMORY_ALLOC_SANITY_CHECK
-    if (s) {
-        if (NULL == (ret_value = (char *)H5MM_malloc(HDstrlen(s) + 1)))
-            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
-        HDstrcpy(ret_value, s);
-    }
-#else
     if (s)
         if (NULL == (ret_value = HDstrdup(s)))
             HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "string duplication failed")
-#endif
-
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5MM_xstrdup() */
@@ -475,9 +186,6 @@ done:
  *
  * Return:      Success:    Pointer to a new string
  *              Failure:    NULL
- *
- * Programmer:  Robb Matzke
- *              Jul 10 1997
  *-------------------------------------------------------------------------
  */
 char *
@@ -489,14 +197,8 @@ H5MM_strdup(const char *s)
 
     if (!s)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "NULL string not allowed")
-#if defined H5_MEMORY_ALLOC_SANITY_CHECK
-    if (NULL == (ret_value = (char *)H5MM_malloc(HDstrlen(s) + 1)))
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
-    HDstrcpy(ret_value, s);
-#else
     if (NULL == (ret_value = HDstrdup(s)))
         HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "string duplication failed")
-#endif
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -521,9 +223,6 @@ done:
 char *
 H5MM_strndup(const char *s, size_t n)
 {
-#if defined H5_MEMORY_ALLOC_SANITY_CHECK
-    size_t len;
-#endif
     char *ret_value = NULL;
 
     FUNC_ENTER_NOAPI(NULL)
@@ -531,19 +230,8 @@ H5MM_strndup(const char *s, size_t n)
     if (!s)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "NULL string not allowed")
 
-#if defined H5_MEMORY_ALLOC_SANITY_CHECK
-    for (len = 0; len < n && s[len] != '\0'; len++)
-        ;
-
-    if (NULL == (ret_value = H5MM_malloc(len + 1)))
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
-
-    H5MM_memcpy(ret_value, s, len);
-    ret_value[len] = '\0';
-#else
     if (NULL == (ret_value = HDstrndup(s, n)))
         HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "string duplication failed")
-#endif
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -552,18 +240,13 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5MM_xfree
  *
- * Purpose:     Just like free(3) except null pointers are allowed as
- *              arguments, and the return value (always NULL) can be
- *              assigned to the pointer whose memory was just freed:
+ * Purpose:     Just like free(3) except the return value (always NULL) can
+ *              be assigned to the pointer whose memory was just freed:
  *
- *              thing = H5MM_xfree (thing);
+ *                  thing = H5MM_xfree(thing);
  *
  * Return:      Success:    NULL
  *              Failure:    never fails
- *
- * Programmer:  Robb Matzke
- *              Jul 10 1997
- *
  *-------------------------------------------------------------------------
  */
 void *
@@ -572,37 +255,7 @@ H5MM_xfree(void *mem)
     /* Use FUNC_ENTER_NOAPI_NOINIT_NOERR here to avoid performance issues */
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
-    if (mem) {
-#if defined H5_MEMORY_ALLOC_SANITY_CHECK
-        if (H5MM__is_our_block(mem)) {
-            H5MM_block_t *block = H5MM_BLOCK_FROM_BUF(mem);
-
-            /* Run sanity checks on this block and its neighbors */
-            H5MM__sanity_check(mem);
-            H5MM__sanity_check_block(block->next);
-            H5MM__sanity_check_block(block->prev);
-
-            /* Update statistics */
-            H5MM_curr_alloc_bytes_s -= block->u.info.size;
-            H5MM_curr_alloc_blocks_count_s--;
-
-            /* Reset block info */
-            HDmemset(block->sig, 0, H5MM_SIG_SIZE);
-            block->next->prev    = block->prev;
-            block->prev->next    = block->next;
-            block->next          = NULL;
-            block->prev          = NULL;
-            block->u.info.in_use = FALSE;
-
-            /* Free the block (finally!) */
-            HDfree(block);
-        }
-        else
-            HDfree(mem);
-#else  /* H5_MEMORY_ALLOC_SANITY_CHECK */
-        HDfree(mem);
-#endif /* H5_MEMORY_ALLOC_SANITY_CHECK */
-    }  /* end if */
+    HDfree(mem);
 
     FUNC_LEAVE_NOAPI(NULL)
 } /* end H5MM_xfree() */
@@ -616,7 +269,6 @@ H5MM_xfree(void *mem)
  *
  * Return:      Success:    NULL
  *              Failure:    never fails
- *
  *-------------------------------------------------------------------------
  */
 void *
@@ -639,10 +291,6 @@ H5MM_xfree_const(const void *mem)
  *
  * Return:      Success:    pointer to dest
  *              Failure:    NULL
- *
- * Programmer:  Dana Robinson
- *              Spring 2019
- *
  *-------------------------------------------------------------------------
  */
 void *
@@ -665,45 +313,3 @@ H5MM_memcpy(void *dest, const void *src, size_t n)
     FUNC_LEAVE_NOAPI(ret)
 
 } /* end H5MM_memcpy() */
-
-/*-------------------------------------------------------------------------
- * Function:	H5MM_get_alloc_stats
- *
- * Purpose:	Gets the memory allocation statistics for the library, if the
- *	H5_MEMORY_ALLOC_SANITY_CHECK macro is defined.  If the macro is not
- *	defined, zeros are returned.  These statistics are global for the
- *	entire library.
- *
- * Parameters:
- *  H5_alloc_stats_t *stats;            OUT: Memory allocation statistics
- *
- * Return:	Success:	non-negative
- *		Failure:	negative
- *
- * Programmer:  Quincey Koziol
- *              Saturday, March 7, 2020
- *
- *-------------------------------------------------------------------------
- */
-herr_t
-H5MM_get_alloc_stats(H5_alloc_stats_t *stats)
-{
-    FUNC_ENTER_NOAPI_NOERR
-
-#if defined H5_MEMORY_ALLOC_SANITY_CHECK
-    if (stats) {
-        stats->total_alloc_bytes        = H5MM_total_alloc_bytes_s;
-        stats->curr_alloc_bytes         = H5MM_curr_alloc_bytes_s;
-        stats->peak_alloc_bytes         = H5MM_peak_alloc_bytes_s;
-        stats->max_block_size           = H5MM_max_block_size_s;
-        stats->total_alloc_blocks_count = H5MM_total_alloc_blocks_count_s;
-        stats->curr_alloc_blocks_count  = H5MM_curr_alloc_blocks_count_s;
-        stats->peak_alloc_blocks_count  = H5MM_peak_alloc_blocks_count_s;
-    }  /* end if */
-#else  /* H5_MEMORY_ALLOC_SANITY_CHECK */
-    if (stats)
-        HDmemset(stats, 0, sizeof(H5_alloc_stats_t));
-#endif /* H5_MEMORY_ALLOC_SANITY_CHECK */
-
-    FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5MM_get_alloc_stats() */
diff --git a/src/H5MMprivate.h b/src/H5MMprivate.h
index 02c2bb8..130a83e 100644
--- a/src/H5MMprivate.h
+++ b/src/H5MMprivate.h
@@ -13,8 +13,6 @@
 /*-------------------------------------------------------------------------
  *
  * Created:             H5MMprivate.h
- *                      Jul 10 1997
- *                      Robb Matzke
  *
  * Purpose:             Private header for memory management.
  *
@@ -28,29 +26,19 @@
 /* Private headers needed by this file */
 #include "H5private.h"
 
-#if defined H5_MEMORY_ALLOC_SANITY_CHECK
-/*#define H5MM_PRINT_MEMORY_STATS */
-#define H5MM_free(Z) H5MM_xfree(Z)
-#else /* H5_MEMORY_ALLOC_SANITY_CHECK */
 #define H5MM_free(Z) HDfree(Z)
-#endif /* H5_MEMORY_ALLOC_SANITY_CHECK */
 
 /*
  * Library prototypes...
  */
-H5_DLL void  *H5MM_malloc(size_t size) H5_ATTR_MALLOC;
-H5_DLL void  *H5MM_calloc(size_t size) H5_ATTR_MALLOC;
-H5_DLL void  *H5MM_realloc(void *mem, size_t size);
-H5_DLL char  *H5MM_xstrdup(const char *s);
-H5_DLL char  *H5MM_strdup(const char *s);
-H5_DLL char  *H5MM_strndup(const char *s, size_t n);
-H5_DLL void  *H5MM_xfree(void *mem);
-H5_DLL void  *H5MM_xfree_const(const void *mem);
-H5_DLL void  *H5MM_memcpy(void *dest, const void *src, size_t n);
-H5_DLL herr_t H5MM_get_alloc_stats(H5_alloc_stats_t *stats);
-#if defined   H5_MEMORY_ALLOC_SANITY_CHECK
-H5_DLL void   H5MM_sanity_check_all(void);
-H5_DLL void   H5MM_final_sanity_check(void);
-#endif /* H5_MEMORY_ALLOC_SANITY_CHECK */
+H5_DLL void *H5MM_malloc(size_t size) H5_ATTR_MALLOC;
+H5_DLL void *H5MM_calloc(size_t size) H5_ATTR_MALLOC;
+H5_DLL void *H5MM_realloc(void *mem, size_t size);
+H5_DLL char *H5MM_xstrdup(const char *s);
+H5_DLL char *H5MM_strdup(const char *s);
+H5_DLL char *H5MM_strndup(const char *s, size_t n);
+H5_DLL void *H5MM_xfree(void *mem);
+H5_DLL void *H5MM_xfree_const(const void *mem);
+H5_DLL void *H5MM_memcpy(void *dest, const void *src, size_t n);
 
 #endif /* H5MMprivate_H */
diff --git a/src/H5MMpublic.h b/src/H5MMpublic.h
index 36a8293..778c6e3 100644
--- a/src/H5MMpublic.h
+++ b/src/H5MMpublic.h
@@ -13,8 +13,6 @@
 /*-------------------------------------------------------------------------
  *
  * Created:             H5MMpublic.h
- *                      Jul 10 1997
- *                      Robb Matzke
  *
  * Purpose:             Public declarations for the H5MM (memory management)
  *                      package.
@@ -36,11 +34,4 @@ typedef void *(*H5MM_allocate_t)(size_t size, void *alloc_info);
 typedef void (*H5MM_free_t)(void *mem, void *free_info);
 //! <!-- [H5MM_free_t_snip] -->
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifdef __cplusplus
-}
-#endif
 #endif /* H5MMpublic_H */
diff --git a/src/H5Zdevelop.h b/src/H5Zdevelop.h
index a757163..346eb0e 100644
--- a/src/H5Zdevelop.h
+++ b/src/H5Zdevelop.h
@@ -353,15 +353,6 @@ extern "C" {
  *          release builds. Static links to the MSVC CRT can also introduce
  *          new memory allocator state.
  *
- *          Note that the HDF5 library enabled memory sanity checks by default
- *          in debug builds for many years. The heap canaries introduced to
- *          buffers by this mechanism would cause problems when filters
- *          attempted to reallocate these buffers. The sanity checks are no
- *          longer enabled by default in any configuration. When in doubt,
- *          memory sanity checking can be disabled explicitly by configuring
- *          with `--disable-memory-alloc-sanity-check` in the Autotools or
- *          setting `HDF5_MEMORY_ALLOC_SANITY_CHECK` to `OFF` in CMake.
- *
  *          The library does provide H5allocate_memory() and H5free_memory()
  *          functions that will use the library's allocation and free functions,
  *          however using these functions will require linking your filter to
diff --git a/src/H5public.h b/src/H5public.h
index 745cd18..345191c 100644
--- a/src/H5public.h
+++ b/src/H5public.h
@@ -397,19 +397,6 @@ typedef struct H5O_token_t {
 //! <!-- [H5O_token_t_snip] -->
 
 /**
- * Allocation statistics info struct
- */
-typedef struct H5_alloc_stats_t {
-    unsigned long long total_alloc_bytes;        /**< Running count of total # of bytes allocated */
-    size_t             curr_alloc_bytes;         /**< Current # of bytes allocated */
-    size_t             peak_alloc_bytes;         /**< Peak # of bytes allocated */
-    size_t             max_block_size;           /**< Largest block allocated */
-    size_t             total_alloc_blocks_count; /**< Running count of total # of blocks allocated */
-    size_t             curr_alloc_blocks_count;  /**< Current # of blocks allocated */
-    size_t             peak_alloc_blocks_count;  /**< Peak # of blocks allocated */
-} H5_alloc_stats_t;
-
-/**
  * Library shutdown callback, used by H5atclose().
  */
 typedef void (*H5_atclose_func_t)(void *ctx);
@@ -591,27 +578,6 @@ H5_DLL herr_t H5set_free_list_limits(int reg_global_lim, int reg_list_lim, int a
 H5_DLL herr_t H5get_free_list_sizes(size_t *reg_size, size_t *arr_size, size_t *blk_size, size_t *fac_size);
 /**
  * \ingroup H5
- * \brief Gets the memory allocation statistics for the library
- *
- * \param[out] stats Memory allocation statistics
- * \return \herr_t
- *
- * \details H5get_alloc_stats() gets the memory allocation statistics for the
- *          library, if the \c --enable-memory-alloc-sanity-check option was
- *          given when building the library. Applications can check whether
- *          this option was enabled detecting if the
- *          \c H5_MEMORY_ALLOC_SANITY_CHECK macro is defined. This option is
- *          enabled by default for debug builds of the library and disabled by
- *          default for non-debug builds. If the option is not enabled, all the
- *          values returned with be 0. These statistics are global for the
- *          entire library, but do not include allocations from chunked dataset
- *          I/O filters or non-native VOL connectors.
- *
- * \since 1.10.7
- */
-H5_DLL herr_t H5get_alloc_stats(H5_alloc_stats_t *stats);
-/**
- * \ingroup H5
  * \brief Returns the HDF library release number
  *
  * \param[out] majnum The major version number of the library
diff --git a/src/H5trace.c b/src/H5trace.c
index 49500ea..03eaf11 100644
--- a/src/H5trace.c
+++ b/src/H5trace.c
@@ -1543,18 +1543,6 @@ H5_trace_args(H5RS_str_t *rs, const char *type, va_list ap)
 
                 case 'H':
                     switch (type[1]) {
-                        case 'a': /* H5_alloc_stats_t */
-                        {
-                            H5_alloc_stats_t stats = HDva_arg(ap, H5_alloc_stats_t);
-
-                            H5RS_asprintf_cat(rs, "{%llu, %zu, %zu, %zu, %zu, %zu, %zu}",
-                                              stats.total_alloc_bytes, stats.curr_alloc_bytes,
-                                              stats.peak_alloc_bytes, stats.max_block_size,
-                                              stats.total_alloc_blocks_count, stats.curr_alloc_blocks_count,
-                                              stats.peak_alloc_blocks_count);
-                        } /* end block */
-                        break;
-
                         case 'c': /* H5_atclose_func_t */
                         {
                             H5_atclose_func_t cfunc = (H5_atclose_func_t)HDva_arg(ap, H5_atclose_func_t);
diff --git a/src/libhdf5.settings.in b/src/libhdf5.settings.in
index 9f5a58a..dbdbc74 100644
--- a/src/libhdf5.settings.in
+++ b/src/libhdf5.settings.in
@@ -90,7 +90,6 @@ Dimension scales w/ new references: @DIMENSION_SCALES_WITH_NEW_REF@
     Packages w/ extra debug output: @INTERNAL_DEBUG_OUTPUT@
                        API tracing: @TRACE_API@
               Using memory checker: @USINGMEMCHECKER@
-   Memory allocation sanity checks: @MEMORYALLOCSANITYCHECK@
             Function stack tracing: @CODESTACK@
                   Use file locking: @DESIRED_FILE_LOCKING@
          Strict file format checks: @STRICT_FORMAT_CHECKS@