Make computational threads leave user interface usable

[Paul Pogonyshev]

Since several versions Emacs has Lisp threads, but they are not used
much, because 1) only one thread executes at any given time; 2)
threads yield control to each other only with explicit (thread-yield)
call or IO blocks. Which means that it is pointless to start a new
thread for heavy computation: it will lock UI until finished anyway.

Attached patch tries to solve point 2 only by making threads
automatically yield control to each other from time to time. The patch
is mainly for discussion.

To see its effect, evaluate this expression:

    (make-thread (lambda ()
                   (dotimes (n 10000000)
                     (when (= (% n 1000000) 0)
                       (message "%s" n)))
                   (message "done")))

In normal Emacs, UI is frozen until the thread completes. You see
messages in the echo area, but that's rather a special case: you
cannot e.g. navigate or type in the current buffer.

With the patch, however, computation thread periodically (and
automatically: no alteration of the expression is needed) yields to UI
thread, leaving Emacs responsive while computation is going on.

There are some problems, though.

* Computation is 3-4 times slower than without auto-yielding. You can
compare to unpatched Emacs or bind `thread-inhibit-auto-yield' to t in
the thread function. This is probably due to the fact it auto-yields
~50 times per second. But on the other hand, does it really have to be
that slow? I don't know much about Emacs internals, maybe someone with
more knowledge can say if it is unavoidable, or yielding is just not
optimized because it is just not done that frequently currently.

* Message buffer contents seems screwed. But this is probably
"normal", as non-main threads shouldn't touch UI as I understand. This
expression is just an example.

* Variable `thread-auto-yield-after' is accessible from Lisp, but
rebinding doesn't take effect immediately. Which is especially bad if
you rebind from nil to a non-nil value.

In general, what are the thoughts about the patch? Does it look
interesting, or is auto-yielding simply out of question?

Paul

P.S. Please CC me on replies, I'm not subscribed to the list.