Boost.Interprocess使用手册翻译之七：托管内存片段（Managed Memory Segments）

高级索引函数

[cpp]viewplaincopymanaged_shm.reserve_named_objects(1000);
managed_shm.reserve_unique_objects(1000);
managed_shm.reserve_named_objects(1000);
managed_shm.reserve_unique_objects(1000);

[cpp]viewplaincopytypedefmanaged_shared_memory::const_named_iteratorconst_named_it;
const_named_itnamed_beg=managed_shm.named_begin();
const_named_itnamed_end=managed_shm.named_end();

typedefmanaged_shared_memory::const_unique_iteratorconst_unique_it;
const_unique_itunique_beg=managed_shm.unique_begin();
const_unique_itunique_end=managed_shm.unique_end();

for(;named_beg!=named_end;++named_beg){
//Apointertothenameofthenamedobject
constmanaged_shared_memory::char_type*name=named_beg->name();
//Thelengthofthename
std::size_tname_len=named_beg->name_length();
//Aconstantvoidpointertothenamedobject
constvoid*value=named_beg->value();
}

for(;unique_beg!=unique_end;++unique_beg){
//Thetypeid(T).name()oftheuniqueobject
constchar*typeid_name=unique_beg->name();
//Thelengthofthename
std::size_tname_len=unique_beg->name_length();
//Aconstantvoidpointertotheuniqueobject
constvoid*value=unique_beg->value();
}

分配对齐的内存部分

[cpp]viewplaincopy#include<boost/interprocess/managed_shared_memory.hpp>
#include<cassert>

intmain()
{
usingnamespaceboost::interprocess;

//Removesharedmemoryonconstructionanddestruction
structshm_remove
{
shm_remove(){shared_memory_object::remove("MySharedMemory");}
~shm_remove(){shared_memory_object::remove("MySharedMemory");}
}remover;

//Managedmemorysegmentthatallocatesportionsofasharedmemory
//segmentwiththedefaultmanagementalgorithm
managed_shared_memorymanaged_shm(create_only,"MySharedMemory",65536);

conststd::size_tAlignment=128;

//Allocate100bytesalignedtoAlignmentfromsegment,throwingversion
void*ptr=managed_shm.allocate_aligned(100,Alignment);

//Checkalignment
assert((static_cast<char*>(ptr)-static_cast<char*>(0))%Alignment==0);

//Deallocateit
managed_shm.deallocate(ptr);

//Nonthrowingversion
ptr=managed_shm.allocate_aligned(100,Alignment,std::nothrow);

//Checkalignment
assert((static_cast<char*>(ptr)-static_cast<char*>(0))%Alignment==0);

//Deallocateit
managed_shm.deallocate(ptr);

//Ifwewanttoefficientlyallocatealignedblocksofmemory
//usemanaged_shared_memory::PayloadPerAllocationvalue
assert(Alignment>managed_shared_memory::PayloadPerAllocation);

//Thisallocationwillmaximizethesizeofthealignedmemory
//andwillincreasethepossibilityoffindingmorealignedmemory
ptr=managed_shm.allocate_aligned
(3*Alignment-managed_shared_memory::PayloadPerAllocation,Alignment);

//Checkalignment
assert((static_cast<char*>(ptr)-static_cast<char*>(0))%Alignment==0);

//Deallocateit
managed_shm.deallocate(ptr);

return0;
}

多种分配函数

[cpp]viewplaincopy//!Allocatesn_elementsofelem_sizebytes.
multiallocation_iteratorallocate_many(std::size_telem_size,std::size_tmin_elements,std::size_tpreferred_elements,std::size_t&received_elements);

//!Allocatesn_elements,eachoneofelem_sizes[i]bytes.
multiallocation_iteratorallocate_many(conststd::size_t*elem_sizes,std::size_tn_elements);

