Hi Stefan,

I think you got me on the right track there:

> So I assume that means the render clients are leaking. Most likely this is 
> due to missing sync() on some objects. Try setting the 100 to 10 in 
> Object::notifyNewHeadVersion and see who is throwing an assertion.

After setting the value to 10, I'm getting an assertion on the root
node object, which I'm keeping in the FrameData. It looks like all the
previous versions are still kept alive until the assertion is thrown.
I'm pretty sure this happens when deserializing a graph node object,
so for reference here's my implementation for a general graph node,
like the root element:

        void DistNode::deserialize(co::DataIStream &is, const uint64_t 
dirtyBits)
        {
                DistSerializable::deserialize( is, dirtyBits );

                if( dirtyBits & DIRTY_CHILDREN )
                {
                        // Obtain Class and ID of LeftChild
                        Class leftChildClass;
                        is >> leftChildClass;
                        co::base::UUID leftChildID;
                        is >> leftChildID;
                        is >> _leftChildVersion;

                        // Obtain Class and ID of RightSibling
                        Class rightSiblingClass;
                        is >> rightSiblingClass;
                        co::base::UUID rightSiblingID;
                        is >> rightSiblingID;
                        is >> _rightSiblingVersion;

                        // Instantiate objects for LeftChild and Right Sibling
                        // And map LeftChild and RightSibling to master ID
                        co::LocalNodePtr localNode = getLocalNode();

                        if(leftChildID != co::base::UUID(0))
                        {
                                DistNode *newLeftChild = 
getInstanceOf(leftChildClass);
                                localNode->mapObject(newLeftChild, leftChildID);
                                if(LeftChild)
                                        if(LeftChild->isAttached())
                                        {
                                                
localNode->releaseObject(LeftChild);
                                        }
                                LeftChild = newLeftChild;
                        }
                        else
                                LeftChild = NULL;

                        if(rightSiblingID != co::base::UUID(0))
                        {
                                DistNode *newRightSibling = 
getInstanceOf(rightSiblingClass);
                                localNode->mapObject(newRightSibling, 
rightSiblingID);
                                if(RightSibling)
                                        if(RightSibling->isAttached())
                                        {
                                                
localNode->releaseObject(RightSibling);
                                        }
                                RightSibling = newRightSibling;
                        }
                        else
                                RightSibling = NULL;
                }
                if( dirtyBits & DIRTY_NAME )
                {
                        is >> _name;
                }
        }

For testing purpose I added the releaseObject() call. However I'm not
really sure if this is really needed, or if something else is missing
here...
I still seem to be somewhat lost... Is there anything else I have to
take care of before I map my new instances, or does Equalizer manage
everything by itself?

Thanks for all your input so far, you have been a great help Stefan. :)

Cheers,
Matteo

_______________________________________________
eq-dev mailing list
[email protected]
http://www.equalizergraphics.com/cgi-bin/mailman/listinfo/eq-dev
http://www.equalizergraphics.com

Reply via email to