interprocess managed_shared_memory Sınıfı

Giriş
Şu satırı dahil ederiz.

#include <boost/interprocess/managed_shared_memory.hpp>

Açıklaması şöyle. Bu sınıfın kardeşi managed_mapped_file

"Boost.Interprocess offers managed shared memory between processes using managed_shared_memory or managed_mapped_file. Two processes just map the same the memory mappable resource and read from and write to that object."

Anladığım kadarıyla bu sınıf bir uygulama yazarken, diğerinin silmesine izin veriyor. Mutex gibi bir yapı ile kilitleyip bırakmaya gerek yok .

Allocator Tanımlama
Saklanacak veri tipi için allocator tanımlanır.

strin Tanımlama Örnekleri
Tanımladığımız boost::interprocess::basic_string nesnesine allocator geçmek gerekir.
Elimizde Foo yapısı olsun.

struct Foo;
typedef allocator<Foo, managed_shared_memory::segment_manager> salloc;

typedef boost::interprocess::basic_string<char, std::char_traits<char>,
 salloc::rebind<char>::other> shared_string;

struct Foo {
  int X, Y, H, W;

  Foo(salloc alloc) : m_str(alloc) {}

  shared_string m_str;
};

Şöyle yaparız.

salloc alloc_inst(managed_shm.get_segment_manager());

Foo foo(alloc_inst);

foo.Label = "Hello World";
foo.H = 1;
foo.W = 1;
foo.Y = 1;
foo.X = 1;

// Construct a vector named "MyVector" in shared memory with argument alloc_inst
typedef vector<Foo, salloc> MyVector;
MyVector *myvector = managed_shm.construct<MyVector>("MyVector")(alloc_inst);

/foo data;
myvector->push_back(foo);

Örnek
Çok küçük bellek alanı tanımlarsak exception fırlatır. Açıklaması şöyle

There's considerable initial overhead, consuming 320 bytes before anything happened.

Şöyle yaparız.

try {
  boost::interprocess::managed_shared_memory managed_shm(
    boost::interprocess::create_only,
    "Demo",
    256);
  std::cout << "success" << std::endl;
}
catch (boost::interprocess::interprocess_exception &ex) {
  std::cout << ex.what() << std::endl;
}

boost::interprocess::vector tanımlama Örnekleri
Şu satırı dahil ederiz.

#include <boost/interprocess/containers/vector.hpp>

Örnek 1
vector of boost::interprocess::basic_string tanımlamak için şöyle yaparız.

typedef allocator<MyShmString, managed_shared_memory::segment_manager>
  StringAllocator;

typedef vector<MyShmString, StringAllocator> MyShmStringVector;

Örnek 2
vector Foo isimli bir struct tutuyor olsun. Şöyle yaparız.

struct Foo;
typedef allocator<Foo, managed_shared_memory::segment_manager> vAllocator;

Vector'u yaratmak için şöyle yaparız.

// Initialize shared memory STL-compatible allocator
vAllocator alloc_inst (managed_shm.get_segment_manager());

// Construct a vector named "MyVector" in shared memory with argument alloc_inst
typedef vector<Foo, salloc> MyVector;
MyVector *myvector = managed_shm.construct<MyVector>("MyVector")(alloc_inst);

Örnek 3
Şöyle yaparız.

namespace bip = boost::interprocess;

typedef unsigned char uchar;
//Typedefs of allocators and containers
typedef bip::managed_shared_memory::segment_manager        segment_manager_t;
typedef bip::allocator<void, segment_manager_t>  void_allocator;

typedef void_allocator::rebind<uchar>::other  uchar_allocator;
typedef bip::vector<uchar, uchar_allocator>   uchar_vector;

Yardımcı Sınıf

Belleği temiz yaratmak ve temizlemek için şöyle yaparız.

struct shm_remove
{
  shm_remove(){shared_memory_object::remove("MySharedMemory");}
  ~shm_remove(){shared_memory_object::remove("MySharedMemory");}
}remover;

Ayrılan Bellek Alanı Yetersiz Gelirse
Açıklaması şöyle.

Every time a segment is grown, the OS is free to reallocate the whole memory chunk, and then, all pointers to that memory become invalid. Then, test_vector could point to invalid memory after growing. Try mapping the segment again, this time with the open_only option and use managed_shared_memory::find to reach to your vector.

Örnek
Şöyle yaparız.

void append(int value) {
  try {
    test_vector->push_back(value);
  } catch (std::exception & e) {  // Grow shared memory if out of memory
    managed_shared_memory::grow(SHMEM_NAME.data(), 1000);
    // Re-map the shared memory segment
    segment = new managed_shared_memory(open_only, SHMEM_NAME.data());
     // Find the vector object in the newly mapped shared memory segment
     std::pair<ShmemVector*, size_t> return_value = segment->find<ShmemVector>
      ("ShmemVector");
     test_vector = return_value.first;
     // Append the value
     test_vector->push_back(value);
  }
}

Constructor
Şöyle yaparız

// Create a new segment with given name and size
managed_shared_memory segment(create_only,"MySharedMemory",65536);

construct metodu
Şöyle yaparız

StringAllocator stringallocator(segment.get_segment_manager());
MyShmStringVector *myshmvector = segment.construct<MyShmStringVector>("MyVector")
  (stringallocator);

Daha sonra bu vector'e string eklenebilir.

std::string sName = ...;
myshmvector->push_back(sName(pBuf));

destroy metodu
Şöyle yaparız

segment.destroy<MyShmStringVector>("MyVector");

find metodu
Şöyle yaparız

// Find the vector using c-string name
MyShmStringVector *myvector = segment.find<MyShmStringVector>("MyVector").first;

MyShmStringVector::iterator it;

for(it = myvector->begin(); it !=myvector->end(); ++it){
  ...
}

find_or_construct metodu
Şöyle yaparız.

auto* v = segment.find_or_construct<MyShmStringVector>("MyVector")
 (segment.get_segment_manager()).first;

get_free_memory metodou
Şöyle yaparız.

std::cout << segment.get_free_memory() << std::endl;

get_segment_manager metodu
Tanımladığımız allocator'ları ilklendirmek için parametre olarak geçeriz. Şöyle yaparız.

//Initialize shared memory STL-compatible allocator
CharAllocator charallocator(segment.get_segment_manager());
StringAllocator stringallocator(segment.get_segment_manager());

Şöyle yaparız.

Struct1Vector svector(segment.get_segment_manager());