//!Allocatesn_elementsofelem_sizebytes.Nothrowingversion.
multiallocation_iteratorallocate_many(std::size_telem_size,std::size_tmin_elements,std::size_tpreferred_elements,std::size_t&received_elements,std::nothrow_tnothrow);

//!Allocatesn_elements,eachoneofelem_sizes[i]bytes.Nothrowingversion.
multiallocation_iteratorallocate_many(conststd::size_t*elem_sizes,std::size_tn_elements,std::nothrow_tnothrow);

[cpp]viewplaincopy#include<boost/interprocess/managed_shared_memory.hpp>
#include<boost/interprocess/detail/move.hpp>//boost::move
#include<cassert>//assert
#include<cstring>//std::memset
#include<new>//std::nothrow
#include<vector>//std::vector

intmain()
{
usingnamespaceboost::interprocess;
typedefmanaged_shared_memory::multiallocation_chainmultiallocation_chain;

//Removesharedmemoryonconstructionanddestruction
structshm_remove
{
shm_remove(){shared_memory_object::remove("MySharedMemory");}
~shm_remove(){shared_memory_object::remove("MySharedMemory");}
}remover;

managed_shared_memorymanaged_shm(create_only,"MySharedMemory",65536);

//Allocate16elementsof100bytesinasinglecall.Non-throwingversion.
multiallocation_chainchain(managed_shm.allocate_many(100,16,std::nothrow));

//Checkifthememoryallocationwassuccessful
if(chain.empty())return1;

//Allocatedbuffers
std::vector<void*>allocated_buffers;

//Initializeourdata
while(!chain.empty()){
void*buf=chain.front();
chain.pop_front();
allocated_buffers.push_back(buf);
//Theiteratormustbeincrementedbeforeoverwritingmemory
//becauseotherwise,theiteratorisinvalidated.
std::memset(buf,0,100);
}

//Nowdeallocate
while(!allocated_buffers.empty()){
managed_shm.deallocate(allocated_buffers.back());
allocated_buffers.pop_back();
}

//Allocate10buffersofdifferentsizesinasinglecall.Throwingversion
managed_shared_memory::size_typesizes[10];
for(std::size_ti=0;i<10;++i)
sizes[i]=i*3;

chain=managed_shm.allocate_many(sizes,10);
managed_shm.deallocate_many(boost::move(chain));
return0;
}

扩展内存分配

[cpp]viewplaincopyenumboost::interprocess::allocation_type
{
//BitwiseOR(|)combinablevalues
boost::interprocess::allocate_new=...,
boost::interprocess::expand_fwd=...,
boost::interprocess::expand_bwd=...,
boost::interprocess::shrink_in_place=...,
boost::interprocess::nothrow_allocation=...
};

template<classT>
std::pair<T*,bool>
allocation_command(boost::interprocess::allocation_typecommand
,std::size_tlimit_size
,std::size_tpreferred_size
,std::size_t&received_size
,T*reuse_ptr=0);

[cpp]viewplaincopy#include<boost/interprocess/managed_shared_memory.hpp>
#include<cassert>

