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.