L4Re: region mapper/manager concurrency considerations and resource limits

Hello,

Apologies for introducing two potentially separate topics, but they both seem 
to present themselves in my most recent endeavour. In short, I am wondering 
about the following...

What considerations need to be given to concurrency with regard to the use of 
the l4re_rm_attach function and similar functionality? Is access to the region 
mapper/manager from different threads in the same task advisable, are there 
thread safety issues, and if so, can these be sensibly worked around?

(I have observed what seems to be the same address being provided for two 
different dataspaces at the same time, which does not appear to happen when I 
introduce locking around calls to l4re_rm_attach. Are such problems expected 
or could this be some other problem manifesting itself?)

What kind of resource limits apply to L4Re tasks? In my work, I am allocating 
capabilities for objects acting as dataspaces. Things seem to work fairly well 
up to a certain point, and then capability allocation seems to fail, and 
program failure is then not particularly graceful.

(I currently observe that creating 160 threads, each with its own IPC gate 
capability seems to be unproblematic, but more than this will produce errors 
that manifest themselves either in pthread library code or in my own code 
where a critical section is supposed to be enforced.)

I suppose some contextual remarks might be useful. My previous work involved 
providing some simple filesystem-related functionality through filesystem 
servers, where a new server object (exposed via an IPC gate and having its own 
thread) is created for each open file. Some stress testing in a multiprocessor 
environment indicated that various concurrency issues were highly likely to be 
present.

(I also probably didn't provide general enough support for flexpages, but 
since all my "send" flexpages were single machine pages, I don't think this 
would have caused additional problems or confusion.)

Consequently, I migrated the principal mechanisms to my Linux environment and 
wrote a simulation to explore the concurrency situation, identifying and 
hopefully remedying various deficiencies (including more general flexpage 
support). This new endeavour involves bringing this tested functionality back 
into L4Re, wiring it up with the IPC system, and testing using multithreaded 
clients.

I might also ask about support in L4Re for C++ threading constructs. When 
developing my simulation, I decided to use the standard C++ support for 
threading, mutexes, condition variables, and so on, as opposed to using 
pthread functionality. I imagine that C++ library support for these things 
just wraps the pthread functionality, but I wonder if there are not other 
considerations that I might need to be aware of.

Sorry if this is in any way vague, but since there isn't really any discussion 
about system architecture or implementation on this list with respect to these 
technologies (or really any technologies), I find myself experimenting with 
the available software to determine techniques and approaches that I hope will 
be viable. Nevertheless, any constructive remarks or advice would be greatly 
appreciated.

Thanks in advance,

Paul