intmain()
{
usingnamespaceboost::interprocess;

//Removesharedmemoryonconstructionanddestruction
structshm_remove
{
shm_remove(){shared_memory_object::remove("MySharedMemory");}
~shm_remove(){shared_memory_object::remove("MySharedMemory");}
}remover;

//Managedmemorysegmentthatallocatesportionsofasharedmemory
//segmentwiththedefaultmanagementalgorithm
managed_shared_memorymanaged_shm(create_only,"MySharedMemory",10000*sizeof(std::size_t));

//Allocateatleast100bytes,1000bytesifpossible
managed_shared_memory::size_typemin_size=100,preferred_size=1000;
managed_shared_memory::size_typereceived_size;
std::size_t*ptr=managed_shm.allocation_command<std::size_t>
(boost::interprocess::allocate_new,min_size,preferred_size,received_size).first;

//Receivedsizemustbebiggerthanmin_size
assert(received_size>=min_size);

//Getfreememory
managed_shared_memory::size_typefree_memory_after_allocation=managed_shm.get_free_memory();

//Nowwritethedata
for(std::size_ti=0;i<received_size;++i)ptr[i]=i;

//Nowtrytotriplicatethebuffer.Wewon'tadmitanexpansion
//lowertothedoubleoftheoriginalbuffer.
//This"should"besuccessfulsincenootherclassisallocating
//memoryfromthesegment
managed_shared_memory::size_typeexpanded_size;
std::pair<std::size_t*,bool>ret=managed_shm.allocation_command
(boost::interprocess::expand_fwd,received_size*2,received_size*3,expanded_size,ptr);

//Checkinvariants
assert(ret.second==true);
assert(ret.first==ptr);
assert(expanded_size>=received_size*2);

//Getfreememoryandcompare
managed_shared_memory::size_typefree_memory_after_expansion=managed_shm.get_free_memory();
assert(free_memory_after_expansion<free_memory_after_allocation);

//Writenewvalues
for(std::size_ti=received_size;i<expanded_size;++i)ptr[i]=i;

//Trytoshrinkapproximatelytomin_size,butthenewsize
//shouldbesmallerthanmin_size*2.
//This"should"besuccessfulsincenootherclassisallocating
//memoryfromthesegment
managed_shared_memory::size_typeshrunk_size;
ret=managed_shm.allocation_command
(boost::interprocess::shrink_in_place,min_size*2,min_size,shrunk_size,ptr);

//Checkinvariants
assert(ret.second==true);
assert(ret.first==ptr);
assert(shrunk_size<=min_size*2);
assert(shrunk_size>=min_size);

//Getfreememoryandcompare
managed_shared_memory::size_typefree_memory_after_shrinking=managed_shm.get_free_memory();
assert(free_memory_after_shrinking>free_memory_after_expansion);

//Deallocatethebuffer
managed_shm.deallocate(ptr);
return0;
}

用写拷贝或只读模式打开托管共享内存或内存映射文件

[cpp]viewplaincopy#include<boost/interprocess/managed_mapped_file.hpp>
#include<fstream>//std::fstream
#include<iterator>//std::distance

intmain()
{
usingnamespaceboost::interprocess;

//Definefilenames
constchar*ManagedFile="MyManagedFile";
constchar*ManagedFile2="MyManagedFile2";

//Trytoeraseanypreviousmanagedsegmentwiththesamename
file_mapping::remove(ManagedFile);
file_mapping::remove(ManagedFile2);
remove_file_on_destroydestroyer1(ManagedFile);
remove_file_on_destroydestroyer2(ManagedFile2);

{
//Createannamedintegerinamanagedmappedfile
managed_mapped_filemanaged_file(create_only,ManagedFile,65536);
managed_file.construct<int>("MyInt")(0u);

//Nowcreateacopyonwriteversion
managed_mapped_filemanaged_file_cow(open_copy_on_write,ManagedFile);

//Erasetheintandcreateanewone
if(!managed_file_cow.destroy<int>("MyInt"))
throwint(0);
managed_file_cow.construct<int>("MyInt2");

//Checkchanges
if(managed_file_cow.find<int>("MyInt").first&&!managed_file_cow.find<int>("MyInt2").first)
throwint(0);

//Checktheoriginalisintact
if(!managed_file.find<int>("MyInt").first&&managed_file.find<int>("MyInt2").first)
throwint(0);

{//Dumpthemodifiedcopyonwritesegmenttoafile
std::fstreamfile(ManagedFile2,std::ios_base::out|std::ios_base::binary);
if(!file)
throwint(0);
file.write(static_cast<constchar*>(managed_file_cow.get_address()),(std::streamsize)managed_file_cow.get_size());
}

//Nowopenthemodifiedfileandtestchanges
managed_mapped_filemanaged_file_cow2(open_only,ManagedFile2);
if(managed_file_cow2.find<int>("MyInt").first&&!managed_file_cow2.find<int>("MyInt2").first)
throwint(0);
}
{
//Nowcreatearead-onlyversion
managed_mapped_filemanaged_file_ro(open_read_only,ManagedFile);

//Checktheoriginalisintact
if(!managed_file_ro.find<int>("MyInt").first&&managed_file_ro.find<int>("MyInt2").first)
throwint(0);

//Checkthenumberofnamedobjectsusingtheiterators
if(std::distance(managed_file_ro.named_begin(),managed_file_ro.named_end())!=1&&
std::distance(managed_file_ro.unique_begin(),managed_file_ro.unique_end())!=0)
throwint(0);
}
return0;
}

