Как переслать объявление пользовательского unique_ptr для разделяемой памяти - PullRequest
Новая
       8

Как переслать объявление пользовательского unique_ptr для разделяемой памяти

0 голосов
/ 03 января 2019

Я взял приведенный ниже пример из книги д-ра Риана Куинна «Практическое системное программирование на C / C ++», которая немного изменилась. Оборачивает mmap с помощью unique_ptr {}. Это работает почти так же, как мне нужно. Я хотел бы переслать объявление указателя на отображенную память, чтобы я мог использовать его в качестве члена частного класса. Мое приложение является многозадачным, каждое из которых имеет однопоточный режим работы в режиме реального времени с общей памятью для взаимодействия между задачами. У доктора Куинна есть второй пример с общей памятью, который немного длиннее, чем показанный здесь, но этот иллюстрирует проблему. Shm_open / mmap относительно дорогостоящий по времени. Мне нужно, чтобы это было сделано один раз во время установки, и я не знаю, как это сделать. Я знаю, как сделать это с помощью сырых указателей. Я использую g ++ 4.8.5.

Я пробовал: 

std::unique_ptr<myStruct,mmap_deleter> ptr;

Что приводит к: 

 /usr/include/c++/4.8.2/tuple:132:22: error: no matching function for call to ‘mmap_deleter::mmap_deleter()’
   : _M_head_impl() { }

#include <memory>
#include <iostream>

#include <string.h>
#include <sys/mman.h>

constexpr auto PROT_RW = PROT_READ | PROT_WRITE;
constexpr auto MAP_ALLOC = MAP_PRIVATE | MAP_ANONYMOUS;

class mmap_deleter
{
    std::size_t m_size;

public:
    mmap_deleter(std::size_t size) :
        m_size{size}
    { }

    void operator()(void *ptr) const
    {
        munmap(ptr, m_size);
    }
};

template<typename T>
auto mmap_unique()
{
    if (auto ptr = mmap(0, sizeof(T), PROT_RW, MAP_ALLOC, -1, 0)) {

        auto obj = new (ptr) T(args...);
        auto del = mmap_deleter(sizeof(T));

        return std::unique_ptr<T, mmap_deleter>(obj, del);
    }

    throw std::bad_alloc();
}

struct myStruct{
    double foo;
    double bar;
};
// Forward declare pointer, neither compiles
std::unique_ptr<myStruct> ptr;
// or
// std::unique_ptr<myStruct,mmap_deleter> ptr;

int main()
{
    ptr = mmap_unique<myStruct>();
    ptr->foo = 55.;
    std::cout << ptr->foo << '\n';
}

Вот глупый пример, который будет компилироваться и запускаться с использованием необработанного указателя, который иллюстрирует, что я хочу сделать с помощью умного указателя. 

// myClass.h
class myClass
{
public:
    myClass();
    ~myClass();
    int get_i();
    int get_j();
private:
    void myFunc1();
    void myFunc2();
    void myFunc3();

    struct myStruct{
         int i;
         int j;
    };
// FORWARD Declaration of ptr here!!!!!!!!!!!!!!!!!!!!!
// I would like to use a smart pointer
    myStruct* ptr_myStruct{nullptr};
};
#include <sys/mman.h>
#include <iostream>
#include <string.h>
#include <cerrno>
//#include "myClass.h"
myClass::myClass(){
   // Set the pointer to the mmap'ed address
   ptr_myStruct = (myStruct*)mmap(NULL,sizeof(myStruct),PROT_READ|PROT_WRITE,MAP_SHARED|MAP_ANONYMOUS, -1, 0);
   memset(ptr_myStruct,0,sizeof(myStruct));
   // The three member functions use ptr_myStruct
   myFunc1();
   myFunc2();
   myFunc3();
}

myClass::~myClass(){
   munmap(ptr_myStruct,sizeof(myStruct));
   ptr_myStruct = nullptr;
}

void myClass::myFunc1(){
ptr_myStruct->i++;
}
void myClass::myFunc2(){
ptr_myStruct->j++;
}
void myClass::myFunc3(){
ptr_myStruct->i++;
}
int myClass::get_i(){return ptr_myStruct->i;}
int myClass::get_j(){return ptr_myStruct->j;}
int main(){
  myClass a;
  std::cout<< a.get_i()<<"   "<<a.get_j()<<"\n";
}

Ответы [ 2 ]

0 голосов
/ 03 января 2019

Линия 

std::unique_ptr<myStruct,mmap_deleter> ptr;

пытается конструкция по умолчанию a mmap_deleter, потому что это определение объекта. Ваш конструктор size_t подавляет сгенерированное компилятором значение по умолчанию (здесь для вас хорошо ).

Вместо этого вы можете предоставить его в качестве параметра шаблона, который также позволяет применять ~T к вашим объектам по мере необходимости. 

template <typename T>
struct mmap_deleter
{
    void operator()(T* ptr) const
    {
        ptr->~T();
        munmap(ptr, sizeof(T));
    }
};

template<typename T, typename... Args>
std::unique_ptr<T, mmap_deleter<T>> mmap_unique(Args&&... args)
{
    if (auto ptr = mmap(0, sizeof(T), PROT_RW, MAP_ALLOC, -1, 0)) {

        return { new (ptr) T(std::forward<Args>(args)...) };
    }

    throw std::bad_alloc();
}
0 голосов
/ 03 января 2019

После некоторого массирования ваш код компилируется и работает (я добавил несколько отладочных отпечатков, чтобы продемонстрировать это), см. живой пример .(Также имейте в виду, что mmap_deleter не вызывает деструктор obj, но должен).

Учитывая, что вы используете C ++ 14, я бы предложил удалить mmap_deleter и упроститьследующий код: 

template <typename T>
using unique_mapped_ptr = std::unique_ptr<T, void(*)(T*)>;

template<typename T, typename ...Args>
unique_mapped_ptr<T> mmap_unique(Args... args)
{
    constexpr auto PROT_RW = PROT_READ | PROT_WRITE;
    constexpr auto MAP_ALLOC = MAP_PRIVATE | MAP_ANONYMOUS;

    if (auto ptr = mmap(0, sizeof(T), PROT_RW, MAP_ALLOC, -1, 0)) {
        return {
            new (ptr) T{args...},
            [](T*p) {
                p->~T();
                munmap(p, sizeof(T));
            }
        };
    }

    throw std::bad_alloc();
}

Затем вы можете использовать unique_mapped_ptr<myStruct> для определения указателей на отображаемые объекты.

См. пример с myClass.

...