boost::lockfree::queue doesn't seem to free memory though destructors on every collection objects are invoked

[ableabhijeet@…]

The problem here is, boost::lockfree::queue doesn't free memory once it is allocated. Why freelist nodes are not returned to OS? destructors on individual collection objects are invoked.

#include <iostream>
#include <Windows.h>
#include <boost/thread/thread.hpp>
#include <boost/lockfree/queue.hpp>

using namespace std;
using namespace boost;

struct Record
{
    char str[128];

    Record(const char* rec)
    {
        memset(this->str, 0, sizeof(this->str));
        strcpy_s(this->str, rec);
    }

    ~Record()
    {
        cout << "~Record " << this->str << endl;
    }

    Record& operator= (const Record& rec)
    {
        if (this == &rec)
        {
            return *this;
        }

        memset(this->str, 0, sizeof(this->str));
        strcpy_s(this->str, rec.str);
        return *this;
    }
};

typedef boost::lockfree::queue<Record*, boost::lockfree::fixed_sized<true>> RecordsQueue;

RecordsQueue Records(10000);

class MyClass
{
public:

    void FillThread()
    {
        int i = 0;
        while (true)
        {
            Record *rec = new Record(to_string(i).c_str());
            Records.push(rec);
            i++;
        };
    }

    void ProcessThread()
    {
        while (true)
        {
            Record *rec;
            Records.pop(rec);
            {
                cout << "Record " << rec->str << endl;
                delete rec;
            }
        };
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
    boost::thread* thread1, *thread2;

    MyClass myObj;

    thread1 = new boost::thread(boost::bind(&MyClass::FillThread, myObj));
    HANDLE threadHandle1 = thread1->native_handle();
    SetThreadPriority(threadHandle1, THREAD_PRIORITY_NORMAL);

    boost::this_thread::sleep(boost::posix_time::seconds(1));

    thread2 = new boost::thread(boost::bind(&MyClass::ProcessThread, myObj));
    HANDLE threadHandle2 = thread2->native_handle();
    SetThreadPriority(threadHandle2, THREAD_PRIORITY_NORMAL);

    thread1->join();
    thread2->join();

    return 0;
}

[timblechmann]

http://www.boost.org/doc/libs/1_56_0/doc/html/lockfree/rationale.html#lockfree.rationale.memory_management

[anonymous]

It is okay to reuse the free list block. So when 10000 nodes are allocated, program will continue to iterate from 1 to 10000 nodes. I don't understand Why memory keeps on increasing, memory usage is in GBs!.... I have lockfree::queue of fixed_sized 10000.