Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > C++ > Heap Manager and new/delete overloading

Reply
Thread Tools

Heap Manager and new/delete overloading

 
 
silver360@gmail.com
Guest
Posts: n/a
 
      12-20-2005
Hello,
I'm trying to create a basic Heap manager and i have some question
about new/delete overloading.
The following code give me this output :
>> $./heap
>> registered : 0x804d098
>> 0x804d008 _Delete unknown block
>> registered : 0x804d138
>> 0x804d008 _Delete unknown block
>> 0x804d098 _Delete ok
>> 0x804d0a8 _Delete unknown block
>> 0x804d138 _Delete ok
>> 0x804d148 _Delete unknown block


Why is the HeapManager::_Delete called to delete objects that weren't
created using HeapManager::_New ?
The only reason I see is that these calls come from my BlocksMap
internals. Is it possible to differenciate delete used by the libstdc++
and delete used by the parts of my programs which are after the
overloading ?
Thanks for any advice
Silver

------------------------------------------------
#include <map>
#include <vector>
#include <stdlib.h>
#include <string>
#include <string.h>
#include <iostream>

using namespace std;

class HeapManager
{
public:
struct BlockDescriptor {
size_t size;
char filename[100];
int line;
};
static HeapManager* pSelf;
~HeapManager ();
void* _New (size_t size, const string& filename, int line);
void _Delete (void* addr);
private:
typedef map<void*, BlockDescriptor*> t_blocksMap;
t_blocksMap BlocksMap;
};

HeapManager::~HeapManager ()
{
vector<t_blocksMap::iterator> toErase;
t_blocksMap::iterator i;
for(i=BlocksMap.begin(); i!=BlocksMap.end(); i++) {
cout << "leak : " << i->second->filename << ":" << i->second->line
<<endl;
free(i->second);
free(i->first);
toErase.push_back(i);
}
for(unsigned int j =0; j<toErase.size(); j++) {
BlocksMap.erase(toErase[j]);
}
}

void* HeapManager::_New(size_t size, const string& filename, int line)
{
if(size <= 0)
return 0;

BlockDescriptor* pDesc =
(BlockDescriptor*)malloc(sizeof(BlockDescriptor));
pDesc->size = size;
strncpy(pDesc->filename,filename.data(),99);
pDesc->filename[99] = '\0';
pDesc->line = line;
void* block = malloc(size);
BlocksMap.insert(make_pair(block,pDesc));
cout << "registered : " << block << endl;
return block;
}

void HeapManager::_Delete(void* addr)
{
if(addr == 0)
return;
cout << addr << " ";
t_blocksMap::iterator i = BlocksMap.find(addr);
if (i != BlocksMap.end()) {
cout << "_Delete ok " << endl;
free(i->second);
BlocksMap.erase(i);
} else {
cout << "_Delete unknown block" << endl;
}
free(addr);
}

void* operator new(size_t size, const string& filename, int line) {
return HeapManager:Self->_New(size, filename, line);
}

void* operator new[](size_t size, const string& filename, int line) {
return HeapManager:Self->_New(size, filename, line);
}

void operator delete (void* addr) {
HeapManager:Self->_Delete(addr);
}

void operator delete [] (void* addr) {
HeapManager:Self->_Delete(addr);
}

#define new new(__FILE__,__LINE__)

HeapManager* HeapManager:Self = NULL;
HeapManager theHeap;

class Foo
{
public:
int bar;
};

int main()
{
HeapManager:Self = &theHeap;
Foo* ptr = new Foo;
Foo* ptr2 = new Foo;
delete ptr;
delete ptr2;


return 0;

}

 
Reply With Quote
 
 
 
 
mlimber
Guest
Posts: n/a
 
      12-20-2005
http://www.velocityreviews.com/forums/(E-Mail Removed) wrote:
> Hello,
> I'm trying to create a basic Heap manager and i have some question
> about new/delete overloading.
> The following code give me this output :
> >> $./heap
> >> registered : 0x804d098
> >> 0x804d008 _Delete unknown block
> >> registered : 0x804d138
> >> 0x804d008 _Delete unknown block
> >> 0x804d098 _Delete ok
> >> 0x804d0a8 _Delete unknown block
> >> 0x804d138 _Delete ok
> >> 0x804d148 _Delete unknown block

