Boost.Interprocess STL containers are
based on the SGI STL library implementation:

Copyright (c) 1996,1997 Silicon Graphics Computer Systems, Inc. Permission
to use, copy, modify, distribute and sell this software and its documentation
for any purpose is hereby granted without fee, provided that the above
copyright notice appear in all copies and that both that copyright notice
and this permission notice appear in supporting documentation. Silicon
Graphics makes no representations about the suitability of this software
for any purpose. It is provided "as is" without express or implied
warranty.

Copyright (c) 1994 Hewlett-Packard Company Permission to use, copy, modify,
distribute and sell this software and its documentation for any purpose
is hereby granted without fee, provided that the above copyright notice
appear in all copies and that both that copyright notice and this permission
notice appear in supporting documentation. Hewlett-Packard Company makes
no representations about the suitability of this software for any purpose.
It is provided "as is" without express or implied warranty.

ABI breaking: Containers don't derive
from allocators, to avoid problems with allocators that might define
virtual functions with the same names as container member functions.
That would convert container functions in virtual functions and might
disallow some of them if the returned type does not lead to a covariant
return. Allocators are now stored as base classes of internal structs.

Fixed bug in deque::clear()
and deque::erase(),
they were declared private.

Fixed bug in deque::erase().
Thanks to Steve LoBasso.

Fixed bug in atomic_dec32(). Thanks to Glenn Schrader.

Improved (multi)map/(multi)set constructors taking iterators. Now those
have linear time if the iterator range is already sorted.

ABI breaking: (multi)map/(multi)set
now reduce their node size. The color bit is embedded in the parent pointer.
Now, the size of a node is the size of 3 pointers in most systems. This
optimization is activated for raw and offset_ptr
pointers.

(multi)map/(multi)set now reuse memory from old nodes in the assignment
operator.

ABI breaking: Implemented node-containers
based on intrusive containers. This saves code size, since many instantiations
share the same algorithms.

Corrected code to be compilable with Visual C++ 8.0.

Added function to zero free memory in memory algorithms and the segment
manager. This function is useful for security reasons and to improve
compression ratios for files created with managed_mapped_file.

Added support for intrusive index types in managed memory segments. Intrusive
indexes save extra memory allocations to allocate the index since with
just one allocation, we allocate room for the value, the name and the
hook to insert the object in the index.

Created new index type: iset_index.
It's an index based on an intrusive set (rb-tree).

Created new index type: iunordered_set_index.
It's an index based on a pseudo-intrusive unordered set (hash table).

ABI breaking: The intrusive index iset_index is now the default index type.

Optimized vector to take advantage of boost::has_trivial_destructor.
This optimization avoids calling destructors of elements that have a
trivial destructor.

Optimized vector to take advantage of has_trivial_destructor_after_move
trait. This optimization avoids calling destructors of elements that
have a trivial destructor if the element has been moved (which is the
case of many movable types). This trick was provided by Howard Hinnant.

Added move semantics to containers. Improves performance when using containers
of containers.

ABI breaking: End nodes of node containers
(list, slist, map/set) are now embedded in the containers instead of
allocated using the allocator. This allows no-throw move-constructors
and improves performance.

ABI breaking: slist
and list containers now have constant-time
size() function. The size of the container is added
as a member.

Win32 version of shared mutexes and shared conditions are based on "spin
and wait" atomic instructions. This leads to poor performance and
does not manage any issues like priority inversions. We would need very
serious help from threading experts on this. And I'm not sure that this
can be achieved in user-level software. Posix based implementations use
PTHREAD_PROCESS_SHARED attribute to place mutexes in shared memory, so
there are no such problems. I'm not aware of any implementation that simulates
PTHREAD_PROCESS_SHARED attribute for Win32. We should be able to construct
these primitives in memory mapped files, so that we can get filesystem
persistence just like with POSIX primitives.

Currently Interprocess only allows char
based names for basic named objects. However, several operating systems
use wchar_t names for resources (mapped
files, for example). In the future Interprocess should try to present a
portable narrow/wide char interface. To do this, it would be useful to
have a boost wstring <-> string conversion utilities to translate
resource names (escaping needed characters that can conflict with OS names)
in a portable way. It would be interesting also the use of boost::filesystem
paths to avoid operating system specific issues.

Boost.Interprocess offers a process-shared
message queue based on Boost.Interprocess
primitives like mutexes and conditions. I would want to develop more mechanisms,
like stream-oriented named fifo so that we can use it with a iostream-interface
wrapper (we can imitate Unix pipes).

C++ needs more complex mechanisms and it would be nice to have a stream
and datagram oriented PF_UNIX-like mechanism in C++. And for very fast
inter-process remote calls Solaris doors is an interesting alternative
to implement for C++. But the work to implement PF_UNIX-like sockets and
doors would be huge (and it might be difficult in a user-level library).
Any network expert volunteer?