托管堆内存和托管外部缓冲区

托管外部缓冲区：构建所有的Boost.Interprocess对象在用户提供的缓冲区中

[cpp]viewplaincopy//Namedobjectcreationmanagedmemorysegment
//Allobjectsareconstructedinauserprovidedbuffer
template<
classCharType,
classMemoryAlgorithm,
template<classIndexConfig>classIndexType
>
classbasic_managed_external_buffer;

//Namedobjectcreationmanagedmemorysegment
//Allobjectsareconstructedinauserprovidedbuffer
//Namesarec-strings,
//Defaultmemorymanagementalgorithm
//(rbtree_best_fitwithnomutexesandrelativepointers)
//Name-objectmappingsarestoredinthedefaultindextype(flat_map)
typedefbasic_managed_external_buffer<
char,
rbtree_best_fit<null_mutex_family,offset_ptr<void>>,
flat_map_index
>managed_external_buffer;

//Namedobjectcreationmanagedmemorysegment
//Allobjectsareconstructedinauserprovidedbuffer
//Namesarewide-strings,
//Defaultmemorymanagementalgorithm
//(rbtree_best_fitwithnomutexesandrelativepointers)
//Name-objectmappingsarestoredinthedefaultindextype(flat_map)
typedefbasic_managed_external_buffer<
wchar_t,
rbtree_best_fit<null_mutex_family,offset_ptr<void>>,
flat_map_index
>wmanaged_external_buffer;

#include<boost/interprocess/managed_external_buffer.hpp>

[cpp]viewplaincopy#include<boost/interprocess/managed_external_buffer.hpp>
#include<boost/interprocess/allocators/allocator.hpp>
#include<boost/interprocess/containers/list.hpp>
#include<cstring>
#include<boost/aligned_storage.hpp>

intmain()
{
usingnamespaceboost::interprocess;

//Createthestaticmemorywhowillstoreallobjects
constintmemsize=65536;

staticboost::aligned_storage<memsize>::typestatic_buffer;

//Thismanagedmemorywillconstructobjectsassociatedwith
//awidestringinthestaticbuffer
wmanaged_external_bufferobjects_in_static_memory
(create_only,&static_buffer,memsize);

//Weoptimizeresourcestocreate100namedobjectsinthestaticbuffer
objects_in_static_memory.reserve_named_objects(100);

//Aliasanintegernodeallocatortype
//Thisallocatorwillallocatememoryinsidethestaticbuffer
typedefallocator<int,wmanaged_external_buffer::segment_manager>
allocator_t;

//AliasaSTLcompatiblelisttobeconstructedinthestaticbuffer
typedeflist<int,allocator_t>MyBufferList;

//Thelistmustbeinitializedwiththeallocator
//Allobjectscreatedwithobjects_in_static_memorywill
//bestoredinthestatic_buffer!
MyBufferList*list=objects_in_static_memory.construct<MyBufferList>(L"MyList")
(objects_in_static_memory.get_segment_manager());
//Sincetheallocationalgorithmfromwmanaged_external_bufferusesrelative
//pointersandallthepointersconstructedintthestaticmemorypoint
//toobjectsinthesamesegment,wecancreateanotherstaticbuffer
//fromthefirstoneandduplicateallthedata.
staticboost::aligned_storage<memsize>::typestatic_buffer2;
std::memcpy(&static_buffer2,&static_buffer,memsize);

//Nowopentheduplicatedmanagedmemorypassingthememoryasargument
wmanaged_external_bufferobjects_in_static_memory2
(open_only,&static_buffer2,memsize);

//Checkthat"MyList"hasbeenduplicatedinthesecondbuffer
if(!objects_in_static_memory2.find<MyBufferList>(L"MyList").first)
return1;

//Destroythelistsfromthestaticbuffers
objects_in_static_memory.destroy<MyBufferList>(L"MyList");
objects_in_static_memory2.destroy<MyBufferList>(L"MyList");
return0;
}