>
> Why is the HeapManager::_Delete called to delete objects that weren't
> created using HeapManager::_New ?
> The only reason I see is that these calls come from my BlocksMap
> internals. Is it possible to differenciate delete used by the libstdc++
> and delete used by the parts of my programs which are after the
> overloading ?
> Thanks for any advice
> Silver
>
> ------------------------------------------------
> #include <map>
> #include <vector>
> #include <stdlib.h>
> #include <string>
> #include <string.h>
> #include <iostream>
>
> using namespace std;
>
> class HeapManager
> {
> public:
> struct BlockDescriptor {
> size_t size;
> char filename[100];
> int line;
> };
> static HeapManager* pSelf;
> ~HeapManager ();
> void* _New (size_t size, const string& filename, int line);
> void _Delete (void* addr);
> private:
> typedef map<void*, BlockDescriptor*> t_blocksMap;
> t_blocksMap BlocksMap;
> };
>
> HeapManager::~HeapManager ()
> {
> vector<t_blocksMap::iterator> toErase;
> t_blocksMap::iterator i;
> for(i=BlocksMap.begin(); i!=BlocksMap.end(); i++) {
> cout << "leak : " << i->second->filename << ":" << i->second->line
> <<endl;
> free(i->second);
> free(i->first);
> toErase.push_back(i);
> }
> for(unsigned int j =0; j<toErase.size(); j++) {
> BlocksMap.erase(toErase[j]);
> }
> }
>
> void* HeapManager::_New(size_t size, const string& filename, int line)
> {
> if(size <= 0)
> return 0;
>
> BlockDescriptor* pDesc =
> (BlockDescriptor*)malloc(sizeof(BlockDescriptor));
> pDesc->size = size;
> strncpy(pDesc->filename,filename.data(),99);
> pDesc->filename[99] = '\0';
> pDesc->line = line;
> void* block = malloc(size);
> BlocksMap.insert(make_pair(block,pDesc));
> cout << "registered : " << block << endl;
> return block;
> }
>
> void HeapManager::_Delete(void* addr)
> {
> if(addr == 0)
> return;
> cout << addr << " ";
> t_blocksMap::iterator i = BlocksMap.find(addr);
> if (i != BlocksMap.end()) {
> cout << "_Delete ok " << endl;
> free(i->second);
> BlocksMap.erase(i);
> } else {
> cout << "_Delete unknown block" << endl;
> }
> free(addr);
> }
>
> void* operator new(size_t size, const string& filename, int line) {
> return HeapManager:Self->_New(size, filename, line);
> }
>
> void* operator new[](size_t size, const string& filename, int line) {
> return HeapManager:Self->_New(size, filename, line);
> }
>
> void operator delete (void* addr) {
> HeapManager:Self->_Delete(addr);
> }
>
> void operator delete [] (void* addr) {
> HeapManager:Self->_Delete(addr);
> }
>
> #define new new(__FILE__,__LINE__)
>
> HeapManager* HeapManager:Self = NULL;
> HeapManager theHeap;
>
> class Foo
> {
> public:
> int bar;
> };
>
> int main()
> {
> HeapManager:Self = &theHeap;
> Foo* ptr = new Foo;
> Foo* ptr2 = new Foo;
> delete ptr;
> delete ptr2;
>
>
> return 0;
>
> }


First of all, symbols such as _New and _Delete are illegitimate. All
symbols beginning with an underscore and captial letter are reserved
for use by the implementation. Fix that, try it again to make sure it's
not an implementation conflict, and then we can talk.

Second, you might be interested in this FAQ that discusses overloading
new and delete:

http://www.parashift.com/c++-faq-lit...html#faq-11.14

Third, you might consider using the singleton pattern for your heap
manager rather than that pointer to self trick. See _Modern C++ Design_
chapter 6 for more than you ever wanted to know about C++ singletons.

Cheers! --M

 
Reply With Quote
 
 
 
 
silver360@gmail.com
Guest
Posts: n/a
 
      12-21-2005
Thanks for your answers.

>From what i learnt from the FAQ, if i want that only the objects

created through my new(size_t, const string&, int) call my overloaded
delete, i must redefine delete(void*, const string& , int ).

I rewrote my code with Singleton and correct symbols, but if i redefine
delete(void*, const string&, int), the program crash in dbgheap.c:1252
(_CrtIsValidHeapPointer). If i comment my 'new' delete an keep the old
delete(void*), i get the same output than in the first message.

Silver

----------------
// heap.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

#include <map>
#include <vector>
#include <stdlib.h>
#include <string>
#include <string.h>
#include <iostream>

using namespace std;

class HeapManager
{
public:
struct BlockDescriptor {
size_t size;
char filename[100];
int line;
};
static HeapManager* Instance();

void* myNew (size_t size, const string& filename, int line);
void myDelete (void* addr);
private:
typedef map<void*, BlockDescriptor*> t_blocksMap;
t_blocksMap BlocksMap;
HeapManager();
HeapManager(const HeapManager&);
HeapManager& operator= (const HeapManager&);
~HeapManager ();
};

HeapManager::HeapManager()
{

}

HeapManager::HeapManager(const HeapManager&)
{

}

HeapManager& HeapManager:perator = (const HeapManager&)
{
return *Instance();
}

HeapManager* HeapManager::Instance()
{
static HeapManager inst;
return &inst;
}

