Question

I’m using debug_new to find memory leaks . I’m deleting my objects and debug_new doesn’t show any trace of me leaking them.

I’ve read several threads on memory fragmentation. But I’m still confused. At this point I’m testing my framework and I’m doing a simple test. I create a new objects like so:

if(sf::Keyboard::isKeyPressed(sf::Keyboard::Space)){
    artemis::Entity& e = world->createEntity();
    e.addComponent(new PositionComponent(posX,posY));
    e.addComponent(new MovementComponent(500,0));
    e.addComponent(new SpriteComponent(TextureManager::getInstance().getTexture("bullet.png")));
    e.addComponent(new ColliderComponent(10,10));
    e.refresh();
    e.setGroup("BULLET");
}

These “components” are managed in a manager called “EntityManager” which reuses the Entity objects but destroys the components when the Entity is send back to the “pool”.
I’ve tested this, and only new entities are made if no available entity is in the pool.

As you can see by the code above. In this simple test the patterns are the same. Yet the allocator keeps using new memory instead of reusing any previously used memory. Creating a few thousands per space-bar hit( per 1/60 a frame) caused my memory to go into the 2 gig spectrum. The components aren’t even that big. For example:

class ColliderComponent : public artemis::Component{

    public:
    int width,height,collidionsId;

    ColliderComponent(int width, int height){
        this->width = width;
        this->height = height;
    }
};

Most components are simple “collections” of ints so far. They are pretty lightweight. It should most definitely reuse some of the previously allocated/released memory. But it just doesn’t.

Maybe I’m missing something. Does anyone have a different idea of what might be going on? And are there any good( free ) memory profilers?
If it’s not because of my components, the flaw must be somewhere else. I simply can not see it at this point and it’s frustrating to say the least.

Edit:
It looks like I was overlooking a different part which caused a major leak. This was obviously a dumb fault by myself.

This was the culprit:
e.setGroup(“BULLET”);

“BULLET” is saved as a pointer ( I should redesign this ) and was overriding pointers to the existing strings at the index of the entity id. I have no idea why I overlooked this but my memory allocation is stable now!

I could have used smart pointers, but so far I’ve been learning a lot from this! I feel like I have achieved something =D

Answer 1

I don’t see an overloaded new operator in ColliderComponent, which leads me to believe you are always allocating from the heap, and giving the memory to your EntityManager. This would definitely look like a leak, that disappears as soon as your EntityManager gets destructed.

Edit: I understand more about how your code works now. Components are not cached by your EntityManager, only the Entity is.