मुझे प्रक्रियाओं (संभवतः भविष्य में अधिक जटिल वस्तुओं) के बीच तारों का एक ढेर साझा करने की आवश्यकता है। मैंने बूस्ट :: इंटरप्रोसेस का उपयोग करने का निर्णय लिया है लेकिन मैं इसे काम नहीं कर सकता। मुझे यकीन है कि ऐसा इसलिए है क्योंकि मैं कुछ समझ नहीं रहा हूं। मैंने उनके उदाहरण का पालन किया, लेकिन अगर मैं उस लाइब्रेरी का उपयोग करने के अनुभव वाले किसी व्यक्ति को अपना कोड देख सकता हूं और मुझे बता सकता है कि क्या गलत है, तो मैं वास्तव में इसकी सराहना करता हूं। समस्या यह है कि ऐसा लगता है लेकिन कुछ पुनरावृत्तियों के बाद मुझे पाठक प्रक्रिया और कभी-कभी लेखक प्रक्रिया पर सभी प्रकार के अपवाद मिलते हैं। यहाँ मेरी कार्यान्वयन का एक सरलीकृत संस्करण है:बूस्ट, साझा मेमोरी और वेक्टर
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-> प्रारंभ() एक वैध स्ट्रिंग का संदर्भ नहीं देता है। यह कचरा है। और फिर आगे निष्पादन एक अपवाद फेंकता है।
EDIT3 मैंने std :: string के बजाय boost :: interprocess :: 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;
मुझे पिछले पोस्टर के लिए बहुत खेद है। मैंने गलती से "हटाएं" पर क्लिक किया और इस सटीक प्रश्न के मूल पोस्ट को मिटा दिया। – Budric
क्या आप मिटा नहीं सकते? या क्या यह केवल उत्तर के लिए काम करता है? –
क्या मुझे आपकी इनलाइन विधियों के आकार पर गड़बड़ करने की अनुमति है? या क्या यह मुझे सी ++ नोब के रूप में चिह्नित करता है? –