boost-react-native-bundle

<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> <title>Managed Memory Segments</title> <link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css"> <meta name="generator" content="DocBook XSL Stylesheets V1.78.1"> <link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset"> <link rel="up" href="../interprocess.html" title="Chapter 14. Boost.Interprocess"> <link rel="prev" href="synchronization_mechanisms.html" title="Synchronization mechanisms"> <link rel="next" href="allocators_containers.html" title="Allocators, containers and memory allocation algorithms"> </head> <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> <table cellpadding="2" width="100%"><tr> <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td> <td align="center"><a href="../../../index.html">Home</a></td> <td align="center"><a href="../../../libs/libraries.htm">Libraries</a></td> <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> <td align="center"><a href="../../../more/index.htm">More</a></td> </tr></table> <hr> <div class="spirit-nav"> <a accesskey="p" href="synchronization_mechanisms.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../interprocess.html"><img src="../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="allocators_containers.html"><img src="../../../doc/src/images/next.png" alt="Next"></a> </div> <div class="section"> <div class="titlepage"><div><div><h2 class="title" style="clear: both"> <a name="interprocess.managed_memory_segments"></a><a class="link" href="managed_memory_segments.html" title="Managed Memory Segments">Managed Memory Segments</a> </h2></div></div></div> <div class="toc"><dl class="toc"> <dt><a href="managed_memory_segments.html#interprocess.managed_memory_segments.making_ipc_easy">Making Interprocess Data Communication Easy</a></dt> <dt><a href="managed_memory_segments.html#interprocess.managed_memory_segments.managed_shared_memory">Managed Shared Memory</a></dt> <dt><a href="managed_memory_segments.html#interprocess.managed_memory_segments.managed_mapped_files">Managed Mapped File</a></dt> <dt><a href="managed_memory_segments.html#interprocess.managed_memory_segments.managed_memory_segment_features">Managed Memory Segment Features</a></dt> <dt><a href="managed_memory_segments.html#interprocess.managed_memory_segments.managed_memory_segment_advanced_features">Managed Memory Segment Advanced Features</a></dt> <dt><a href="managed_memory_segments.html#interprocess.managed_memory_segments.managed_heap_memory_external_buffer">Managed Heap Memory And Managed External Buffer</a></dt> </dl></div> <div class="section"> <div class="titlepage"><div><div><h3 class="title"> <a name="interprocess.managed_memory_segments.making_ipc_easy"></a><a class="link" href="managed_memory_segments.html#interprocess.managed_memory_segments.making_ipc_easy" title="Making Interprocess Data Communication Easy">Making Interprocess Data Communication Easy</a> </h3></div></div></div> <div class="toc"><dl class="toc"> <dt><a href="managed_memory_segments.html#interprocess.managed_memory_segments.making_ipc_easy.managed_memory_segments_intro">Introduction</a></dt> <dt><a href="managed_memory_segments.html#interprocess.managed_memory_segments.making_ipc_easy.managed_memory_segment_int">Declaration of managed memory segment classes</a></dt> </dl></div> <div class="section"> <div class="titlepage"><div><div><h4 class="title"> <a name="interprocess.managed_memory_segments.making_ipc_easy.managed_memory_segments_intro"></a><a class="link" href="managed_memory_segments.html#interprocess.managed_memory_segments.making_ipc_easy.managed_memory_segments_intro" title="Introduction">Introduction</a> </h4></div></div></div> As we have seen, Boost.Interprocess offers some basic classes to create shared memory objects and file mappings and map those mappable classes to the process' address space. However, managing those memory segments is not not easy for non-trivial tasks. A mapped region is a fixed-length memory buffer and creating and destroying objects of any type dynamically, requires a lot of work, since it would require programming a memory management algorithm to allocate portions of that segment. Many times, we also want to associate names to objects created in shared memory, so all the processes can find the object using the name. Boost.Interprocess offers 4 managed memory segment classes: <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "> <li class="listitem"> To manage a shared memory mapped region (basic_managed_shared_memory class). </li> <li class="listitem"> To manage a memory mapped file (basic_managed_mapped_file). </li> <li class="listitem"> To manage a heap allocated (<code class="computeroutput">operator new</code>) memory buffer (basic_managed_heap_memory class). </li> <li class="listitem"> To manage a user provided fixed size buffer (basic_managed_external_buffer class). </li> </ul></div> The first two classes manage memory segments that can be shared between processes. The third is useful to create complex data-bases to be sent though other mechanisms like message queues to other processes. The fourth class can manage any fixed size memory buffer. The first two classes will be explained in the next two sections. basic_managed_heap_memory and basic_managed_external_buffer will be explained later. The most important services of a managed memory segment are: <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "> <li class="listitem"> Dynamic allocation of portions of a memory the segment. </li> <li class="listitem"> Construction of C++ objects in the memory segment. These objects can be anonymous or we can associate a name to them. </li> <li class="listitem"> Searching capabilities for named objects. </li> <li class="listitem"> Customization of many features: memory allocation algorithm, index types or character types. </li> <li class="listitem"> Atomic constructions and destructions so that if the segment is shared between two processes it's impossible to create two objects associated with the same name, simplifying synchronization. </li> </ul></div> </div> <div class="section"> <div class="titlepage"><div><div><h4 class="title"> <a name="interprocess.managed_memory_segments.making_ipc_easy.managed_memory_segment_int"></a><a class="link" href="managed_memory_segments.html#interprocess.managed_memory_segments.making_ipc_easy.managed_memory_segment_int" title="Declaration of managed memory segment classes">Declaration of managed memory segment classes</a> </h4></div></div></div> All Boost.Interprocess managed memory segment classes are templatized classes that can be customized by the user: <pre class="programlisting">template < class CharType, class MemoryAlgorithm, template<class IndexConfig> class IndexType > class basic_managed_shared_memory / basic_managed_mapped_file / basic_managed_heap_memory / basic_external_buffer; </pre> These classes can be customized with the following template parameters: <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "> <li class="listitem"> CharType is the type of the character that will be used to identify the created named objects (for example, char or wchar_t) </li> <li class="listitem"> MemoryAlgorithm is the memory algorithm used to allocate portions of the segment (for example, rbtree_best_fit ). The internal typedefs of the memory algorithm also define: <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; "> <li class="listitem"> The synchronization type (<code class="computeroutput">MemoryAlgorithm::mutex_family</code>) to be used in all allocation operations. This allows the use of user-defined mutexes or avoiding internal locking (maybe code will be externally synchronized by the user). </li> <li class="listitem"> The Pointer type (<code class="computeroutput">MemoryAlgorithm::void_pointer</code>) to be used by the memory allocation algorithm or additional helper structures (like a map to maintain object/name associations). All STL compatible allocators and containers to be used with this managed memory segment will use this pointer type. The pointer type will define if the managed memory segment can be mapped between several processes. For example, if <code class="computeroutput">void_pointer</code> is <code class="computeroutput">offset_ptr<void></code> we will be able to map the managed segment in different base addresses in each process. If <code class="computeroutput">void_pointer</code> is <code class="computeroutput">void*</code> only fixed address mapping could be used. </li> <li class="listitem"> See <a class="link" href="customizing_interprocess.html#interprocess.customizing_interprocess.custom_interprocess_alloc" title="Writing a new shared memory allocation algorithm">Writing a new memory allocation algorithm</a> for more details about memory algorithms. </li> </ul></div> </li> <li class="listitem"> IndexType is the type of index that will be used to store the name-object association (for example, a map, a hash-map, or an ordered vector). </li> </ul></div> This way, we can use <code class="computeroutput">char</code> or <code class="computeroutput">wchar_t</code> strings to identify created C++ objects in the memory segment, we can plug new shared memory allocation algorithms, and use the index type that is best suited to our needs. </div> </div> <div class="section"> <div class="titlepage"><div><div><h3 class="title"> <a name="interprocess.managed_memory_segments.managed_shared_memory"></a><a class="link" href="managed_memory_segments.html#interprocess.managed_memory_segments.managed_shared_memory" title="Managed Shared Memory">Managed Shared Memory</a> </h3></div></div></div> <div class="toc"><dl class="toc"> <dt><a href="managed_memory_segments.html#interprocess.managed_memory_segments.managed_shared_memory.managed_memory_common_shm">Common Managed Shared Memory Classes</a></dt> <dt><a href="managed_memory_segments.html#interprocess.managed_memory_segments.managed_shared_memory.constructing_managed_shared_memories">Constructing Managed Shared Memory</a></dt> <dt><a href="managed_memory_segments.html#interprocess.managed_memory_segments.managed_shared_memory.windows_managed_memory_common_shm">Using native windows shared memory</a></dt> <dt><a href="managed_memory_segments.html#interprocess.managed_memory_segments.managed_shared_memory.xsi_managed_memory_common_shm">Using XSI (system V) shared memory</a></dt> </dl></div> <div class="section"> <div class="titlepage"><div><div><h4 class="title"> <a name="interprocess.managed_memory_segments.managed_shared_memory.managed_memory_common_shm"></a><a class="link" href="managed_memory_segments.html#interprocess.managed_memory_segments.managed_shared_memory.managed_memory_common_shm" title="Common Managed Shared Memory Classes">Common Managed Shared Memory Classes</a> </h4></div></div></div> As seen, basic_managed_shared_memory offers a great variety of customization. But for the average user, a common, default shared memory named object creation is needed. Because of this, Boost.Interprocess defines the most common managed shared memory specializations: <pre class="programlisting">//!Defines a managed shared memory with c-strings as keys for named objects, //!the default memory algorithm (with process-shared mutexes, //!and offset_ptr as internal pointers) as memory allocation algorithm //!and the default index type as the index. //!This class allows the shared memory to be mapped in different base //!in different processes typedef basic_managed_shared_memory<char ,/*Default memory algorithm defining offset_ptr<void> as void_pointer*/ ,/*Default index type*/> managed_shared_memory; //!Defines a managed shared memory with wide strings as keys for named objects, //!the default memory algorithm (with process-shared mutexes, //!and offset_ptr as internal pointers) as memory allocation algorithm //!and the default index type as the index. //!This class allows the shared memory to be mapped in different base //!in different processes typedef basic_managed_shared_memory<wchar_t ,/*Default memory algorithm defining offset_ptr<void> as void_pointer*/ ,/*Default index type*/> wmanaged_shared_memory; </pre> <code class="computeroutput">managed_shared_memory</code> allocates objects in shared memory associated with a c-string and <code class="computeroutput">wmanaged_shared_memory</code> allocates objects in shared memory associated with a wchar_t null terminated string. Both define the pointer type as <code class="computeroutput">offset_ptr<void></code> so they can be used to map the shared memory at different base addresses in different processes. If the user wants to map the shared memory in the same address in all processes and want to use raw pointers internally instead of offset pointers, Boost.Interprocess defines the following types: <pre class="programlisting">//!Defines a managed shared memory with c-strings as keys for named objects, //!the default memory algorithm (with process-shared mutexes, //!and offset_ptr as internal pointers) as memory allocation algorithm //!and the default index type as the index. //!This class allows the shared memory to be mapped in different base //!in different processes*/ typedef basic_managed_shared_memory <char ,/*Default memory algorithm defining void * as void_pointer*/ ,/*Default index type*/> fixed_managed_shared_memory; //!Defines a managed shared memory with wide strings as keys for named objects, //!the default memory algorithm (with process-shared mutexes, //!and offset_ptr as internal pointers) as memory allocation algorithm //!and the default index type as the index. //!This class allows the shared memory to be mapped in different base //!in different processes typedef basic_managed_shared_memory <wchar_t ,/*Default memory algorithm defining void * as void_pointer*/ ,/*Default index type*/> wfixed_managed_shared_memory; </pre> </div> <div class="section"> <div class="titlepage"><div><div><h4 class="title"> <a name="interprocess.managed_memory_segments.managed_shared_memory.constructing_managed_shared_memories"></a><a class="link" href="managed_memory_segments.html#interprocess.managed_memory_segments.managed_shared_memory.constructing_managed_shared_memories" title="Constructing Managed Shared Memory">Constructing Managed Shared Memory</a> </h4></div></div></div> Managed shared memory is an advanced class that combines a shared memory object and a mapped region that covers all the shared memory object. That means that when we create a new managed shared memory: <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "> <li class="listitem"> A new shared memory object is created. </li> <li class="listitem"> The whole shared memory object is mapped in the process' address space. </li> <li class="listitem"> Some helper objects are constructed (name-object index, internal synchronization objects, internal variables...) in the mapped region to implement managed memory segment features. </li> </ul></div> When we open a managed shared memory <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "> <li class="listitem"> A shared memory object is opened. </li> <li class="listitem"> The whole shared memory object is mapped in the process' address space. </li> </ul></div> To use a managed shared memory, you must include the following header: <pre class="programlisting">#include <boost/interprocess/managed_shared_memory.hpp> </pre> <pre class="programlisting">//1. Creates a new shared memory object // called "MySharedMemory". //2. Maps the whole object to this // process' address space. //3. Constructs some objects in shared memory // to implement managed features. //!! If anything fails, throws interprocess_exception // managed_shared_memory segment ( create_only , "MySharedMemory" //Shared memory object name , 65536); //Shared memory object size in bytes </pre> <pre class="programlisting">//1. Opens a shared memory object // called "MySharedMemory". //2. Maps the whole object to this // process' address space. //3. Obtains pointers to constructed internal objects // to implement managed features. //!! If anything fails, throws interprocess_exception // managed_shared_memory segment (open_only, "MySharedMemory");//Shared memory object name </pre> <pre class="programlisting">//1. If the segment was previously created // equivalent to "open_only" (size is ignored). //2. Otherwise, equivalent to "create_only" //!! If anything fails, throws interprocess_exception // managed_shared_memory segment ( open_or_create , "MySharedMemory" //Shared memory object name , 65536); //Shared memory object size in bytes </pre> When the <code class="computeroutput">managed_shared_memory</code> object is destroyed, the shared memory object is automatically unmapped, and all the resources are freed. To remove the shared memory object from the system you must use the <code class="computeroutput">shared_memory_object::remove</code> function. Shared memory object removing might fail if any process still has the shared memory object mapped. The user can also map the managed shared memory in a fixed address. This option is essential when using using <code class="computeroutput">fixed_managed_shared_memory</code>. To do this, just add the mapping address as an extra parameter: <pre class="programlisting">fixed_managed_shared_memory segment (open_only ,"MyFixedAddressSharedMemory" //Shared memory object name ,(void*)0x30000000 //Mapping address </pre> </div> <div class="section"> <div class="titlepage"><div><div><h4 class="title"> <a name="interprocess.managed_memory_segments.managed_shared_memory.windows_managed_memory_common_shm"></a><a class="link" href="managed_memory_segments.html#interprocess.managed_memory_segments.managed_shared_memory.windows_managed_memory_common_shm" title="Using native windows shared memory">Using native windows shared memory</a> </h4></div></div></div> Windows users might also want to use native windows shared memory instead of the portable <code class="computeroutput"><a class="link" href="../boost/interprocess/shared_memory_object.html" title="Class shared_memory_object">shared_memory_object</a></code> managed memory. This is achieved through the <code class="computeroutput"><a class="link" href="../boost/interprocess/basic_managed__idp65413104.html" title="Class template basic_managed_windows_shared_memory">basic_managed_windows_shared_memory</a></code> class. To use it just include: <pre class="programlisting">#include <boost/interprocess/managed_windows_shared_memory.hpp> </pre> This class has the same interface as <code class="computeroutput"><a class="link" href="../boost/interprocess/basic_managed__idp65355360.html" title="Class template basic_managed_shared_memory">basic_managed_shared_memory</a></code> but uses native windows shared memory. Note that this managed class has the same lifetime issues as the windows shared memory: when the last process attached to the windows shared memory is detached from the memory (or ends/crashes) the memory is destroyed. So there is no persistence support for windows shared memory. To communicate between system services and user applications using <code class="computeroutput">managed_windows_shared_memory</code>, please read the explanations given in chapter <a class="link" href="sharedmemorybetweenprocesses.html#interprocess.sharedmemorybetweenprocesses.sharedmemory.windows_shared_memory" title="Native windows shared memory">Native windows shared memory</a>. </div> <div class="section"> <div class="titlepage"><div><div><h4 class="title"> <a name="interprocess.managed_memory_segments.managed_shared_memory.xsi_managed_memory_common_shm"></a><a class="link" href="managed_memory_segments.html#interprocess.managed_memory_segments.managed_shared_memory.xsi_managed_memory_common_shm" title="Using XSI (system V) shared memory">Using XSI (system V) shared memory</a> </h4></div></div></div> Unix users might also want to use XSI (system V) instead of the portable <code class="computeroutput"><a class="link" href="../boost/interprocess/shared_memory_object.html" title="Class shared_memory_object">shared_memory_object</a></code> managed memory. This is achieved through the <code class="computeroutput"><a class="link" href="../boost/interprocess/basic_managed__idp65461824.html" title="Class template basic_managed_xsi_shared_memory">basic_managed_xsi_shared_memory</a></code> class. To use it just include: <pre class="programlisting">#include <boost/interprocess/managed_xsi_shared_memory.hpp> </pre> This class has nearly the same interface as <code class="computeroutput"><a class="link" href="../boost/interprocess/basic_managed__idp65355360.html" title="Class template basic_managed_shared_memory">basic_managed_shared_memory</a></code> but uses XSI shared memory as backend. </div> For more information about managed XSI shared memory capabilities, see <code class="computeroutput"><a class="link" href="../boost/interprocess/basic_managed__idp65461824.html" title="Class template basic_managed_xsi_shared_memory">basic_managed_xsi_shared_memory</a></code> class reference. </div> <div class="section"> <div class="titlepage"><div><div><h3 class="title"> <a name="interprocess.managed_memory_segments.managed_mapped_files"></a><a class="link" href="managed_memory_segments.html#interprocess.managed_memory_segments.managed_mapped_files" title="Managed Mapped File">Managed Mapped File</a> </h3></div></div></div> <div class="toc"><dl class="toc"> <dt><a href="managed_memory_segments.html#interprocess.managed_memory_segments.managed_mapped_files.managed_memory_common_mfile">Common Managed Mapped Files</a></dt> <dt><a href="managed_memory_segments.html#interprocess.managed_memory_segments.managed_mapped_files.constructing_managed_mapped_files">Constructing Managed Mapped Files</a></dt> </dl></div> <div class="section"> <div class="titlepage"><div><div><h4 class="title"> <a name="interprocess.managed_memory_segments.managed_mapped_files.managed_memory_common_mfile"></a><a class="link" href="managed_memory_segments.html#interprocess.managed_memory_segments.managed_mapped_files.managed_memory_common_mfile" title="Common Managed Mapped Files">Common Managed Mapped Files</a> </h4></div></div></div> As seen, basic_managed_mapped_file offers a great variety of customization. But for the average user, a common, default shared memory named object creation is needed. Because of this, Boost.Interprocess defines the most common managed mapped file specializations: <pre class="programlisting">//Named object creation managed memory segment //All objects are constructed in the memory-mapped file // Names are c-strings, // Default memory management algorithm(rbtree_best_fit with no mutexes) // Name-object mappings are stored in the default index type (flat_map) typedef basic_managed_mapped_file < char, rbtree_best_fit<mutex_family, offset_ptr<void> >, flat_map_index > managed_mapped_file; //Named object creation managed memory segment //All objects are constructed in the memory-mapped file // Names are wide-strings, // Default memory management algorithm(rbtree_best_fit with no mutexes) // Name-object mappings are stored in the default index type (flat_map) typedef basic_managed_mapped_file< wchar_t, rbtree_best_fit<mutex_family, offset_ptr<void> >, flat_map_index > wmanaged_mapped_file; </pre> <code class="computeroutput">managed_mapped_file</code> allocates objects in a memory mapped files associated with a c-string and <code class="computeroutput">wmanaged_mapped_file</code> allocates objects in a memory mapped file associated with a wchar_t null terminated string. Both define the pointer type as <code class="computeroutput">offset_ptr<void></code> so they can be used to map the file at different base addresses in different processes. </div> <div class="section"> <div class="titlepage"><div><div><h4 class="title"> <a name="interprocess.managed_memory_segments.managed_mapped_files.constructing_managed_mapped_files"></a><a class="link" href="managed_memory_segments.html#interprocess.managed_memory_segments.managed_mapped_files.constructing_managed_mapped_files" title="Constructing Managed Mapped Files">Constructing Managed Mapped Files</a> </h4></div></div></div> Managed mapped file is an advanced class that combines a file and a mapped region that covers all the file. That means that when we create a new managed mapped file: <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "> <li class="listitem"> A new file is created. </li> <li class="listitem"> The whole file is mapped in the process' address space. </li> <li class="listitem"> Some helper objects are constructed (name-object index, internal synchronization objects, internal variables...) in the mapped region to implement managed memory segment features. </li> </ul></div> When we open a managed mapped file <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "> <li class="listitem"> A file is opened. </li> <li class="listitem"> The whole file is mapped in the process' address space. </li> </ul></div> To use a managed mapped file, you must include the following header: <pre class="programlisting">#include <boost/interprocess/managed_mapped_file.hpp> </pre> <pre class="programlisting">//1. Creates a new file // called "MyMappedFile". //2. Maps the whole file to this // process' address space. //3. Constructs some objects in the memory mapped // file to implement managed features. //!! If anything fails, throws interprocess_exception // managed_mapped_file mfile (create_only, "MyMappedFile", //Mapped file name 65536); //Mapped file size </pre> <pre class="programlisting">//1. Opens a file // called "MyMappedFile". //2. Maps the whole file to this // process' address space. //3. Obtains pointers to constructed internal objects // to implement managed features. //!! If anything fails, throws interprocess_exception // managed_mapped_file mfile (open_only, "MyMappedFile"); //Mapped file name[c++] //1. If the file was previously created // equivalent to "open_only". //2. Otherwise, equivalent to "open_only" (size is ignored) // //!! If anything fails, throws interprocess_exception // managed_mapped_file mfile (open_or_create, "MyMappedFile", //Mapped file name 65536); //Mapped file size </pre> When the <code class="computeroutput">managed_mapped_file</code> object is destroyed, the file is automatically unmapped, and all the resources are freed. To remove the file from the filesystem you could use standard C <code class="computeroutput">std::remove</code> or Boost.Filesystem's <code class="computeroutput">remove()</code> functions, but file removing might fail if any process still has the file mapped in memory or the file is open by any process. To obtain a more portable behaviour, use <code class="computeroutput">file_mapping::remove(const char *)</code> operation, which will remove the file even if it's being mapped. However, removal will fail in some OS systems if the file (eg. by C++ file streams) and no delete share permission was granted to the file. But in most common cases <code class="computeroutput">file_mapping::remove</code> is portable enough. </div> For more information about managed mapped file capabilities, see <code class="computeroutput"><a class="link" href="../boost/interprocess/basic_managed_mapped_file.html" title="Class template basic_managed_mapped_file">basic_managed_mapped_file</a></code> class reference. </div> <div class="section"> <div class="titlepage"><div><div><h3 class="title"> <a name="interprocess.managed_memory_segments.managed_memory_segment_features"></a><a class="link" href="managed_memory_segments.html#interprocess.managed_memory_segments.managed_memory_segment_features" title="Managed Memory Segment Features">Managed Memory Segment Features</a> </h3></div></div></div> <div class="toc"><dl class="toc"> <dt><a href="managed_memory_segments.html#interprocess.managed_memory_segments.managed_memory_segment_features.allocate_deallocate">Allocating fragments of a managed memory segment</a></dt> <dt><a href="managed_memory_segments.html#interprocess.managed_memory_segments.managed_memory_segment_features.segment_offset">Obtaining handles to identify data</a></dt> <dt><a href="managed_memory_segments.html#interprocess.managed_memory_segments.managed_memory_segment_features.allocation_types">Object construction function family</a></dt> <dt><a href="managed_memory_segments.html#interprocess.managed_memory_segments.managed_memory_segment_features.anonymous">Anonymous instance construction</a></dt> <dt><a href="managed_memory_segments.html#interprocess.managed_memory_segments.managed_memory_segment_features.unique">Unique instance construction</a></dt> <dt><a href="managed_memory_segments.html#interprocess.managed_memory_segments.managed_memory_segment_features.synchronization">Synchronization guarantees</a></dt> <dt><a href="managed_memory_segments.html#interprocess.managed_memory_segments.managed_memory_segment_features.index_types">Index types for name/object mappings</a></dt> <dt><a href="managed_memory_segments.html#interprocess.managed_memory_segments.managed_memory_segment_features.managed_memory_segment_segment_manager">Segment Manager</a></dt> <dt><a href="managed_memory_segments.html#interprocess.managed_memory_segments.managed_memory_segment_features.managed_memory_segment_information">Obtaining information about a constructed object</a></dt> <dt><a href="managed_memory_segments.html#interprocess.managed_memory_segments.managed_memory_segment_features.managed_memory_segment_atomic_func">Executing an object function atomically</a></dt> </dl></div> The following features are common to all managed memory segment classes, but we will use managed shared memory in our examples. We can do the same with memory mapped files or other managed memory segment classes. <div class="section"> <div class="titlepage"><div><div><h4 class="title"> <a name="interprocess.managed_memory_segments.managed_memory_segment_features.allocate_deallocate"></a><a class="link" href="managed_memory_segments.html#interprocess.managed_memory_segments.managed_memory_segment_features.allocate_deallocate" title="Allocating fragments of a managed memory segment">Allocating fragments of a managed memory segment</a> </h4></div></div></div> If a basic raw-byte allocation is needed from a managed memory segment, (for example, a managed shared memory), to implement top-level interprocess communications, this class offers allocate and deallocate functions. The allocation function comes with throwing and no throwing versions. Throwing version throws boost::interprocess::bad_alloc (which derives from <code class="computeroutput">std::bad_alloc</code>) if there is no more memory and the non-throwing version returns 0 pointer. <pre class="programlisting">#include <boost/interprocess/managed_shared_memory.hpp> int main() { using namespace boost::interprocess; //Remove shared memory on construction and destruction struct shm_remove { shm_remove() { shared_memory_object::remove("My