gcmh VS emacs

cf. https://github.com/emacsmirror/gcmh (the author's [=Andrea Corallo's] Emacs package "GCMH - the Garbage Collector Magic Hack")

A lot of people use way higher values than 800 KB without any problems. As a matter of fact, I've been using 256 MB for a very long time, haven't noticed any issues with it. So I wouldn't call 1 GB madness, it can be perfectly fine in some cases, especially if one uses gcmh, so it has a high chance that GCs will happen when the user doesn't interact with emacs (I also setup emacs to do GC when emacs loses focus. This means that GC pause is invisible most of the time for me). I strongly prefer very rare, short GC pauses than microstuttering all the time. Also, some operations apply a lot of pressure to the memory system, and do hundreds of GCs with the default setting, so most of the CPU time is spent in the GC when these operations run. Increasing gc-cons-threshold makes such operations much faster which means less pauses.

One possible solution is to switch to a LSP approach. You should also take a look at the garbage-collector-magic-hack package: https://github.com/emacsmirror/gcmh

If you experience some lag, my first advice would be to install the GCMH package. It basically changes the garbage-collection rules to ensure that most garbage collection will happen in small bouts while Emacs is idle. After installing it I've never had my Emacs lag on me. This wouldn't address the retina-display issues you mentioned, but I've never experienced those with emacs-plus.

I've seen gcmh recommended as a library that configures the garbage collector for you. Not sure if it is truly a "one size fits all" solution though.

I’d add that for 1) beacon is a good package. For 2), this may be an issue where you have multiple emacs configuration files. This is a serious problem. 3) be patient, and use the magic GC hack. To add to that, you should probably set the GC threshold to be high. 4) projectile? 5)emacs -nw.

The ugly: Handling JSONRPC synchronously. Now that eldoc is in core emacs, LSP is officially supported by core emacs but from this branch https://github.com/emacs-lsp/emacs/tree/json-rpc-29 it looks like core emacs still handles JSONRPC synchronously and blocking.

Without perf profile, it is hard to say. For starters, you may remove lsp-ui. After this: https://emacs-lsp.github.io/lsp-mode/page/performance/ it should be good enough for most use usecases. If you want blazingly fast lsp-mode, you need the LSP Emacs fork https://github.com/emacs-lsp/emacs which is another beast(see https://www.reddit.com/r/emacs/comments/ymrkyn/async_nonblocking_jsonrpc_or_lsp_performance/ as well).

https://emacs-lsp.github.io/lsp-mode/page/performance/ . If this doesn't do, then https://github.com/emacs-lsp/emacs

The other major performance boost is if you're using lsp-mode and this fork. And an lsp-server that sends waaay too much info, I guess.

lsp-mode is async, but sending the messages. If the server is busy and not reading the input messages then lsp-mode will block. The only way ATM to avoid the issue is to use https://github.com/emacs-lsp/emacs .

I disagree. When I am running a compilation (with output being dumped into a visible buffer) + query magit for large commit. Over tramp. Things noticeably freeze. Technically it all is async. Practically, it is implemented as polling things on main thread with some witing happening in non-async fashion.

> For example, querying your compiler for a list of methods that apply to the current object, or a list of functions that start with “Foo” are mostly moving to external processes using LSP as the communication protocol.

That's why we have lsp-bridge and lsp-mode emacs fork :) Both of which build some infrastructure to avoid doing communication work with lsp-mode work in main emacs thread. So, heavy emacs users are building some async machinery which wraps another already async and relatively lightweight protocol, because core emacs facilities can't keep up with it. Architecturally it is kind of insane.

I think, lsp-mode fork is doing the right thing (from practical POV; it goes against "emacs is just an elisp interpreter" ideology though) and hope it gets into core at some point. A better solution would have being having first class async and background threads support at the elisp level. Which would never happen due to elisp messiness.

https://github.com/emacs-lsp/emacs

Locks: https://www.gnu.org/software/emacs/manual/html_node/elisp/Mu...

Semaphores are not there, my mistake; I was thinking about: https://www.gnu.org/software/emacs/manual/html_node/elisp/Co...

That's basically what every other threading library provides in most languages... and it's also what was shown time and again to be very hard to work with directly. Higher-order abstractions are necessary to make parallelism safe and concurrency convenient.

> and atomicity is guaranteed apart from when you use these calls. So you'd never be in a problem state of `setq` failing halfway, for example.

That's true - it looks like Emacs uses a global lock to ensure the atomicity, similarly to what Python does. Also like in Python, you can release that lock from native code (module or core). You cannot touch any interpreter state from other threads, so you need a bit of plumbing to get the results back, but it's possible. I found this: https://github.com/emacs-lsp/emacs/blob/json-rpc/src/json.c very interesting: it's a fork that moves JSONRPC from Lisp to C and out of the main thread. See for example line 1109 and related.

> but threads are pretty useful already if hard to code with.

That's the point: the capabilities are there (mostly), but abstractions are not. Coding with threads, even in the presence of the global lock, is hard, and ensuring correctness is nontrivial. At the very least we should get channels for communication (share by communicating, don't communicate by sharing) between threads and thread pools for executing tasks (like futures in Java or Python, or Task in Elixir). Threads and locks are way too low-level for normal coding. I suspect that's the reason why they're not used more widely, even though they're there for the third(?) release now.

Aside: Racket is actually a nice example of concurrency and parallelism being treated as completely separate concerns. IIRC threads in Racket are call/cc-based green threads, while places are separate instances of the VM that execute in OS-level thread or separate process. Threads provide concurrency and places provide parallelism. It's actually a good thing, I think. Mixing the two is often a major source of errors. Racket also has futures, which are parallel-if-possible primitives that can benefit from parallelism if they don't touch external state - a sort of a middle ground.

In any case: yes, Elisp threads are a good addition to the language, but they alone are not enough to bring concurrency to the masses, so to speak. As a concurrency primitives, and compared to callbacks, they have few advantages and some serious downsides. Emacs still needs a lot of work on the concurrency front. And don't even mention parallelism, that's another can of worms that we don't really need to open :)

In order for that to work, you have to use the json-rpc branch from here: https://github.com/emacs-lsp/emacs .