RE: On PATH_MAX

[Christopher Nelson]

> > > Indeed. The common term for this relationship is "multithreading".
> > > 
> > > But I think that somehow you and Christopher are talking 
> past each 
> > > other.
> > > 
> > 
> > Yes, exactly.  I mean two threads that don't exist in the 
> same address 
> > space.  In general, you could call them two processes.  So far as a 
> > multithreading app is concerned, there is no possible provision for 
> > confinement, of individual threads -- at least on most modern 
> > processors, so that would be outside my query.
> 
> The problem is that you don't say what's _inside_ your query.
> 
> I could now refine my example, and say that the two threads 
> are _not_ in the same address space, but they agree on a 
> large region of potentially shared memory, and share 
> everything except for a small private core.  Then you might 
> say that you meant everything except multi-threading _and_ my 
> refined example, and then I will refine my example further and so on.
> 
> Eventually we will reach something that will adequately 
> describe the case you mean.  But it is not my responsibility 
> to try to find the boundary by making up one example after 
> another.  It would be much more efficient if you would state 
> the boundary yourself up front.

LOL.  I'm sorry, I thought that I had done that already as part of the
question.  Let me try to be more specific.

Two threads, A and B, who do not have an exclusive communication
arrangement, wish to communicate so that thread B can perform some
service for thread A.  Threads A and B exist in separate address spaces.
Threads A and B do not share the same code base.  Address space is
defined as the set of mappings maintained for the hardware virtual
memory system, representing the maximum amount of memory that a thread
can address.

Now, imagine that Thread A prepares a service request plus data for
Thread B.  Imagine that this request is deliberately crafted to involve
all available address space.  Thread A delivers the request to Thread B.
In order for Thread B to even *consider* the request, it must map the
memory into it's own address space.  Now, let us say that Thread C needs
to communicate with Thread B as well.  The attempt will fail, though,
because Thread B has exhausted all of its address space by accepting the
request from Thread A.  Thus Thread A has denied access to Thread B for
any other thread.

Does this make sense?

-={C}=-