memory calculation is going negative while using malloc_hook - unix

Question

I want to track memory usage through the the program execution. I have used malloc_hook to capture all the memory related calls. below is the program
long int memory_bytes_hook = 0;
long int peak_memory_hook = 0;
std::mutex memory_mutex_hook;
static void my_init_hook (void);
static void *my_malloc_hook (size_t, const void *);
static void my_free_hook (void*, const void *);
static void* my_realloc_hook (void *ptr, size_t size, const void *caller);
static void *(*old_malloc_hook)(size_t, const void *);
static void (*old_free_hook)(void*, const void *);
static void *(*old_realloc_hook)(void *ptr, size_t size, const void *caller);
static void
my_init_hook (void)
{
__malloc_hook = my_malloc_hook;
__free_hook = my_free_hook;
__realloc_hook = my_realloc_hook ;
}
static void *
my_malloc_hook (size_t size, const void *caller)
{
const std::lock_guard<std::mutex> lock(memory_mutex_hook);
void *result;
__malloc_hook = nullptr;
__free_hook = nullptr ;
__realloc_hook = nullptr ;
result = malloc (size);
memory_bytes_hook += malloc_usable_size(result);
if(peak_memory_hook < memory_bytes_hook )
peak_memory_hook = memory_bytes_hook ;
my_init_hook();
return result;
}
static void* my_realloc_hook (void *ptr, size_t size, const void *caller)
{
const std::lock_guard<std::mutex> lock(memory_mutex_hook);
__malloc_hook = nullptr;
__free_hook = nullptr;//old_free_hook ;
__realloc_hook = nullptr;//old_realloc_hook ;
long int oldSize = malloc_usable_size(ptr);
void *result = realloc(ptr, size);
long int updated_size = malloc_usable_size(result);
memory_bytes_hook += (updated_size - oldSize);
if(peak_memory_hook < memory_bytes_hook )
peak_memory_hook = memory_bytes_hook ;
my_init_hook();
return result;
}
static void
my_free_hook (void *ptr, const void *caller)
{
const std::lock_guard<std::mutex> lock(memory_mutex_hook);
__malloc_hook = nullptr;// old_malloc_hook;
__free_hook = nullptr;// old_free_hook ;
__realloc_hook = nullptr;//old_realloc_hook ;
/* Call recursively */
long int oldSize = malloc_usable_size(ptr);
free (ptr);
memory_bytes_hook -= oldSize;
if(peak_memory_hook < memory_bytes_hook )
peak_memory_hook = memory_bytes_hook ;
my_init_hook();
}
int main(int argc, char** argv)
{
my_init_hook();
... calling other libraries and do lot of operation for couple of hours...
std::cout <<"At last: peak_memory hook: "<< peak_memory_hook << "\t" << " Bytes
allocated: " << memory_bytes_hook << "\n";
return 0;
}
At the end of program execution I am getting negative value of memory_bytes_hook . I did put some logs at intermediate intervals. It was observed that memory_bytes_hook value started reducing after some time and eventually went to negative. That's why It is not because of overflow. I was wondering , What could be other reason of it going negative value. I was hoping, malloc hook would catch all the memory related calls.