Re: better new delete
cppquester@googlemail.com wrote in news:1188220750.006159.197410
@r29g2000hsg.googlegroups.com:
Hi Folks,
I just had the following idea for opertor new and delete
(I am sure I am not the first one, haven't seen it
so far though):
class A
{
std::vector< int> someData;
static std::stack used;
You need to give a type here.
public:
static void * operator new (size_t size);
static void operator delete (void *p, size_t size);
};
void* A::operator new(size_t sz)
{
void* res;
if( used.size() > 0)
{
res = used.back();
used.pop();
return res;
}
return ::new( sz);
}
void A::operator delete (void *p, size_t sz)
{
someData.clear();
used.push( p);
}
If there are a lot of instances of A to be allocated and freed all the
time,
could (would) this result in a performance gain compared to
the standard new/delete operator as system calls are avoided in most
cases?
Of course it is obvious that there is a certain memory overhead (for
the stack and as all As are never freed), but it looks to me that this
is a very easy way to gain a lot of performance potentially. Am I
missing something?
At first I didn't understand the point of someData, but now I think I
do. What you really want to do with your delete operator is:
void A::operator delete(void *p, size_t sz)
{
static_cast<A*>(p)->~A();
used.push(p);
}
The difference is that you invoke the class' destructor instead of
trying to hand code everything.
The problem with this approach is thread safety. If you are writing a
multi-threaded application, you will need to protect the queuing
operations and that will give you back your OS hit.
This kind of allocator will help you if you have objects which will have
lots of creations a deletes (thousands) in the lifetime of the
application. In that particular case, this type of allocator will help
with memory fragmentation issues and may help in speed. Most of my
programming is multi-threaded, so I don't really see a performance
improvement except for as a whole because the memory isn't quite so
fragmented.
In order to see a performance increase, you will want to be sure that
most of the time, a previously deleted object will be waiting for reuse.
If your program is truly single threaded, you might consider just
reusing the existing object instead of going through a reallocation
cycle.
Hope my observations help in some way,
joe