operator new overloading and template functions

**anon** · 05-26-2008

I tried a few things. The new[] operator (or deallocation of arrays) seems to be broken:

Code:

#include <iostream>
struct Test
{
    Test() { std::cout << "Test()\n"; }
    ~Test() { std::cout << "~Test()\n"; }
};

int main()
{
    nuiMemoryPool pool(1024);
    try {
        Test* t = new (pool, Wrapper<Test>()) Test[2];
    }
    catch (std::exception& e) {
        std::cout << e.what() << '\n';
    }

};

Outputs:

Test()
Test()
~Test()
~Test()
~Test()
~Test()
~Test()
~Test()

It also seems that if you are out of memory you should throw an exception and not return NULL, otherwise the program just crashes.

The nuiMemoryPoolGuard is either broken or I don't get its usage:

Code:

int main()
{
    nuiMemoryPool pool(1024);
    Test* t = new (pool, Wrapper<Test>()) Test;
    {
        nuiMemoryPoolGuard guard(pool);
        Test* u = new (pool, Wrapper<Test>()) Test;
    }
};

This leaves u undestructed.

And Clear offers other misuse:

Code:

int main()
{
    nuiMemoryPool pool(1024);
    Test* t = new (pool, Wrapper<Test>()) Test;
    {
        nuiMemoryPoolGuard guard(pool);
        Test* u = new (pool, Wrapper<Test>()) Test;
        pool.Clear();
    }
};

This runs destructor three times.

* I typedeffed uint8 as unsigned char.

**CornedBee** · 05-26-2008

A memory pool is not a bulk unloader or some sort of garbage collector, so don't use it like that.

Well, the Apache HTTPD uses them very effectively as such.

**phantomotap** · 05-26-2008

Well, the Apache HTTPD uses them very effectively as such.

I doubt it. They certainly aren't using them more effectively than they could use a real bulk unloader or garbage collector.

Edit: I don't doubt that they may be using a garbage collector effectively, a bulk unloader effectively, or memory pools effectively. I do doubt that they are using a memory pool as a bulk unloader or a garbage collector effectively.

Soma

**CornedBee** · 05-26-2008

Check out the APR Pools. That's what I'm talking about.

**phantomotap** · 05-26-2008

Check out the APR Pools. That's what I'm talking about.

Nearest I can tell they do not provide a hook for garbage collection. It does have a bulk unload mechanism, but it almost certainly is efficient.

Soma

**CornedBee** · 05-26-2008

It's simply a linearly allocated memory area that can be only freed all at once. It does not call object cleanup functions.

I'm not sure what you mean by a hook for garbage collection, or exactly what you consider a bulk unload mechanism.

**phantomotap** · 05-26-2008

Then it seems a bit odd that you should say that Apache uses memory pools effectively as such.

*shrug*

It doesn't matter. Designing a memory pool to partially emulate a garbage collector or a bulk unloader isn't effective because it must waste time and space to provide this behavior. A bulk unloader or a garbage collector could be associated with any memory or any available hook. They can be designed as separate components making each component stronger. They can then be used together by associating a chunk of memory obtained from a memory pool with either component.

Soma

Edit: And a bulk unloader is what you get when you don't have RAII to do cleanup.

**CornedBee** · 05-26-2008

Then it seems a bit odd that you should say that Apache uses memory pools effectively as such.

I know what I mean by those terms. The cognitive dissonance didn't set in until you replied.

**phantomotap** · 05-26-2008

I know what I mean by those terms. The cognitive dissonance didn't set in until you replied.

Then, with that context, I have to ask: why would you find it necessary give the kill function of a memory pool a special name?

Soma

**CornedBee** · 05-26-2008

Now my confusion is complete. Where did I do that?

**krappa** · 05-28-2008

Thanks for trying it out, anon!

Originally Posted by anon

I tried a few things. The new[] operator (or deallocation of arrays) seems to be broken

Thanks for pointing that out. The sizeof(Test) is 1, yet new (pool, Wrapper,Test>()) Test[n] calls the new operator with size n+4, due to 4-byte alignment. In this case, for a 2-Test array, it asks for 6 bytes, i.e. the size for 6 instances of Test.
I haven't found a solution to this yet, I had only tested it with simple types which don't require alignment.
If anyone cares to help me out, I'm still trying to work around this one.

Originally Posted by anon

It also seems that if you are out of memory you should throw an exception and not return NULL, otherwise the program just crashes.

done

Originally Posted by anon

The nuiMemoryPoolGuard is either broken or I don't get its usage:

It was broken, now fixed.

Originally Posted by anon

And Clear offers other misuse:

Code:

int main()
{
    nuiMemoryPool pool(1024);
    Test* t = new (pool, Wrapper<Test>()) Test;
    {
        nuiMemoryPoolGuard guard(pool);
        Test* u = new (pool, Wrapper<Test>()) Test;
        pool.Clear();
    }
};

This runs destructor three times.

Now that the guard is fixed, it runs destructor twice, then, on destruction of the guard, it tries to deallocate at the wrong place and fails an assertion. If the assertion is muted, nothing happens on destruction of the guard.

Thread: operator new overloading and template functions

Thread Tools

Search Thread

Display

Similar Threads

template overloading question

template plus ambiguous overloading!!

Template overloading?

Operator overloading for an inner class of a class template causes compilation error

Operator Overloading and passing a template into COnstructor