Boost C++ Libraries

Boost.Interprocess uses the Windows COM library to implement some features and initializes it with concurrency model COINIT_APARTMENTTHREADED. If the COM library was already initialized by the calling thread for another concurrency model, Boost.Interprocess handles this gracefully and uses COM calls for the already initialized model. If for some reason, you want Boost.Interprocess to initialize the COM library with another model, define the macro BOOST_INTERPROCESS_WINDOWS_COINIT_MODEL before including Boost.Interprocess to one of these values:

Shared memory (shared_memory_object) is implemented in windows using memory mapped files, placed in a shared directory in the shared documents folder (SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders\Common AppData). This directory name is the last bootup time obtained via COM calls (if BOOST_INTERPROCESS_BOOTSTAMP_IS_LASTBOOTUPTIME) defined or searching the system log for a startup event (the default implementation), so that each bootup shared memory is created in a new folder obtaining kernel persistence shared memory.

If using BOOST_INTERPROCESS_BOOTSTAMP_IS_LASTBOOTUPTIME, due to COM implementation related errors, in Boost 1.48 & Boost 1.49 the bootup-time folder was dumped and files were directly created in shared documents folder, reverting to filesystem persistence shared memory. Boost 1.50 fixed those issues and recovered bootup time directory and kernel persistence. If you need to reproduce Boost 1.48 & Boost 1.49 behaviour to communicate with applications compiled with that version, comment #define BOOST_INTERPROCESS_HAS_KERNEL_BOOTTIME directive in the Windows configuration part of boost/interprocess/detail/workaround.hpp.

If using the default implementation, (BOOST_INTERPROCESS_BOOTSTAMP_IS_LASTBOOTUPTIME undefined) and the Startup Event is not found, this might be due to some buggy software that floods or erases the event log.

