On Tue, Jul 30, 2002 at 11:38:56AM +0200, Elizabeth Mattijsen wrote:
> At 01:56 PM 7/29/02 +0200, Arthur Bergman wrote:
> >>At 10:44 AM 7/29/02 +0100, Tim Bunce wrote:
> >>>"Thread::Needs" isn't a very descriptive name - it's too general.
> >>>Something like "Thread::NeedsModules" would be better.
> >I have been thinking maybe it should be called Thread::Modules;
> >use Thread::Modules qw(foo bar baz); #these must be cloned
> >no Thread::Modules qw(don't need this); #these should not be cloned
>
> Hmmm... it would be nice if you could mark modules not to be
> cloned. Unfortunately, at the current state of things, we can only remove
> module stashes _after_ they have been cloned ;-(
>
> Currently the "no Thread::Needs" removes module names from the hash of
> module names to be kept.
>
> I basically see two ways of dealing with modules in threads currently: an
> aggresive way (removing _everything_ except the stuff you specify should
> stay) and a non-aggresive way (just specifying those modules that you know
> you don't need).
>
> The problem with the first is that it may throw away too much. But you
> will save the most memory that way. The problem with the latter is that
> you only remove the modules of which you _know_ as an author that they're
> loaded. But any modules that have been loaded "under the hood" will remain
> in memory, even if you don't need them.
>
> I think the two approaches should not reside in the same module. I would
> therefore like to suggest the following: Thread::With and Thread::Without.
>
> So:
> Thread::With - mark modules to remain in thread memory
> Thread::Without - mark modules to be removed from thread memory
>
> Or maybe we should _interfix_ the word "Module" here?
> Thread::Module::With - mark modules to remain in thread memory
> Thread::Module::Without - mark modules to be removed from thread memory
>
> Or maybe we should _postfix_ the word "Module"?
> Thread::With::Module - mark modules to remain in thread memory
> Thread::Without::Module - mark modules to be removed from thread memory
>
> The "no" calls of these modules would then simply unmark the modules,
> either for keeping or removing.
>
> I think that would be a cleaner interface. Thread::Without would then be
> for the faint of heart, and Thread::With would be for the more brave and
> savvy developers...
Or generalize it to focus on the 'at clone time hook' nature:
Thread::OnClone delete_modules => qw(Foo::Bar Baz);
which could then easily be extended to support other 'at clone time' actions.
But I'm rather uncomfortable with the global impact this module has
(or seems to from the API, I've not looked at the implementation).
It seems likely to cause problems with module that start their own
private threads and may need to use a module that some other module
has declared it's threads don't need. Can't some lexically scoped
implementation be found?
Tim.
