std::vector<boost::dynamic_bitset<>>unable to free memory about dynamic_bitset

[mclow]

I'm not seeing a memory leak here. What is getMemoryUsage, and what system are you running this on?
My test program (attached) reports that every allocation is paired with a deallocation. (Boost trunk, on Mac OS 10.14)

#include <vector>
#include <iostream>
#include <cstdio>

#include <boost/dynamic_bitset.hpp>

void* operator new (std::size_t count)
{
    void *ptr = malloc(count);
    ::printf ("Allocating %ld bytes at %p\n", count, ptr);
    
    return ptr;
}

void* operator new[]( std::size_t count)
{
    void *ptr = malloc(count);
    ::printf ("Allocating %ld bytes[] at %p\n", count, ptr);
    
    return ptr;
}

void operator delete(void *ptr) throw()
{
    ::printf ("deleting %p\n", ptr);
	free(ptr);
}

void operator delete[](void *ptr) throw()
{
    ::printf ("deleting[] %p\n", ptr);
    free(ptr);
}


int main() {
	{
	std::vector<boost::dynamic_bitset<>> m_nodes;
// 	m_nodes.resize(1000000 + 1);
	m_nodes.resize(10 + 1);
	uint64_t descriptor[4] = {1, 2, 3, 4};
	for(size_t i = 0; i < m_nodes.size(); i++)
		{
		m_nodes[i] = boost::dynamic_bitset<>(descriptor, descriptor + 4);
		}
	::printf("Exiting scope\n");
	}
}

[robot-kimbo]

Hi, thanks for reply.

1. system: ubuntu 18.04, boost 1.66.0 release version, gcc/g++ -7
2. getMemoryUsage() is code of get the program memory, it like command "busybox top"
   here is the linux code of it:
   unsigned long getMemoryUsage()
   {
   unsigned long MEM = 0;
   FILE *f = ::fopen ("/proc/self/stat", "r");
   if (!f) return 0;
   if (!::fscanf(f,
   "%*d %*s %*c %*d %*d %*d %*d %*d%*u %*u %*u %*u %*u %*u %*u%*d %*d %*d %*d %*d %*d %*u %lu", &MEM))
   {
   // Error parsing:
   MEM=0;
   }
   ::fclose (f);
   return MEM/1024/1024;
   }
3. For my test program, you can see after destruct of "std::vector<boost::dynamic_bitset<>>", the memory can not restore "13M", that why I mean "std::vector<boost::dynamic_bitset<>>" has memory leak.

[robot-kimbo]

Hi, I also test std::bitset, the memory of this has not meomory leak, here is the test program

int main()
{
cout << "[ memory start ] " << getMemoryUsage() << std::endl;
{

    std::vector<std::bitset <256> > m_nodes;
    m_nodes.resize(1000000 + 1);
    uint64_t descriptor[4] = {1, 2, 3, 4};
    std::bitset <256> tmp(ULONG_MAX);
    for(size_t i = 0; i < m_nodes.size(); i++)
    {
        m_nodes[i] = tmp;
    }
}
cout << "[ memory end ] "  << getMemoryUsage() << endl;

}

The result is:
[ memory start ] 13
[ memory end ] 13

[swatanabe]

AMDG This is not a bug. It's the normal behavior of memory allocation. Allocators do not return memory to the system when it is deallocated, as that would be horribly inefficient for multiple reasons. Instead, the freed memory will be reused on the next allocation. In Christ, Steven Watanabe

[robot-kimbo]

Ok, got it, thank you very much.