[cpp]viewplaincopy//Namedobjectcreationmanagedmemorysegment
//Allobjectsareconstructedinasinglebufferallocatedvianew[]
template<
classCharType,
classMemoryAlgorithm,
template<classIndexConfig>classIndexType
>
classbasic_managed_heap_memory;

//Namedobjectcreationmanagedmemorysegment
//Allobjectsareconstructedinasinglebufferallocatedvianew[]
//Namesarec-strings,
//Defaultmemorymanagementalgorithm
//(rbtree_best_fitwithnomutexesandrelativepointers)
//Name-objectmappingsarestoredinthedefaultindextype(flat_map)
typedefbasic_managed_heap_memory<
char,
rbtree_best_fit<null_mutex_family>,
flat_map_index
>managed_heap_memory;

//Namedobjectcreationmanagedmemorysegment
//Allobjectsareconstructedinasinglebufferallocatedvianew[]
//Namesarewide-strings,
//Defaultmemorymanagementalgorithm
//(rbtree_best_fitwithnomutexesandrelativepointers)
//Name-objectmappingsarestoredinthedefaultindextype(flat_map)
typedefbasic_managed_heap_memory<
wchar_t,
rbtree_best_fit<null_mutex_family>,
flat_map_index
>wmanaged_heap_memory;

#include<boost/interprocess/managed_heap_memory.hpp>

[cpp]viewplaincopy#include<boost/interprocess/containers/list.hpp>
#include<boost/interprocess/managed_heap_memory.hpp>
#include<boost/interprocess/allocators/allocator.hpp>
#include<cstddef>

usingnamespaceboost::interprocess;
typedeflist<int,allocator<int,managed_heap_memory::segment_manager>>
MyList;

intmain()
{
//Wewillcreateabufferof1000bytestostorealist
managed_heap_memoryheap_memory(1000);

MyList*mylist=heap_memory.construct<MyList>("MyList")
(heap_memory.get_segment_manager());

//Obtainhandle,thatidentifiesthelistinthebuffer
managed_heap_memory::handle_tlist_handle=heap_memory.get_handle_from_address(mylist);

//Filllistuntilthereisnomorememoryinthebuffer
try{
while(1){
mylist->insert(mylist->begin(),0);
}
}
catch(constbad_alloc&){
//memoryisfull
}
//Let'sobtainthesizeofthelist
MyList::size_typeold_size=mylist->size();

//Tomakethelistbigger,let'sincreasetheheapbuffer
//in1000bytesmore.
heap_memory.grow(1000);

//Ifmemoryhasbeenreallocated,theoldpointerisinvalid,so
//usepreviouslyobtainedhandletofindthenewpointer.
mylist=static_cast<MyList*>
(heap_memory.get_address_from_handle(list_handle));

//Filllistuntilthereisnomorememoryinthebuffer
try{
while(1){
mylist->insert(mylist->begin(),0);
}
}
catch(constbad_alloc&){
//memoryisfull
}

//Let'sobtainthenewsizeofthelist
MyList::size_typenew_size=mylist->size();

assert(new_size>old_size);

//Destroylist
heap_memory.destroy_ptr(mylist);

return0;
}