HeapManager::~HeapManager ()
{
vector<t_blocksMap::iterator> toErase;
t_blocksMap::iterator i;
for(i=BlocksMap.begin(); i!=BlocksMap.end(); i++) {
cout << "leak : " << i->second->filename << ":" << i->second->line
<<endl;
free(i->second);
free(i->first);
toErase.push_back(i);
}
for(unsigned int j =0; j<toErase.size(); j++) {
BlocksMap.erase(toErase[j]);
}
}

void* HeapManager::myNew(size_t size, const string& filename, int line)
{
if(size <= 0)
return 0;

BlockDescriptor* pDesc =
(BlockDescriptor*)malloc(sizeof(BlockDescriptor));
pDesc->size = size;
strncpy(pDesc->filename,filename.data(),99);
pDesc->filename[99] = '\0';
pDesc->line = line;
void* block = malloc(size);
BlocksMap.insert(make_pair(block,pDesc));
cout << "registered : " << block << endl;
return block;
}

void HeapManager::myDelete(void* addr)
{
if(addr == 0)
return;
cout << addr << " ";
t_blocksMap::iterator i = BlocksMap.find(addr);
if (i != BlocksMap.end()) {
cout << "_Delete ok " << endl;
free(i->second);
BlocksMap.erase(i);
} else {
cout << "_Delete unregistered" << endl;
}
free(addr);
}

void* operator new(size_t size, const string& filename, int line) {
return HeapManager::Instance()->myNew(size, filename, line);
}

void* operator new[](size_t size, const string& filename, int line) {
return HeapManager::Instance()->myNew(size, filename, line);
}

void operator delete(void* addr, const string& filename, int line) {
HeapManager::Instance()->myDelete(addr);
}

void operator delete[](void* addr, const string& filename, int line){
HeapManager::Instance()->myDelete(addr);
}
/*
void operator delete (void* addr) {
HeapManager::Instance()->myDelete(addr);
}

void operator delete [] (void* addr) {
HeapManager::Instance()->myDelete(addr);
}*/

#define new new(__FILE__,__LINE__)



class Foo
{
public:
int bar;
};

int main()
{
Foo* ptr = new Foo;
Foo* ptr2 = new Foo;
delete ptr;
delete ptr2;


return 0;

}

 
Reply With Quote
 
mlimber
Guest
Posts: n/a
 
      12-21-2005
(E-Mail Removed) wrote:
> Thanks for your answers.
>
> >From what i learnt from the FAQ, if i want that only the objects

> created through my new(size_t, const string&, int) call my overloaded
> delete, i must redefine delete(void*, const string& , int ).


Yes, you must do this for exception safety. See the FAQ.

>
> I rewrote my code with Singleton and correct symbols, but if i redefine
> delete(void*, const string&, int), the program crash in dbgheap.c:1252
> (_CrtIsValidHeapPointer). If i comment my 'new' delete an keep the old
> delete(void*), i get the same output than in the first message.


You must not do this. See below.

>
> Silver
>
> ----------------
> // heap.cpp : Defines the entry point for the console application.
> //
>
> #include "stdafx.h"
>
> #include <map>
> #include <vector>
> #include <stdlib.h>


Prefer <cstdlib>

> #include <string>
> #include <string.h>


Prefer <cstring>

