मैं एल्गोरिदम पास करने वाले संदेश को कार्यान्वित कर रहा हूं। संदेशों को आसन्न नोड्स के बीच गुजरता है जब उनके पास संदेश लिखने के लिए नोड पर पर्याप्त जानकारी होती है - जानकारी जो पड़ोसी नोड्स से नोड को पास की जाती है। कार्यान्वयन छोटा होता है यदि मैं प्रत्येक संदेश को धागा बना देता हूं और बूंद को स्थिति को तब तक सोता हूं जब तक आवश्यक जानकारी उपलब्ध न हो जाए।किसी शर्त पर प्रतीक्षा करने के लिए गैर-थ्रेडेड विकल्प। (संपादित करें: boost.asio के साथ प्रोक्टर पैटर्न?)
दुर्भाग्यवश - मेरे पास ग्राफ में 100k नोड्स हैं जिसका अर्थ 300k धागे होगा। जब मैं asked कितने धागे को उत्तर देने का उत्तर था कि मुझे नहीं करना चाहिए - और इसके बजाय फिर से डिज़ाइन करना चाहिए।
मेरा प्रश्न है: क्या किसी शर्त की प्रतीक्षा के लिए मानक डिजाइन पैटर्न है? शायद कुछ असीमित नियंत्रण पैटर्न?
संपादित करें: मुझे लगता है कि मैं इसे प्रोएकेटर पैटर्न के साथ कर सकता हूं। मैंने बूस्ट :: एएसओओ को शामिल करने के लिए टैग में संपादित किया है - यह देखने के लिए कि क्या इसके साथ कोई सुझाव है या नहीं।
तो चर्चा ठोस हो सकता है, तो यहां संदेशों अब तक निर्धारित किए जाते हैं:
class
Message
{
public:
Message(const Node* from, Node* to)
: m_from(from), m_to(to)
{}
void
operator()()
{
m_to->ReceiveMessage(m_from->ComposeMessage());
}
private:
Node *m_from, *m_to;
};
ये संदेश functors वर्तमान में बढ़ावा :: धागा के साथ शुरू कर रहे हैं। फिर हम
class Node
{
Node(Node* Neighbour1, Node* Neighbour2, Node* Neighbour3);
// The messages (currently threads) are created on construction,
// The condition locks then sort out when they actually get passed
// without me having to think too hard.
void ReceiveMessage(const Message&);
//set m_message from received messages;
//EDIT This looks like an async write - use boost asio here?
Message
ComposeMessage()
{
// If possible I want to implement this function without threads
// It works great but it if every message is a thread
// then I have 300k threads.
// EDIT: this looks like an async read (use boost asio here?)
boost::mutex::scoped_lock lock(m_mutex);
while (!m_message) //lock the thread until parameter is set.
m_cond.wait(lock);
return *m_message;
}
private:
boost::optional<Message> m_message;
boost::mutex m_mutex;
boost::condition m_cond;
}
मैं कोड की पारदर्शिता पसंद है और यदि संभव हो तो सशर्त ताला करने के लिए कुछ विकल्प होने से एक ही इंटरफेस रखने के लिए करना चाहते हैं?
लगता है जैसे आप सीएसपी को कम या ज्यादा कम कर रहे हैं। एक सीएसपी पुस्तकालय खोजने के बारे में जो यह सब आपके लिए करता है? – jalf
@ जैफ - मुझे लगता है कि आप सही हैं। मैंने सीएसपी के बारे में नहीं सुना था (मुझे नहीं पता था कि कंप्यूटर साइंस मुझे अंत में प्राप्त करेगा)। ऐसा लगता है कि मेरे पास कुछ करने के लिए कुछ गुगल है ... – Tom