| Home | Libraries | People | FAQ | More

## Acknowledgements, notes and links

### Thanks to...

#### People

Many people have contributed with ideas and revisions, so this is the place to thank them:

- Thanks to all people who have shown interest in the library and have downloaded and tested the snapshots.
- Thanks to Francis Andre and Anders Hybertz for their ideas and suggestions. Many of them are not implemented yet but I hope to include them when library gets some stability.
- Thanks to Matt Doyle, Steve LoBasso, Glenn Schrader, Hiang Swee Chiang, Phil Endecott, Rene Rivera, Harold Pirtle, Paul Ryan, Shumin Wu, Michal Wozniak, Peter Johnson, Alex Ott, Shane Guillory, Steven Wooding and Kim Barrett for their bug fixes and library testing.
- Thanks to Martin Adrian who suggested the use of Interprocess framework for user defined buffers.
- Thanks to Synge Todo for his boostbook-doxygen patch to improve Interprocess documentation.
- Thanks to Olaf Krzikalla for his Intrusive library. I have taken some ideas to improve red black tree implementation from his library.
- Thanks to Daniel James for his unordered_map/set family and his help with allocators. His great unordered implementation has been a reference to design exception safe containers.
- Thanks to Howard Hinnant for his amazing help, specially explaining allocator swapping, move semantics and for developing upgradable mutex and lock transfer features.
- Thanks to Pavel Vozenilek for his continuous review process, suggestions, code and help. He is the major supporter of Interprocess library. The library has grown with his many and great advices.
- And finally, thank you to all Boosters. Long live to C++!

### Release Notes

#### Boost 1.45 Release

- Fixed bugs #1080, #3284, #3439, #3448, #3582, #3682, #3829, #3846, #3914, #3947, #3950, #3951, #3985, #4010, #4417, #4019, #4039, #4218, #4230, #4250, #4297, #4350, #4352, #4426, #4516, #4524, #4557, #4606, #4685, #4694.
- Added support for standard rvalue reference move semantics (tested on GCC 4.5 and VC10).
- Permissions can be detailed for interprocess named resources.
- `mapped_region::flush` initiates disk flushing but does not guarantee it's completed when returns, since it is not portable.
- FreeBSD and MacOS now use posix semaphores to implement named semaphores and mutex.

#### Boost 1.41 Release

- Support for POSIX shared memory in Mac OS.
- ABI breaking: Generic `semaphore` and `named_semaphore` now implemented more efficiently with atomic operations.
- More robust file opening in Windows platforms with active Anti-virus software.

#### Boost 1.40 Release

- Windows shared memory is created in Shared Documents folder so that it can be shared between services and processes
- Fixed bugs #2967, #2973, #2992, #3138, #3166, #3205.

#### Boost 1.39 Release

- Added experimental `stable_vector` container.
- `shared_memory_object::remove` has now POSIX `unlink` semantics and `file_mapping::remove` was added to obtain POSIX `unlink` semantics with mapped files.
- Shared memory in windows has now kernel lifetime instead of filesystem lifetime: shared memory will disappear when the system reboots.
- Updated move semantics.
- Fixed bugs #2722, #2729, #2766, #1390, #2589,

#### Boost 1.38 Release

- Updated documentation to show rvalue-references funcions instead of emulation functions.
- More non-copyable classes are now movable.
- Move-constructor and assignments now leave moved object in default-constructed state instead of just swapping contents.
- Several bugfixes ( #2391, #2431, #1390, #2570, #2528.

#### Boost 1.37 Release

- Containers can be used now in recursive types.
- Added `BOOST_INTERPROCESS_FORCE_GENERIC_EMULATION` macro option to force the use of generic emulation code for process-shared synchronization primitives instead of native POSIX functions.
- Added placement insertion members to containers
- `boost::posix_time::pos_inf` value is now handled portably for timed functions.
- Update some function parameters from `iterator` to `const_iterator` in containers to keep up with the draft of the next standard.
- Documentation fixes.

#### Boost 1.36 Release

- Added anonymous shared memory for UNIX systems.
- Fixed erroneous `void` return types from `flat_map::erase()` functions.
- Fixed missing move semantics on managed memory classes.
- Added copy_on_write and open_read_only options for shared memory and mapped file managed classes.
- ABI breaking: Added to `mapped_region` the mode used to create it.
- Corrected instantiation errors in void allocators.
- `shared_ptr` is movable and supports aliasing.

#### Boost 1.35 Release

- Added auxiliary utilities to ease the definition and construction of `shared_ptr`, `weak_ptr` and `unique_ptr`. Added explanations and examples of these smart pointers in the documentation.

- Optimized vector:

  - 1) Now works with raw pointers as much as possible when using allocators defining `pointer` as an smart pointer. This increases performance and improves compilation times.
  - 2) A bit of metaprogramming to avoid using move_iterator when the type has trivial copy constructor or assignment and improve performance.
  - 3) Changed custom algorithms with standard ones to take advantage of optimized standard algorithms.
  - 4) Removed unused code.
