Re: [Boost-users] boost.interprocess dynamic segment size?

From: Ion Gaztañaga (igaztanaga_at_[hidden])
Date: 2008-04-12 16:48:01

Zeljko Vrba wrote:
> On Fri, Apr 11, 2008 at 10:10:28PM +0200, Ion Gaztañaga wrote:
>> it's possible without the collaboration and processes. It's in the to-do 
>> list, but I don't see how could I implement it.
>>
> POSIX shared memory segments can be grown: enlarge the underlying file with
> ftruncate(), then mmap() the new chunk with MAP_FIXED flag at the end of
> existing mapping; this may naturally fail in which case the application is
> out of luck.  (It may help if the initial mapping's starting address is
> chosen smartly in a platform-specific way.)

hat should we do if

> 
> As for growing it atomically, two things are important to note:
> 
>   1) there's always the first process that wants to enlarge it 
>   2) the other processes first must get some knowledge about segment
>      growth -- this does not happen magically, but is somehow transmitted
> 	 by the process that has grown the segment

Ok. One process takes a lock tries to introduce new elements so 
increases the segment and adds more elements in a shared memory list. 
Then unlocks the mutex. New elements allocated in the list can be 
introduced in the front of the list. Other processes, lock the mutex and 
traverse the list and crash. How can we stop all processes to notify 
them that the mapping should be increased? I can guess that we could 
catch SIGSEV, see if new mappings have been added in a shared segment 
information and try to get new mappings map them again, and retry the 
access. But this is easier to say than to write.

> 2) relies on the assumption that a correct program can't know about address
> X until it has malloc()'d it.  With multiple processes this assumption is
> extended to that a process can't know about address X until _some_ process
> has malloc()'d it _and_ communicated it to others.

With malloc all threads have atomically mapped that memory in their 
address space because they shared the address space. Once one threads 
successes doing it, all threads have succeed. Doing this with shared 
memory is a lot more difficult.

> So, for N processes, have in the initial mapping:
> [...]

I think I can find some weaknesses to this process, but I'll try to 
think a bit more about it.

Regards,

Ion