> the main problem has to do with dynamic line sizes

Naw, Scintilla uses a contiguous (gap) buffer to store the data. I believe this 
is what Emacs and other editors do, as it's a fair trade-off for typical text 
file operations.

> Geany/Scintilla doesn't know where the next line will end so it has to scan 
> every character to keep its loaded undo buffer

It does scan every character to locate line-endings, which it caches in a side 
table to make other operations much more efficient. This isn't really related 
to undo buffer.

> I'm not sure why you guys reported that it consumes twice the size of the 
> file size. 

In addition to the side table for the line offset information, it also keeps a 
separate gap buffer which holds a byte for the styling information for each 
character. This is why it's at least twice the size in memory. Also when Geany 
loads a file, I believe it loads it into a string, sends it to Scintilla, and 
then frees it, so it uses 2x the total size there too. In addition, internally 
when Scintilla re-allocates it's internal buffers/tables, it most likely causes 
2x memory overhead (in addition to the gap buffer's extra capacity), so it can 
copy data from old memory to new memory. I think this is what @elextr is 
referring to.

> Not sure if it would be possible to improve geany to using a static line size 
> setting

It wouldn't, and it would also break files with long-lines (ex. minified JS or 
whatever).

> possibly the dynamic undo buffer to ensure memory is not allocated if its not 
> necessary.

It would be possible to optimize the undo buffer by storing the delta/diff 
between the current buffer vs the top of the undo buffer on reload, but it 
would make a different set of tradeoffs for time vs space which may not be as 
optimal for typical text file editing needs.

> It would also be nice to warn the user if Geany is in danger of running out 
> of memory. Then a user could commit changes as necessary and reset the undo 
> buffer while not continuing to consume more memory.

Agree, but there are many cases where it's not possible. Inside GLib when it 
tries to allocate memory, if it fails, it aborts the process, which is a fairly 
reasonable thing to do on decent modern operating systems. It may (or not) be 
possible to gracefully handle OOM conditions inside Scintilla as this PR is 
about though, assuming when the Scintilla call returns, it leaves enough memory 
for Geany to allocate a new dialog window and format a string into it's message.

-- 
You are receiving this because you are subscribed to this thread.
Reply to this email directly or view it on GitHub:
https://github.com/geany/geany/issues/1569#issuecomment-320129497

Reply via email to