Date: prev next · Thread: first prev next last
2015 Archives by date, by thread · List index


Hello Kohei,

I hoped very much that you could take a look at this and comment here. Thank you!

6/19/2015 11:42 AM, Kohei Yoshida пишет:
On Wed, 2015-06-17 at 20:20 +1000, Mike Kaganski wrote:
Another crash that I haven't issued to bugzilla (it would only add up
to those already mentioned; don't know if it is already reported):
Copy a cell with comment to clipboard → close original document →
paste to another document.
This is a corner case that is known to create all sorts of issues due to
the way Calc interacts with the system clipboard.  This itself alone is
not good enough evidence that there is a need for redesign with the note
handling.
So, I thought it's  manifestation of obscure interface/protocol of the
objects that leads to broken conditions when implementers use them.
Currently I'm evaluating possible changes to (mainly) ScPostIt that
would make its usage more safe and robust.
Not in my opinion.  Bugs happen, and they need to be fixed.  But I think
you are jumping to a conclusion a bit too quickly.  Seeing a few bugs
(to me 6 bugs is a "few") and thinking that "hey, we need a total
redesign of foo" is what I'm seeing here.  A little premature move.

If you think the way notes are handled is too obscure, you haven't seen
nothing yet. ;-)

Well, yes. :) However, I have some resources to spend on this topic; and I *suppose* that I see a little improvement that could make the usage of the class more intuitive. I suppose I understand *why* the bugs were introduced, and what changes would easily prevent that from happening. Probably I'm wrong; anyway, I ask you and Markus to allow me adding you to reviewers when I have something to review (on gerrit). And I'm sure that if it turns to be unworthy, it will be rejected.


That's a summary of what I'm trying to do. I'm very thankful for
anything you'd like to share on this topic. Thank you.
So, to me, a summary of what you are proposing is that "trying to be
clever with manual memory management is too complicated, let's just
always make copies of objects so that we don't have to think about
this." which is the wrong mindset to have especially when you work on a
very performance sensitive area such as Calc core.

I'm sorry, but you are wrong. That was the first approach that I described, and it is not one that I suggest. The second (preferred) one was to use smart pointers to allow keep sharing objects among owners, while ensuring correct memory management. I think that sharing pointers fits well to shared_ptr intended usage :)

The unfortunate reality is that in Calc core, you *do* need to be smart
about object life cycles to avoid poor run-time performance.  This is
because 1) object creation and deletion is so darn expensive especially
when millions of instances are involved, which the note objects
certainly are, and 2) we've optimized the hell out of the current note
handling to make Calc scale enough to handle hundreds of thousands of
note instances.  This unfortunately means that we do have to take every
opportunities to avoid unnecessary coping of objects, and also means
that (as you see) it has caused unfortunate crasher bugs needing to be
squashed, but that's usually the way the games are played around Calc
core.  I'm not necessarily fond of it, but that's the way it is.

I see, and I understand that there is some inherent complexity. But I don't see how saying "it's too complicated; let it be as it is" helps. Actually, I wanted to get specific comments about my coverage of use cases, and their intended handling.

I want to describe them once again. I think that there are only three distinct types of notes out there: 1. *Ordinary* objects: they belong to one and only one cell in a document. They don't share anything with no other *ordinary* note, nor with *clipboard* notes. But they always share data with *undo* notes. They can be copied to any other type of notes: - to other *ordinary* notes (copy to other cells of same or different document) - then no data should be shared, but fully copied - or maybe a "copy-on-change" logic could be implemented, but now there's no such logic, so *for now*, full copy is just as it is intended to work;
- to *undo* notes - always do shallow copy;
- to *clipboard* notes - then do deep copy; but the copy data should also be able to live without drawing layer. I believe that cut-to-clipboard should be treated uniformly, because there are *undo* objects that share data with original object, so transferring it to clipboard is prone to problems. 2. *Clipboard* notes. They should not share anything with any other note. They should be self-dependent, because otherwise (a) the clipboard contents could change by changing *ordinary* notes after copy-to-clipboard was made; and (b) clipboard should be able to live independently of original document and its objects. They can only be copied to *ordinary* notes, not to *undo* or other *clipboard* notes. When copying to *ordinary* note, deep copy is required, because paste from clipboard can be made multiple times, so independence is required. 3. *Undo* objects: they always represent some state of one specific *ordinary* note; all *undo* notes of one *ordinary* object should share its data. Their life is limited by original document - so no need to do expensive copies to manage memory; shared_ptr could be enough. They should only be copied to *ordinary* note, specifically - to the note of the cell they were originally created for. Shallow copy is required for that. Thus, they should at all times share data with exactly zero or one *ordinary* note (zero if original cell note was removed). Never copy them to *clipboard* or other *undo* notes.

That is what I see in code, and what I suppose is sane usage of the class. From this I draw the conclusion that smart memory management in this topic only depends on object *usage types*, and not on other circumstances. But I may well miss something (I'm sure I do), that's why I ask to point me to the usage I oversee. I want to build logic upon the stated usage modes, to make most optimal memory management automatically (ScPostIt client just need to specify the intended usage, and don't worry how not to mess things), not to make full copies at all times.

I'm not saying that there is not a better way to handle note's life
cycles.  As Markus pointed out, there is an unfortunate complexity in
how the notes are currently handled in large part because two separate
entities - Calc core and the drawing layer - claim ownership and memory
management responsibility to the note objects.

Anyway, I'm very sorry to have to counter your proposal this way.  You
are obviously very brave to want to dive into Calc core and unwind its
huge mess, which should be commended. :-)  But my advice to you is to
spend a bit more time and effort in trying to deepen your understanding
of how Calc interacts with the drawing layer to handle notes, then get
back to the subject to improving the design of notes.  Either way, as
Markus pointed out, incremental approaches would help, not a big-bang
re-design.

I don't see it as "counter-proposal", just necessary seat belts. Thank you for your concerns! I don't rush into breaking everything; actually you see, that I do spend time to understand what goes on with the notes *prior* to making deep changes, including consulting with experienced LO developers. So I do take your advise seriously.

P.S. And I do understand that there need to be a number of unit tests. (It's sad, because I don't like writing them, but they are necessary, so I'll just have to provide them, or you will ban the changes, won't you? :) )

--
Best regards,
Mike Kaganski

Context


Privacy Policy | Impressum (Legal Info) | Copyright information: Unless otherwise specified, all text and images on this website are licensed under the Creative Commons Attribution-Share Alike 3.0 License. This does not include the source code of LibreOffice, which is licensed under the Mozilla Public License (MPLv2). "LibreOffice" and "The Document Foundation" are registered trademarks of their corresponding registered owners or are in actual use as trademarks in one or more countries. Their respective logos and icons are also subject to international copyright laws. Use thereof is explained in our trademark policy.