At 10:26 PM 9/9/00 -0400, Steven W McDougall wrote:
>RFC 178 proposes a shared data model for Perl6 threads. In a shared
>- globals are shared unless localized
>- file-scoped lexicals are shared unless the thread recompiles the
>- block scoped lexicals may be shared by
> - passing a reference to them
> - closures
> - declaring one subroutine within the scope of another
>In short, lots of stuff is shared, and just about everything can be
I snipped out the rest here, since it's just generally wrong. (Subs don't
need copying, and the optree doesn't currently hold pointers to
lexicals--if it did recursion wouldn't work)
The current "share everything" model perl 5 uses is too expensive. Far too
much is shared, and it means that for safety you have to lock and unlock
everything. Bleah. That costs too much, and you're spending it in the wrong
The alternate perl 5 model (the one IThreads uses) actually clones off the
data when a new thread is created. This also can be too darned expensive in
many cases, since you really only want to access a limited set of data.
(Though if you're careful about when a thread gets created you can dodge a
bunch of this)
Both methods have their advantages. And both have their unneeded costs.
There are even times when they both suck--what happens, for example, if you
want to fire off a thread in a sub that accesses *no* package variables or
external lexical state? It's self-contained, but you pay either way.
What would be best is if we instead tried going with Plan B. I'd write this
up as a formal RFC, but I'm strapped for time, so here's the overview.
Creating a new thread takes two extra sets of flags. They're the same for
lexical and package variables. These flags can be one of:
*) SHARE_ALL. This marks all the whatevers as shared. Perl flags the data
elements as shared, and every access to everything costs. No data copying's
done. Icky, but OK.
*) SHARE_EXPLICIT. When a new thread is created, all the variables marked
as :shared are shared. All the rest are cloned into the new interpreter
*) SHARE_NOCOPY. When a new thread is created, all the variables marked as
:shared are shared. All the rest are *gone*. Poof. You get an empty symbol
table, and no lexical variables are visible. (We may need to provide empty
variables, since there's no autoviv functionality that'll cover us here)
Maybe files are shared across threads, but that's it.
When a non-shared variable is put into a shared variable, it becomes
shared. So if you have this:
my @bar : shared;
push @bar, \$foo;
then $foo becomes shared. Yes, we do walk references and do propagage
sharedness through containers, so sticking a ref in a shared container
might get you a pause. Tough noogies, you asked for it. :) (We could warn
with -w on this)
What the default is would be up in the air. Personally, I like
share_nocopy, but others might prefer other things.
--------------------------------------"it's like this"-------------------
Dan Sugalski even samurai
[EMAIL PROTECTED] have teddy bears and even
teddy bears get drunk