boost interprocess

Giriş
boost interprocess sadece header dosyalardan oluşur.
boost ile shared memory kullanmak için şu adımlar izlenmeli.
1. Önce bir shared memory alanı yaratılmalı.
2. Allocator yarat.
3. Container yarat
4. Diğer uygulamalar ile eşzamanlılığı sağlamak için bir interprocess mutex kullanılmalı.

Daha kolay kodlamak için şu satır dahil edilir.

using boost::interprocess;

shared_memory_object sınıfı
boost interprocess shared memory yazısına taşıdım.

remove_shared_memory_on_destroy sınıfı
Aslında yardımcı sınıf gibi düşünülebilir. Nesne yok olunca shared memory belleğinin de silinmesini garanti eder.

remove_shared_memory_on_destroy remove_on_destroy("MySharedMemory");
{
  ...
}

managed_shared_memory sınıfı
managed_shared_memory Sınıfı yazısına taşıdım.

xsi_shared_memory Sınıfı
boost interprocess shared memory yazısına taşıdım.

windows_shared_memory Sınıfı
boost interprocess shared memory yazısına taşıdım.

void_allocator sınıfı
Şu satırı dahil ederiz.

#include <boost/interprocess/allocators/allocator.hpp>

Şöyle yaparız.

void_allocator alloc_inst (segment.get_segment_manager());

list sınıfı
Şu satırı dahil ederiz.

#include <boost/interprocess/allocators/allocator.hpp>
#include <boost/interprocess/containers/list.hpp>

Şöyle tanımlarız.

namespace bip = boost::interprocess;

typedef int my_big_struct;

namespace shared {
  using segment = bip::managed_mapped_file;
  using manager = segment::segment_manager;

  template <typename T> using alloc = bip::allocator<T, manager>;
  template <typename T> using list  = boost::interprocess::list<T, alloc<T> >;
}

int main()
{
  using List   = shared::list<my_big_struct>;
  using ItList = shared::list<List::const_iterator>;
  ...
}

Liste veye iterator bir segment ile şöyle kullanılır.

shared::segment segment = ...;
auto& a = *segment.find_or_construct<List>("a")(segment.get_segment_manager());
auto& b = *segment.find_or_construct<ItList>("b")(segment.get_segment_manager());

vector sınıfı
Şu satırı dahil ederiz.

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

map sınıfı
Şu satırı dahil ederiz.

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

string sınıfı
Şu satırı dahil ederiz.

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

Şöyle yaparız.

typedef bi::allocator<char, bi::managed_shared_memory::segment_manager> 
CharAllocator; 
typedef bi::basic_string<char, std::char_traits<char>, CharAllocator> my_string;

named_condition sınıfı
constructor
Şöyle yaparız.

named_condition cond (create_only_t(), "...");

remove metodu

Şöyle yaparız.

boost::interprocess::named_condition::remove("...")); 

named_mutex sınıfı
constructor

Şöyle yaparız.

boost::interprocess::named_mutex* mut
 (boost::interprocess::create_only_t(), "...");

remove metodu

Şöyle yaparız.

boost::interprocess::named_mutex::remove("..."); 

named_recursive_mutex sınıfı
constructor
Şöyle tanımlarız.

#include <boost/interprocess/sync/named_recursive_mutex.hpp>
boost::interprocess::named_recursive_mutex mut(
    boost::interprocess::open_or_create, "MY_SHARED_MUTEX_123");

managed_shared_memory Sınıfı

Giriş
Şu satırı dahil ederiz.

#include <boost/interprocess/managed_shared_memory.hpp>

Bu sınıf ile managed_mapped_file sınıfı arayüz olarak çok benziyorlar.

Bu sınıf Windows'ta backend olarak basic_managed_windows_shared_memory sınıfını kullanıyor. System V işletim sisteminde ise backend olarak basic_managed_xsi_shared_memory sınıfını kullanıyor. Her iki sınıfın ortak noktaları az olduğu için shmid değerini dışarı veremiyor.

constructor
Belleğin bölük bölük kullanılmasına izin verir. Yaratmak için şöyle yaparız.

//Create shared memory
managed_shared_memory segment (create_only,"MySharedMemory", 65536);

Varsa açar, yoksa yaratır. Şöyle yaparız

managed_shared_memory segment (open_or_create,"MySharedMemory", 65536);

Şöyle yaparız.

boost::interprocess::permissions perm; 
perm.set_unrestricted ()
managed_shared_memory segment(create_only_t(), "...", 42768, NULL, perm );

construct metodu
Yaratılan nesneye bir isim vermemiz gerekir. Şöyle yaparız.

segment.construct<MyType> ("Test") (0, 0.2);

Yaratılan nesneye bellek alanı da sağlamak gerekebilir.

