增强，共享内存和向量

我需要在进程之间共享一堆字符串（将来可能会有更复杂的对象）。我决定使用boost :: interprocess，但我无法让它工作。我确信这是因为我不理解某些东西。我遵循他们的例子，但如果有人使用该库的经验可以看看我的代码并告诉我什么是错误的，我将非常感激。问题似乎有效，但经过几次迭代后，我在读取器进程和写入器进程上都会遇到各种异常。下面是我实现的一个简化版本：增强，共享内存和向量

using namespace boost::interprocess; 
class SharedMemoryWrapper 
{ 
public: 
    SharedMemoryWrapper(const std::string & name, bool server) : 
     m_name(name), 
     m_server(server) 
    { 
     if (server) 
     { 
      named_mutex::remove("named_mutex"); 
      shared_memory_object::remove(m_name.c_str()); 
      m_segment = new managed_shared_memory (create_only,name.c_str(),65536);   
      m_stackAllocator = new StringStackAllocator(m_segment->get_segment_manager()); 
      m_stack = m_segment->construct<StringStack>("MyStack")(*m_stackAllocator); 
     } 
     else 
     { 
      m_segment = new managed_shared_memory(open_only ,name.c_str()); 
      m_stack = m_segment->find<StringStack>("MyStack").first; 
     } 
     m_mutex = new named_mutex(open_or_create, "named_mutex"); 
    } 

    ~SharedMemoryWrapper() 
    { 
     if (m_server) 
     { 
      named_mutex::remove("named_mutex"); 
      m_segment->destroy<StringStack>("MyStack"); 
      delete m_stackAllocator; 
      shared_memory_object::remove(m_name.c_str()); 
     } 
     delete m_mutex; 
     delete m_segment; 
    } 

    void push(const std::string & in) 
    { 
     scoped_lock<named_mutex> lock(*m_mutex); 
     boost::interprocess::string inStr(in.c_str()); 
     m_stack->push_back(inStr); 
    } 
    std::string pop() 
    { 
     scoped_lock<named_mutex> lock(*m_mutex); 
     std::string result = ""; 
     if (m_stack->size() > 0) 
     { 
      result = std::string(m_stack->begin()->c_str()); 
      m_stack->erase(m_stack->begin()); 
     } 
     return result; 
    } 
private: 
    typedef boost::interprocess::allocator<boost::interprocess::string, boost::interprocess::managed_shared_memory::segment_manager> StringStackAllocator; 
    typedef boost::interprocess::vector<boost::interprocess::string, StringStackAllocator> StringStack; 
    bool m_server; 
    std::string m_name; 
    boost::interprocess::managed_shared_memory * m_segment; 
    StringStackAllocator * m_stackAllocator; 
    StringStack * m_stack; 
    boost::interprocess::named_mutex * m_mutex; 
};

编辑编辑使用named_mutex。原始代码使用了不正确的interprocess_mutex，但这不是问题。

EDIT2我还应该注意到事情总结到一定程度。编写器进程可以在阅读器中断之前推送几个小字符串（或一个非常大的字符串）。阅读器以m_stack-> begin（）行不引用有效字符串的方式中断。这是垃圾。然后再执行会抛出一个异常。

EDIT3我修改了类，使用boost :: interprocess :: string而不是std :: string。读卡器仍然失效，内存地址无效。这里是读者/写者

//reader process 
SharedMemoryWrapper mem("MyMemory", true); 
std::string myString; 
int x = 5; 
do 
{ 
    myString = mem.pop(); 
    if (myString != "") 
    { 
     std::cout << myString << std::endl; 
    } 
} while (1); //while (myString != ""); 

//writer 
SharedMemoryWrapper mem("MyMemory", false); 
for (int i = 0; i < 1000000000; i++) 
{ 
    std::stringstream ss; 
    ss << i; //causes failure after few thousand iterations 
    //ss << "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" << i; //causes immediate failure 
    mem.push(ss.str()); 
} 
return 0;

来源

2009-04-23 Budric

我对以前的海报非常抱歉。我点击了“删除”，并删除了我原来的这个完全相同的问题。 – Budric 2009-04-23 21:34:57

你不能取消删除？或者这只适用于答案？ – 2009-04-23 21:38:16

有几件事情让我想起你的实现。一种是使用指向名为mutex对象的指针，而大多数boost库的文档往往会向后弯曲而不使用指针。这导致我要求参考您在构建自己的测试用例时所使用的程序片段，因为我曾经有过类似的不幸事件，有时唯一的出路是回到示例，并一次一步地前进我遇到了突变。

另一件似乎有问题的事情是你为共享内存分配了一个65k块，然后在你的测试代码中，循环到1000000000，每次迭代将一个字符串推入你的栈中。

现代PC能够执行每微秒和更多1000条指令，而像Windows这样的操作系统仍然在15毫秒内完成执行量。块，溢出堆栈不会很长。这将是我第一次猜测为什么事情是不合时宜的。

P.S. 我刚刚从修复我的名字返回类似于我的实际身份的东西。然后，讽刺的是，我对你的问题的回答一直在浏览器页面的左上角盯着我们！（当然，假设我是对的，在这个行业中情况往往不是这样）。

来源

2009-07-13 18:55:00

-3

嗯可能共享内存不是你的问题开始的正确设计。但是我们不知道，因为我们不知道你想要达到什么目标。

来源

2009-04-23 23:27:55 lothar

增强，共享内存和向量

回答

相关问题