Rising memory consumption in this snippet

[peterchen-cp]

I see continuous increase in memory in the following snippet:

   auto root = YAML::Load("{ x : 1 }");
   while(1)
   {
      YAML::Node n;
      n.push_back(root["x"]);
   }

I see that m_pMemory->m_nodes increases with each iteration.

Is this intended behavior?

[jbeder]

Not exactly, but it's probably a consequence of how we treat nodes as references to underlying memory, and how that memory gets managed. Essentially, yaml-cpp has the world's stupidest garbage collector. Could totally be improved :)

[peterchen-cp]

Hm... the thought has been bouncing around my head. I'm not familiar with the details of the YAML specification, but from what I get from the current design, I guess the central issue are cyclic references. Are they the only reason to not use strong references (shared_ptr) to dependent nodes?

To put it differently, is there anything speaking against the following design: node uses shared_ptr<node> to contained nodes (sequence and map elements), and one figures out "something" to cope with cyclic references?

(I'm not even sure that this would be a good idea, I'm just trying to understand the current design / design choices.)

[jbeder]

Yes, I think that'd be possible. The current design makes it so that there's no difference between two "equivalent" nodes, whether one is a "nested" in the other, or not. There's *also* probably a way of solving this without a radical change. In your above example, when "n" goes out of scope, we may be able to see that nothing's referencing it, and clear it from the memory's nodes. It's very subtle, though, so it's probably easy to make a mistake (which is why the current design errors on the side of too much memory).

…

On Sun, Mar 24, 2019 at 2:56 PM peterchen-cp ***@***.***> wrote: Hm... the thought has been bouncing around my head. I'm not familiar with the details of the YAML specification, but from what I get from the current design, I guess the central issue are cyclic references. Are they the only reason to not use strong references (shared_ptr) to dependent nodes? To put it differently, is there anything speaking against the following design: node uses shared_ptr<node> to contained nodes (sequence and map elements), *and* one figures out "something" to cope with cyclic references? (I'm not even sure that this would be a good idea, I'm just trying to understand the current design / design choices.) — You are receiving this because you commented. Reply to this email directly, view it on GitHub <#691 (comment)>, or mute the thread <https://github.com/notifications/unsubscribe-auth/ABAqBrD8qEjh1U_bLkhTMZuhkMqQ3hoFks5vZ9hrgaJpZM4cAhXI> .

[carmeli-tamir]

I gave a shot at a fix, and it seems that this doesn't reproduce the issue while passing the tests.
#775
I'd appreciate an explanation if I missed something.