Skip computing size of child objects

[dfalbel]

This speeds up expanding objects with a lot of self-references for which it's very slow to compute the size of.
Relates to posit-dev/positron#4636
Built on top of #629

[lionel-]

Was the performance problem because we were repeatedly computing the size for all nested objects?

I guess ideally we'd start with the leaves and compute sizes of intermediary nodes from the size of their components, this way the work we're doing is proportional to the size of the tree?

The apporach taken here seems like a reasonable workaround.

[lionel-]

From an API standpoint I think a builder-style approach would be cleaner. For instance adding a compute_size() method that you'd call after new() or from(). By default size would be 0.

Especially since computing the size is the less common case.

[dfalbel]

Makes sense! I'll make this change

[dfalbel]

Actually, the problem is that PositronVariable doesn't hold any reference to the RObject, so we can't compute_size() later. We can do something like

var.size = object.size()

at the call site, what do you think of this approach?

[lionel-]

yep sounds good

[dfalbel]

I didn't do a detailed benchmark but, when we expand the children, we return a list of PositronVariables, one for each child node. In the case of the big model in posit-dev/positron#4636 many of the child nodes seem to include references to the data.frame like eg, the formula, and call objects. This causes the each child node to trigger a large computation for the size.

Since we can't really tell which child object ultimatelly owns the actual data.frame, we would also probably sum(size(child) for child in children) much larger then the object size.

Eg if we try to size each element of a list built like:

x <- list(
  x1 = matrix(1, ncol = 10000, nrow = 10000)
)
for (l in letters) {
  x[[l]] <- x$x1
}
x

Anyway, skipping computing the size of child objects make expanding the model run ins ~300ms while if we compute the size, the total time is at around ~1300ms