unofficial mirror of emacs-devel@gnu.org 
 help / color / mirror / code / Atom feed
From: Stefan Monnier <monnier@iro.umontreal.ca>
To: Giuseppe Scrivano <gscrivano@gnu.org>
Cc: emacs-devel@gnu.org
Subject: Re: multi-threaded Emacs
Date: Sat, 29 Nov 2008 17:21:51 -0500	[thread overview]
Message-ID: <jwv4p1qyzcc.fsf-monnier+emacs@gnu.org> (raw)
In-Reply-To: <873ahant5l.fsf@master.homenet> (Giuseppe Scrivano's message of "Sat, 29 Nov 2008 22:01:26 +0100")

>> - handling thread-specific data: gcprolist, mark_byte_stack, and things
>> like that.  You've tackled this one.  I don't find your solution very
>> elegant, but I can't think of a much better one, unless pthreads does
>> provide some kind of thread-specific variables.  I guess the only
>> improvement is to put those vars together, so we have an array of
>> structs (that then contain gcprolist, and mark_byte_stack fields)
>> rather than several arrays.  And then define `gcprolist' as a macro
>> that expands into "thread_data[current_thread()].gcprolist", so as to
>> reduce the amount of source-code changes.

> Yes, we can put thread-specific data together in a struct; what about
> buffer data?  `current_buffer' must be different for every thread so as
> many other global variables, should it be defined in the same
> thread_data struct?

Yes, some additional variables will need to be made
thread-specific, indeed.  For some of them, we may be able to simply use
dynamic-scoping (once this is implemented).

>> - dynamic-scoping: your handling of specpdl is naive and
>> fundamentally flawed.  For multithreading, we will have to completely
>> change the implementation technique of dynamic-scoping.

> I know but it was the easier way to have quickly a working
> proof-of-concept as I concentrated my efforts mainly on the syntax.
> Do you have any idea about how dynamic scoping should be handled in a
> multi-threaded environment?

Currently, we basically use the following implementation:

   (defun get-var (sym)
     (symbol-value 'var))
   (defun set-var (sym val)
     (setf (symbol-value 'var) val))
   (defmacro let-var (sym val body)
     `(let ((oldval (get-var ,sym)))
        (set-var ,sym ,val)
        (unwind-protect
            ,body
          (set-var ,sym ,val))))

we could instead use something like

   (defun get-var (sym)
     (cdr (assq sym specpdl)))
   (defun set-var (sym val)
     (set-cdr (assq sym specpdl) val))
   (defmacro let-var (sym val body)
     `(let ((oldpdl specpdl))
        (push (cons ,sym ,val) specpdl)
        (unwind-protect
            ,body
          (setq specpdl oldpdl))))

where specpdl is a per-thread variable.  Or

   (defun get-var (sym)
     (cdr (assq thread (symbol-value sym))))
   (defun set-var (sym val)
     (set-cdr (assq thread (symbol-value sym)) val))
   (defmacro let-var (sym val body)
     `(let ((oldval (get-var ,sym)))
        (set-var ,sym ,val)
        (unwind-protect
            ,body
          (set-var ,sym ,val))))

This latter one might be the simplest: it basically adapts the
notion of buffer-local/frame-local/terminal-local to also include
thread-local.  Currently, only one form of locality is supported at
a time (a var can't be both buffer-local and terminal-local), so this
would need to be worked out (frame-local and buffer-local was allowed
in Emacs-21 but its behavior was not clearly defined and had corner
case bugs).

Clearly this can have drastic consequences w.r.t the performance of
`get-var'.  And its interaction with buffer-local bindings needs to be
thought through.  We mostly want to handle the default-directory case
where a variable is local to every buffer and can also be
dynamically bound.

>> - synchronization to access all the global variables/objects.
>> You haven't yet have time to tackle this (other than in `put', it
>> seems), and it's going to be difficult.

> Why do you think that a global lock (or several ones for separate kind
> of data) will not be enough?  It is not easy but I think it can be done
> in a reasonable time without many troubles.

I'm not sure what you mean by "a global lock".  The question is not only
how many locks, but what they protect.  My proposal further down to
start with "only one thread active at a time" is what I'd call "a global
lock".

>> - concurrent GC (later to be refined to parallel concurrent GC ;-).
>> - redisplay in its own thread (later to be refined to one redisplay
>> thread per terminal, then per frame, then per window ;-).

> I think that this is the most difficult part, a new GC and how handle
> redisplay.

Actually, a new GC is not indispensable.  We will most likely start by
keeping the same GC and just stopping all threads when a GC is needed.

>> A first step will be to restrict the implementation such that there's no
>> parallelism: only one thread executes at any given time (i.e. have
>> a single lock and have all thread grab the lock before doing any actual
>> work).
> IMHO it is better to avoid this middle solution and try to solve
> directly the problem, it will not give real benefits and having only one
> thread executes at a given time can be done differently, like saving and
> restoring the thread call stack.

Experience shows that making a program concurrent (or even parallel)
requires a lot of work and can only be done step by step, and after each
step appears new opportunities.  I don't see my proposal as
a "middle" solution.  It's just one step out of many.  Before knowing
what other steps are most needed, we will need experience using those
primitives in Elisp packages, so the most pressing step is to provide
the primitives in a robust way.

> Real threads will not suffer I/O bound operations and Emacs will be
> able to use more cores at the same time, if needed.

That can come later.  Parallelism is important, but it will require
changes in Elisp packages, so the first thing is to provide facilities
so that Elisp packages can start using concurrency.  Then we can worry
about taking advantage of parallelism.

If we want to get parallelism without changing Elisp packages, then
I can only see two places where we could do that:
- parallelise redisplay.
- make the GC concurrent (and/or parallel).
Both are pretty difficult.  Interestingly, they're also mostly
orthogonal to the issue of providing concurrency primitives to Elisp.


        Stefan




  reply	other threads:[~2008-11-29 22:21 UTC|newest]

Thread overview: 89+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2008-11-29 13:32 multi-threaded Emacs Giuseppe Scrivano
2008-11-29 20:26 ` Stefan Monnier
2008-11-29 21:01   ` Giuseppe Scrivano
2008-11-29 22:21     ` Stefan Monnier [this message]
2008-11-30 11:35       ` Giuseppe Scrivano
2008-11-30 21:46         ` Stefan Monnier
2008-11-30 22:25           ` Giuseppe Scrivano
2008-11-30 23:03             ` Stefan Monnier
2008-11-30 23:30               ` Giuseppe Scrivano
2008-12-01  3:37                 ` Stefan Monnier
2008-12-06 22:50           ` Tom Tromey
2008-12-07  3:31             ` Stefan Monnier
2008-11-29 22:06   ` Tom Tromey
2008-11-30 16:43 ` Richard M Stallman
2008-11-30 17:34   ` Giuseppe Scrivano
2008-11-30 21:51     ` Stefan Monnier
2008-11-30 22:10       ` Giuseppe Scrivano
2008-11-30 22:20     ` Miles Bader
2008-11-30 23:09       ` Stefan Monnier
2008-11-30 23:09       ` Giuseppe Scrivano
2008-12-01  0:10         ` Chetan Pandya
2008-12-01  3:55         ` Stefan Monnier
2008-12-01 14:06     ` Richard M Stallman
2008-12-01 18:57       ` Giuseppe Scrivano
2008-12-01 20:34         ` Stefan Monnier
2008-12-01 22:41           ` joakim
2008-12-02 16:02         ` Richard M Stallman
2008-12-02 22:22           ` Stefan Monnier
2008-12-02 22:41             ` Giuseppe Scrivano
2008-12-03  2:17               ` Stefan Monnier
2008-12-03 18:26                 ` Giuseppe Scrivano
2008-12-03 20:14                   ` Stefan Monnier
2008-12-05  2:59                     ` Richard M Stallman
2008-12-05  7:40                       ` Giuseppe Scrivano
2008-12-05  8:20                         ` Miles Bader
2008-12-05  9:42                           ` Paul R
2008-12-05 10:10                             ` Eli Zaretskii
2008-12-05 10:35                               ` Paul R
2008-12-05 11:02                           ` Helmut Eller
2008-12-05 15:39                             ` Stefan Monnier
2008-12-05 16:22                             ` Ted Zlatanov
2008-12-05 16:57                             ` Tom Tromey
2008-12-06  4:41                               ` Miles Bader
2008-12-06  7:44                               ` Helmut Eller
2008-12-06 22:31                                 ` Stefan Monnier
2008-12-06  8:30                         ` Richard M Stallman
2008-12-05 15:36                       ` Stefan Monnier
2008-12-06 19:25                         ` Richard M Stallman
2008-12-06 22:41                           ` Stefan Monnier
2008-12-06 23:41                             ` Giuseppe Scrivano
2008-12-07 20:51                               ` Stefan Monnier
2008-12-07 23:51                                 ` Giuseppe Scrivano
2008-12-08  3:06                                   ` Chetan Pandya
2008-12-08 15:50                                   ` Stefan Monnier
2008-12-07 16:02                             ` Richard M Stallman
2008-12-07 20:52                               ` Stefan Monnier
2008-12-07 16:15                           ` Giuseppe Scrivano
2008-12-08 18:26                             ` Richard M Stallman
2008-12-08 19:49                               ` Giuseppe Scrivano
2008-12-09  2:15                                 ` dhruva
2008-12-09  2:49                                   ` Stephen J. Turnbull
2008-12-09  2:53                                     ` dhruva
2008-12-09  9:36                                     ` Andreas Schwab
2008-12-09 17:26                                 ` Richard M Stallman
2008-12-09 19:10                                   ` Giuseppe Scrivano
2008-12-10 18:18                                     ` Richard M Stallman
2008-12-10 18:18                                     ` Richard M Stallman
2008-12-09 19:40                                   ` Stefan Monnier
2008-12-10 18:18                                     ` Richard M Stallman
2008-12-11  1:59                                       ` Stefan Monnier
2008-12-11 14:41                                         ` Ted Zlatanov
2008-12-11 18:30                                           ` Stefan Monnier
2008-12-11 18:42                                             ` Ted Zlatanov
2008-12-11 19:01                                               ` Paul R
2008-12-11 20:53                                               ` Stefan Monnier
2008-12-12 19:03                                                 ` Giuseppe Scrivano
2008-12-13  3:08                                                   ` Stefan Monnier
2008-12-11 19:07                                         ` Paul R
2008-12-11 20:54                                           ` Stefan Monnier
2008-12-05  2:59                   ` Richard M Stallman
2008-12-05 15:40                     ` Stefan Monnier
2008-12-02 23:10             ` Florian Beck
2008-11-30 22:17   ` Miles Bader
2008-11-30 16:44 ` Richard M Stallman
  -- strict thread matches above, loose matches on Subject: below --
2008-12-03  7:59 Re[2]: " ak70
2008-12-04  8:45 ` Richard M Stallman
     [not found]   ` <87prk8mhg9.fsf@vanilla.net.mt>
     [not found]     ` <E1L8ZUB-0002x3-VT@fencepost.gnu.org>
2008-12-05 13:27       ` Li Lin
     [not found]         ` <87prk64ilv.fsf@vanilla.net.mt>
2008-12-05 18:37           ` Giuseppe Scrivano
2008-12-06 21:58             ` Magnus Henoch
2008-12-04 13:21 ` Stefan Monnier

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

  List information: https://www.gnu.org/software/emacs/

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=jwv4p1qyzcc.fsf-monnier+emacs@gnu.org \
    --to=monnier@iro.umontreal.ca \
    --cc=emacs-devel@gnu.org \
    --cc=gscrivano@gnu.org \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
Code repositories for project(s) associated with this public inbox

	https://git.savannah.gnu.org/cgit/emacs.git

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).