> #include <iostream>
>
> using namespace std;
>
> class HeapManager
> {
> public:
> struct BlockDescriptor {
> size_t size;
> char filename[100];
> int line;
> };
> static HeapManager* Instance();
>
> void* myNew (size_t size, const string& filename, int line);
> void myDelete (void* addr);
> private:
> typedef map<void*, BlockDescriptor*> t_blocksMap;
> t_blocksMap BlocksMap;
> HeapManager();
> HeapManager(const HeapManager&);
> HeapManager& operator= (const HeapManager&);
> ~HeapManager ();
> };
>
> HeapManager::HeapManager()
> {
>
> }
>
> HeapManager::HeapManager(const HeapManager&)
> {
>
> }
>
> HeapManager& HeapManager:perator = (const HeapManager&)
> {
> return *Instance();
> }
>
> HeapManager* HeapManager::Instance()
> {
> static HeapManager inst;
> return &inst;
> }
>
> HeapManager::~HeapManager ()
> {
> vector<t_blocksMap::iterator> toErase;
> t_blocksMap::iterator i;
> for(i=BlocksMap.begin(); i!=BlocksMap.end(); i++) {
> cout << "leak : " << i->second->filename << ":" << i->second->line
> <<endl;
> free(i->second);
> free(i->first);
> toErase.push_back(i);
> }
> for(unsigned int j =0; j<toErase.size(); j++) {
> BlocksMap.erase(toErase[j]);
> }
> }
>
> void* HeapManager::myNew(size_t size, const string& filename, int line)
> {
> if(size <= 0)
> return 0;
>
> BlockDescriptor* pDesc =
> (BlockDescriptor*)malloc(sizeof(BlockDescriptor));
> pDesc->size = size;
> strncpy(pDesc->filename,filename.data(),99);
> pDesc->filename[99] = '\0';
> pDesc->line = line;
> void* block = malloc(size);
> BlocksMap.insert(make_pair(block,pDesc));
> cout << "registered : " << block << endl;
> return block;
> }
>
> void HeapManager::myDelete(void* addr)
> {
> if(addr == 0)
> return;
> cout << addr << " ";
> t_blocksMap::iterator i = BlocksMap.find(addr);
> if (i != BlocksMap.end()) {
> cout << "_Delete ok " << endl;
> free(i->second);
> BlocksMap.erase(i);
> } else {
> cout << "_Delete unregistered" << endl;
> }
> free(addr);
> }
>
> void* operator new(size_t size, const string& filename, int line) {
> return HeapManager::Instance()->myNew(size, filename, line);
> }
>
> void* operator new[](size_t size, const string& filename, int line) {
> return HeapManager::Instance()->myNew(size, filename, line);
> }
>
> void operator delete(void* addr, const string& filename, int line) {
> HeapManager::Instance()->myDelete(addr);
> }
>
> void operator delete[](void* addr, const string& filename, int line){
> HeapManager::Instance()->myDelete(addr);
> }
> /*
> void operator delete (void* addr) {
> HeapManager::Instance()->myDelete(addr);
> }
>
> void operator delete [] (void* addr) {
> HeapManager::Instance()->myDelete(addr);
> }*/
>
> #define new new(__FILE__,__LINE__)


Get rid of this macro. See below.

>
>
>
> class Foo
> {
> public:
> int bar;
> };
>
> int main()
> {
> Foo* ptr = new Foo;
> Foo* ptr2 = new Foo;
> delete ptr;
> delete ptr2;
>
>
> return 0;
>
> }


First, regarding the singleton, I'd suggest something along these
lines, though perhaps you need something even more sophisticated in
terms of lifetime management (for which, see _Modern C++ Design_):

template<class T>
class Singleton
{
public:
static T& Instance();
private:
// Disabled functions
Singleton();
Singleton( const Singleton& );
Singleton& operator=( const Singleton& );
Singleton* operator&();
~Singleton();
};

template<class T>
T& Singleton<T>::Instance()
{
static T myObject;
return myObject;
}


class HeapManager
{
// Private ctor/dtor accessible only to friends
friend class Singleton<HeapManager>;
HeapManager() { /* ... */ }
~HeapManager() { /* ... */ }

// Disabled functions for singleton usage
HeapManager( const HeapManager& );
HeapManager& operator=( const HeapManager& );
HeapManager* operator&();

// ...

public:
// ...
};

typedef Singleton<HeapManager> theHeapManager;

Second, regarding the questions from your previous post:

> >> registered : 0x804d098
> >> 0x804d008 _Delete unknown block
> >> registered : 0x804d138
> >> 0x804d008 _Delete unknown block
> >> 0x804d098 _Delete ok
> >> 0x804d0a8 _Delete unknown block
> >> 0x804d138 _Delete ok
> >> 0x804d148 _Delete unknown block

>
> Why is the HeapManager::_Delete called to delete objects that weren't
> created using HeapManager::_New ?


Because in your original code you overload the *global* new and delete
operators. Consequently, your delete operator is being called from
std::string, but your new operator wasn't called from std::string
because the function signatures didn't match and your "#define new"
wasn't in effect yet.

In your updated code, you (rightly) provide a matching delete operator
for your new operator, but you incorrectly invoke the global (i.e., not
your own) delete operator in main(). Also, your updated code won't work
since the file and line numbers must be identical to match your map's
key. With your current operators, you'd need to do something like this
(assuming you get rid of the macro):

Foo* ptr = new("Bob",1) Foo;
Foo* ptr2 = new("Joe",2) Foo;
operator delete(ptr, "Bob",1); // same parameters as above!
operator delete(ptr2, "Joe",2); // same parameters as above!

You'll probably want to change to some other key type than a string/int
pair since the filename/line number thing won't work. In order to get
rid of the ugly syntax in this code, I'll refer you to that same FAQ
again. It describes in detail how to create a custom new/delete pair
and then how to overload the gloabal new/delete operators to use them.

http://www.parashift.com/c++-faq-lit...html#faq-11.14

If you don't understand the FAQ, ask some specific questions. I'm sure
someone here can help.

Cheers! --M

 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
stl heap question: restoring heap validinty after changing 1 element viki C++ 6 06-28-2008 10:12 AM
Heap dump file size vs heap size Michal Slocinski Java 1 03-25-2008 12:54 PM



Advertisments