- 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.
- Implemented `named_mutex` and `named_semaphore` with POSIX named semaphores in systems supporting that option. `named_condition` has been accordingly changed to support interoperability with `named_mutex`.
- Reduced template bloat for node and adaptive allocators extracting node implementation to a class that only depends on the memory algorithm, instead of the segment manager + node size + node number...
- Fixed bug in `mapped_region` in UNIX when mapping address was provided but the region was mapped in another address.
- Added `aligned_allocate` and `allocate_many` functions to managed memory segments.
- Improved documentation about managed memory segments.
- Boost.Interprocess containers are now documented in the Reference section.
- Correction of typos and documentation errors.
- Added `get_instance_name`, `get_instance_length` and `get_instance_type` functions to managed memory segments.
- Corrected suboptimal buffer expansion bug in `rbtree_best_fit`.
- Added iteration of named and unique objects in a segment manager.
- Fixed leak in `vector`.
- Added support for Solaris.
- Optimized `segment_manager` to avoid code bloat associated with templated instantiations.
- Fixed bug for UNIX: No slash ('/') was being added as the first character for shared memory names, leading to errors in some UNIX systems.
- Fixed bug in VC-8.0: Broken function inlining in core offset_ptr functions.
- Code examples changed to use new BoostBook code import features.
- Added aligned memory allocation function to memory algorithms.
- 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 security check to avoid integer overflow bug in allocators and named construction functions.
- Added alignment checks to forward and backwards expansion functions.
- Fixed bug in atomic functions for PPC.
- Fixed race-condition error when creating and opening a managed segment.
- Added adaptive pools.
- Source breaking: Changed node allocators' template parameter order to make them easier to use.
- Added support for native windows shared memory.
- Added more tests.
- Corrected the presence of private functions in the reference section.
- Added function (`deallocate_free_chunks()`) to manually deallocate completely free chunks from node allocators.
- Implemented N1780 proposal to LWG issue 233: Insertion hints in associative containers in interprocess `multiset` and `multimap` classes.
- Source breaking: A shared memory object is now used including `shared_memory_object.hpp` header instead of `shared memory.hpp`.
- ABI breaking: Changed global mutex when initializing managed shared memory and memory mapped files. This change tries to minimize deadlocks.
- Source breaking: Changed shared memory, memory mapped files and mapped region's open mode to a single `mode_t` type.
- Added extra WIN32_LEAN_AND_MEAN before including DateTime headers to avoid socket redefinition errors when using Interprocess and Asio in windows.
- ABI breaking: `mapped_region` constructor no longer requires classes derived from memory_mappable, but classes must fulfill the MemoryMappable concept.
- Added in-place reallocation capabilities to basic_string.
- ABI breaking: Reimplemented and optimized small string optimization. The narrow string class has zero byte overhead with an internal 11 byte buffer in 32 systems!
- 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.

### Books and interesting links

Some useful references about the C++ programming language, C++ internals, shared memory, allocators and containers used to design Boost.Interprocess.

#### Books

- Great book about multithreading, and POSIX: "Programming with Posix Threads", David R. Butenhof
- The UNIX inter-process bible: "UNIX Network Programming, Volume 2: Interprocess Communications", W. Richard Stevens
- Current STL allocator issues: "Effective STL", Scott Meyers
- My C++ bible: "Thinking in C++, Volume 1 & 2", Bruce Eckel and Chuck Allison
- The book every C++ programmer should read: "Inside the C++ Object Model", Stanley B. Lippman
- A must-read: "ISO/IEC TR 18015: Technical Report on C++ Performance", ISO WG21-SC22 members.

#### Links

- A framework to put the STL in shared memory: "A C++ Standard Allocator for the Standard Template Library" .
- Instantiating C++ objects in shared memory: "Using objects in shared memory for C++ application" .
- A shared memory allocator and relative pointer: "Taming Shared Memory" .

### Future improvements...

There are some Interprocess features that I would like to implement and some Boost.Interprocess code that can be much better. Let's see some ideas:

#### Win32 synchronization is too basic

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.

#### Use of wide character names on Boost.Interprocess basic resources

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.

#### Security attributes

Boost.Interprocess does not define security attributes for shared memory and synchronization objects. Standard C++ also ignores security attributes with files so adding security attributes would require some serious work.

#### Future inter-process communications

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?