[cpp]viewplaincopy//Thistestcreatesainmemorydata-baseusingInterprocessmachineryand
//serializesitthroughamessagequeue.Thenrebuildsthedata-basein
//anotherbufferandchecksitagainsttheoriginaldata-base
booltest_serialize_db()
{
//TypedefdatatocreateaInterprocessmap
typedefstd::pair<conststd::size_t,std::size_t>MyPair;
typedefstd::less<std::size_t>MyLess;
typedefnode_allocator<MyPair,managed_external_buffer::segment_manager>
node_allocator_t;
typedefmap<std::size_t,
std::size_t,
std::less<std::size_t>,
node_allocator_t>
MyMap;

//Someconstants
conststd::size_tBufferSize=65536;
conststd::size_tMaxMsgSize=100;

//Allocateamemorybuffertoholdthedestinydatabaseusingvector<char>
std::vector<char>buffer_destiny(BufferSize,0);

message_queue::remove(test::get_process_id_name());
{
//Createthemessage-queues
message_queuemq1(create_only,test::get_process_id_name(),1,MaxMsgSize);

//Openpreviouslycreatedmessage-queuesimulatingotherprocess
message_queuemq2(open_only,test::get_process_id_name());

//Amanagedheapmemorytocreatetheorigindatabase
managed_heap_memorydb_origin(buffer_destiny.size());

//Constructthemapinthefirstbuffer
MyMap*map1=db_origin.construct<MyMap>("MyMap")
(MyLess(),
db_origin.get_segment_manager());
if(!map1)
returnfalse;

//Fillmap1untilisfull
try{
std::size_ti=0;
while(1){
(*map1)[i]=i;
++i;
}
}
catch(boost::interprocess::bad_alloc&){}

//Datacontroldatasendingthroughthemessagequeue
std::size_tsent=0;
message_queue::size_typerecvd=0;
message_queue::size_typetotal_recvd=0;
unsignedintpriority;

//Sendwholefirstbufferthroughthemq1,readit
//throughmq2tothesecondbuffer
while(1){
//Sendafragmentofbuffer1throughmq1
std::size_tbytes_to_send=MaxMsgSize<(db_origin.get_size()-sent)?
MaxMsgSize:(db_origin.get_size()-sent);
mq1.send(&static_cast<char*>(db_origin.get_address())[sent]
,bytes_to_send
,0);
sent+=bytes_to_send;
//Receivethefragmentthroughmq2tobuffer_destiny
mq2.receive(&buffer_destiny[total_recvd]
,BufferSize-recvd
,recvd
,priority);
total_recvd+=recvd;

//Checkifwehavereceivedallthebuffer
if(total_recvd==BufferSize){
break;
}
}

//Thebufferwillcontainacopyoftheoriginaldatabase
//solet'sinterpretthebufferwithmanaged_external_buffer
managed_external_bufferdb_destiny(open_only,&buffer_destiny[0],BufferSize);

//Let'sfindthemap
std::pair<MyMap*,managed_external_buffer::size_type>ret=db_destiny.find<MyMap>("MyMap");
MyMap*map2=ret.first;

//Checkifwehavefoundit
if(!map2){
returnfalse;
}

//Checkifitisasinglevariable(notanarray)
if(ret.second!=1){
returnfalse;
}

//Nowlet'scomparesize
if(map1->size()!=map2->size()){
returnfalse;
}

//Nowlet'scomparealldbvalues
MyMap::size_typenum_elements=map1->size();
for(std::size_ti=0;i<num_elements;++i){
if((*map1)[i]!=(*map2)[i]){
returnfalse;
}
}

//Destroymapsfromdb-s
db_origin.destroy_ptr(map1);
db_destiny.destroy_ptr(map2);
}
message_queue::remove(test::get_process_id_name());
returntrue;
}