In any error case (shared documents folder is not defined or bootup time could not be obtained, the library throws an error. You still can use Boost.Interprocess definining your own directory as the shared directory. Just define BOOST_INTERPROCESS_SHARED_DIR_PATH when using the library and that path will be used to place shared memory files.

If BOOST_USE_WINDOWS_H is defined, <windows.h> and other windows SDK files are included, otherwise the library declares needed functions and structures to reduce the impact of including those heavy headers.

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

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 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.

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?

A B C D E F I L M N O P R S T U W X

A B C D E F I K M N O P R S T V W

A B C D E F G I L M N O P R S T U W Z

Describes adaptive_pool pooled shared memory STL compatible allocator

template<typename T, typename SegmentManager, std::size_t NodesPerBlock, 
         std::size_t MaxFreeBlocks, unsigned char OverheadPercent> 
  class adaptive_pool;namespace boost {
  template<typename T, typename SegmentManager, 
           std::size_t NodesPerBlock = 64, std::size_t MaxFreeBlocks = 2, 
           unsigned char OverheadPercent = 5> 
    class adaptive_pool_v1;
  template<unsigned int V, typename T, typename S, std::size_t NPC, 
           std::size_t F, unsigned char OP> 
    bool operator==(const adaptive_pool_base< V, T, S, NPC, F, OP > &, 
                    const adaptive_pool_base< V, T, S, NPC, F, OP > &);
  template<unsigned int V, typename T, typename S, std::size_t NPC, 
           std::size_t F, unsigned char OP> 
    bool operator!=(const adaptive_pool_base< V, T, S, NPC, F, OP > &, 
                    const adaptive_pool_base< V, T, S, NPC, F, OP > &);
  namespace interprocess {
     adaptive_pool_base(segment_manager *);
     adaptive_pool_base(const adaptive_pool_base &);

    // Assignment from other adaptive_pool_base. 
    adaptive_pool_base & operator=(const adaptive_pool_base & other);
    template<typename T2> 
       adaptive_pool_base(const adaptive_pool_base< Version, T2, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent > &);
     ~adaptive_pool_base();
  }
}
template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F, 
         unsigned char OP> 
  bool operator==(const adaptive_pool< T, S, NodesPerBlock, F, OP > &, 
                  const adaptive_pool< T, S, NodesPerBlock, F, OP > &);
template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F, 
         unsigned char OP> 
  bool operator!=(const adaptive_pool< T, S, NodesPerBlock, F, OP > &, 
                  const adaptive_pool< T, S, NodesPerBlock, F, OP > &);

Describes an allocator that allocates portions of fixed size memory buffer (shared memory, mapped file...)

namespace boost {
  namespace interprocess {
    template<typename T, typename SegmentManager> 
      bool operator==(const allocator< T, SegmentManager > &, 
                      const allocator< T, SegmentManager > &);
    template<typename T, typename SegmentManager> 
      bool operator!=(const allocator< T, SegmentManager > &, 
                      const allocator< T, SegmentManager > &);
  }
}

Describes cached_adaptive_pool pooled shared memory STL compatible allocator

namespace boost {
  namespace interprocess {
    template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F, 
             std::size_t OP> 
      bool operator==(const cached_adaptive_pool< T, S, NodesPerBlock, F, OP > &, 
                      const cached_adaptive_pool< T, S, NodesPerBlock, F, OP > &);
    template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F, 
             std::size_t OP> 
      bool operator!=(const cached_adaptive_pool< T, S, NodesPerBlock, F, OP > &, 
                      const cached_adaptive_pool< T, S, NodesPerBlock, F, OP > &);
  }
}

Describes cached_cached_node_allocator pooled shared memory STL compatible allocator

namespace boost {
  namespace interprocess {
    template<typename T, typename S, std::size_t NPC> 
      bool operator==(const cached_node_allocator< T, S, NPC > &, 
                      const cached_node_allocator< T, S, NPC > &);
    template<typename T, typename S, std::size_t NPC> 
      bool operator!=(const cached_node_allocator< T, S, NPC > &, 
                      const cached_node_allocator< T, S, NPC > &);
  }
}

Describes node_allocator pooled shared memory STL compatible allocator

template<typename T, typename SegmentManager, std::size_t NodesPerBlock> 
  class node_allocator;namespace boost {
  template<typename T, typename SegmentManager, 
           std::size_t NodesPerBlock = 64> 
    class node_allocator_v1;
  template<unsigned int V, typename T, typename S, std::size_t NPC> 
    bool operator==(const node_allocator_base< V, T, S, NPC > &, 
                    const node_allocator_base< V, T, S, NPC > &);
  template<unsigned int V, typename T, typename S, std::size_t NPC> 
    bool operator!=(const node_allocator_base< V, T, S, NPC > &, 
                    const node_allocator_base< V, T, S, NPC > &);
  namespace interprocess {
     BOOST_STATIC_ASSERT((Version<=2));
     node_allocator_base(segment_manager *);
     node_allocator_base(const node_allocator_base &);
    template<typename T2> 
       node_allocator_base(const node_allocator_base< Version, T2, SegmentManager, NodesPerBlock > &);

    // Assignment from other node_allocator_base. 
    node_allocator_base & operator=(const node_allocator_base & other);
     ~node_allocator_base();
  }
}
template<typename T, typename S, std::size_t NPC> 
  bool operator==(const node_allocator< T, S, NPC > &, 
                  const node_allocator< T, S, NPC > &);
template<typename T, typename S, std::size_t NPC> 
  bool operator!=(const node_allocator< T, S, NPC > &, 
                  const node_allocator< T, S, NPC > &);

Describes private_adaptive_pool_base pooled shared memory STL compatible allocator

template<typename T, typename SegmentManager, std::size_t NodesPerBlock, 
         std::size_t MaxFreeBlocks, unsigned char OverheadPercent> 
  class private_adaptive_pool;namespace boost {
  template<typename T, typename SegmentManager, 
           std::size_t NodesPerBlock = 64, std::size_t MaxFreeBlocks = 2, 
           unsigned char OverheadPercent = 5> 
    class private_adaptive_pool_v1;

  // Equality test for same type of private_adaptive_pool_base. 
  template<unsigned int V, typename T, typename S, std::size_t NodesPerBlock, 
           std::size_t F, unsigned char OP> 
    bool operator==(const private_adaptive_pool_base< V, T, S, NodesPerBlock, F, OP > & alloc1, 
                    const private_adaptive_pool_base< V, T, S, NodesPerBlock, F, OP > & alloc2);

  // Inequality test for same type of private_adaptive_pool_base. 
  template<unsigned int V, typename T, typename S, std::size_t NodesPerBlock, 
           std::size_t F, unsigned char OP> 
    bool operator!=(const private_adaptive_pool_base< V, T, S, NodesPerBlock, F, OP > & alloc1, 
                    const private_adaptive_pool_base< V, T, S, NodesPerBlock, F, OP > & alloc2);
  namespace interprocess {

    // Constructor from a segment manager. 
     private_adaptive_pool_base(segment_manager * segment_mngr);

    // Copy constructor from other private_adaptive_pool_base. Never throws. 
     private_adaptive_pool_base(const private_adaptive_pool_base & other);

    // Copy constructor from related private_adaptive_pool_base. Never throws. 
    template<typename T2> 
       private_adaptive_pool_base(const private_adaptive_pool_base< Version, T2, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent > & other);

    // Destructor, frees all used memory. Never throws. 
     ~private_adaptive_pool_base();
  }
}
template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F, 
         unsigned char OP> 
  bool operator==(const private_adaptive_pool< T, S, NodesPerBlock, F, OP > &, 
                  const private_adaptive_pool< T, S, NodesPerBlock, F, OP > &);
template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F, 
         unsigned char OP> 
  bool operator!=(const private_adaptive_pool< T, S, NodesPerBlock, F, OP > &, 
                  const private_adaptive_pool< T, S, NodesPerBlock, F, OP > &);

Describes private_node_allocator_base pooled shared memory STL compatible allocator

template<typename T, typename SegmentManager, std::size_t NodesPerBlock> 
  class private_node_allocator;namespace boost {
  template<typename T, typename SegmentManager, 
           std::size_t NodesPerBlock = 64> 
    class private_node_allocator_v1;

  // Equality test for same type of private_node_allocator_base. 
  template<unsigned int V, typename T, typename S, std::size_t NPC> 
    bool operator==(const private_node_allocator_base< V, T, S, NPC > & alloc1, 
                    const private_node_allocator_base< V, T, S, NPC > & alloc2);

  // Inequality test for same type of private_node_allocator_base. 
  template<unsigned int V, typename T, typename S, std::size_t NPC> 
    bool operator!=(const private_node_allocator_base< V, T, S, NPC > & alloc1, 
                    const private_node_allocator_base< V, T, S, NPC > & alloc2);
  namespace interprocess {
    template<typename T2> struct rebind;

    typedef boost::intrusive::pointer_traits< void_pointer >::template rebind_pointer< T >::type pointer;
    typedef boost::intrusive::pointer_traits< void_pointer >::template rebind_pointer< const T >::type const_pointer;
    typedef T value_type;
    typedef unspecified reference;
    typedef unspecified const_reference;
    typedef segment_manager::size_type size_type;
    typedef segment_manager::difference_type difference_type;
    typedef boost::interprocess::version_type< private_node_allocator_base, Version > version;
    typedef unspecified multiallocation_chain;

    // Constructor from a segment manager. 
     private_node_allocator_base(segment_manager * segment_mngr);

    // Copy constructor from other private_node_allocator_base. Never throws. 
     private_node_allocator_base(const private_node_allocator_base & other);

    // Copy constructor from related private_node_allocator_base. Never throws. 
    template<typename T2> 
       private_node_allocator_base(const private_node_allocator_base< Version, T2, SegmentManager, NodesPerBlock > & other);

    // Destructor, frees all used memory. Never throws. 
     ~private_node_allocator_base();
    segment_manager * get_segment_manager();
    node_pool_t * get_node_pool();
    friend void swap(self_t &, self_t &);
  }
}
template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F, 
         unsigned char OP> 
  bool operator==(const private_node_allocator< T, S, NodesPerBlock, F, OP > &, 
                  const private_node_allocator< T, S, NodesPerBlock, F, OP > &);
template<typename T, typename S, std::size_t NodesPerBlock, std::size_t F, 
         unsigned char OP> 
  bool operator!=(const private_node_allocator< T, S, NodesPerBlock, F, OP > &, 
                  const private_node_allocator< T, S, NodesPerBlock, F, OP > &);