segment.construct<my_string>("Test")(
            "Message to other process",
            segment.get_segment_manager());

find metodu
İsim ile daha önce yaratılan nesneye erişim sağlar.

std::pair<my_string * , size_t > p= mshm.find<my_string>("Test");
cout<< "got " << p.second << " strings " << endl;
cout<< "first string is->"<<p.first->c_str()<<endl;

find_or_construct metodu

Elimizde şöyle typdefler olsun

typedef int KeyType;

typedef boost::container::basic_string<..., ..., ... > MappedType;

typedef std::pair<KeyType, MappedType> ValueType;
typedef boost::interprocess::allocator<ValueType, ...> ShmAlloc;
typedef boost::unordered_map<KeyType, MappedType, ..., ..., ... > ShmHashMap;

Şöyle yaparız.

ShmHashMap *hash_map = segment.find_or_construct<ShmHashMap>
 (unique_instance)(segment.get_segment_manager());

boost interprocess shared memory

Giriş
Bu yazı shared memory belleğinin sadece byte dizisi şeklinde nasıl kullanılacağını gösteriyor. Daha karmaşık veri yapılarını kullanabilmek için Managed Memory Segments sınıflarına bakılmalı.

1. Önce bir shared memory_object nesnesi yaratılmalı.
Not : Daha özel amaçlar için
Windows'a özel windows_shared_memory,
Unix'e özel xsi_shared_memory,
Unix'e özel anonymous_shared_memory

sınıflarından birisi de kullanılabilir.

2. shared_memory_object nesnesinin uzunluğunu ata
3. mapped_region nesnesi ile belleği uygulamaya dahil et.
4. mapped_region nesnesini byte dizisi gibi kullanarak belleğe okuma yazma işlemleri gerçekleştir

Daha kolay kodlamak için şu satır dahil edilir.

using boost::interprocess;

Ya da şöyle yaparız.

namespace ipc = boost::interprocess;

shared_memory_object Sınıfı

shared_memory_object Sınıfı yazısına taşıdım.

mapped_region sınıfı
Şu satırı dahil ederiz.

#include <boost/interprocess/mapped_region.hpp>

constructor

Salt okunur işlem için şöyle yaparız.

//Open already created shared memory object.
windows_shared_memory shm (open_only, "shm", read_only);

//Map the whole shared memory in this process
mapped_region region(shm, read_only);

Hem okunur hem yazılır işlem için şöyle yaparız.

//Create a shared memory object
shared_memory_object shm(create_only, "MySharedMemory", read_write);

//Set size to 1
shm.truncate(1);

//Map the whole shared memory in this process
mapped_region region(shm, read_write);

get_addres metodu

region.get_address() ile döndürülen belleği kullanabiliriz.

char *myChar= static_cast<char*>(region.get_address());

get_size metodu

Şöyle yaparız

char *mem = static_cast<char*>(region.get_address());

for (std::size_t i = 0; i < region.get_size(); ++i)
{
  std::cout << "Memory value: " << (int)*mem << "\n";
  mem++;
}

xsi_shared_memory sınıfı

Şöyle yaparız.

#include <boost/interprocess/xsi_shared_memory.hpp>
#include <boost/interprocess/mapped_region.hpp>

using namespace boost::interprocess;

int main(int argc, char *argv[])
{
  //Build XSI key (ftok based)
  xsi_key key(argv[0], 1);
  //Create a shared memory object.
  xsi_shared_memory shm (create_only, key, 1000);
  // TODO Remove if exists
  printf("shmid: %d\n", shm.get_shmid());
}

Bu sınıfın shmid alanını şöyle görebiliriz.




ipcs -m

key        shmid      owner      perms      bytes      nattch     status      
0x00005feb 0          root       666        12000      2                       
0x00005fe7 32769      root       666        524288     2                       
0x00005fe8 65538      root       666        2097152    2                       
0x0001c08e 98307      root       777        2072       0       




windows_shared_memory sınıfı

Windows'ta shared memory bu kaynağı kullanan en son uygulama sonlanınca işletim sistemi tarafından otomatik olarak yok edilir. Posix sistemlerde ise shared memory nesnesi kalıcıdır. Uygulamaların yaşam döngüsünden bağımsızdır. Her iki yöntemi birleştirmek için boost interprocess windows'ta memory mapped file kullanır.  Eğer bu yöntemi istemiyorsak windows_shared_memory sınıfını kullanırız. Şu satırı dahil ederiz.

#include <boost/interprocess/windows_shared_memory.hpp>

Yazmak için shared memory şöyle yaratılır.

//Create a native windows shared memory object.
windows_shared_memory shm (create_only, "shm", read_write, 65536);

Okumak için shared memory şöyle yaratılır.

//Open already created shared memory object.
windows_shared_memory shm (open_only, "shm", read_only);