📝 🆑 ☁️ C ++ 11 में अतुल्यकालिक कार्य ⚪️ 👩🏼‍🎤 👨🏾‍✈️

अच्छे दिन, मैं अपनी छोटी सी लाइब्रेरी को समुदाय के साथ साझा करना चाहूंगा।

मैं C / C ++ में प्रोग्राम करता हूं, और, दुर्भाग्य से, कामकाजी परियोजनाओं में मैं C ++ 11 मानक का उपयोग नहीं कर सकता हूं। लेकिन फिर मई की छुट्टियां आईं, खाली समय दिखाई दिया और मैंने इस निषिद्ध फल का प्रयोग करने और अध्ययन करने का फैसला किया। सीखने के लिए सबसे अच्छी चीज अभ्यास है। एक प्रोग्रामिंग भाषा पर लेख पढ़ना आपको बेहतर पढ़ना सिखाएगा, इसलिए मैंने कार्यों के अतुल्यकालिक निष्पादन के लिए एक छोटी सी लाइब्रेरी लिखने का फैसला किया।

तुरंत एक आरक्षण करें जो मुझे पता है कि std :: future, std :: async और इतने पर है। मुझे अपने समान कुछ महसूस करने और अपने सिर के साथ लैम्ब्डा कार्यों, थ्रेड्स और म्यूटेक्स की दुनिया में उतरने में दिलचस्पी थी। छुट्टियां साइकिल चलाने के लिए एक अच्छा समय है।

तो चलिए शुरू करते हैं

मैंने तय किया कि मेरा पुस्तकालय निम्नानुसार कार्य करेगा।

थ्रेड की निश्चित संख्या के साथ कुछ पूल है।

लैम्ब्डा फ़ंक्शन के सिंटैक्स का उपयोग करके इसमें कार्य जोड़े जाते हैं।

कार्य से ही, आप इसके कार्यान्वयन का परिणाम निकाल सकते हैं, या बस इसके काम के अंत की प्रतीक्षा कर सकते हैं।

आगे देखते हुए, यह कुछ इस तरह दिखता है:

... act::control control(N_THREADS); auto some_task = act::make_task([](std::vector<double>::const_iterator begin, std::vector<double>::const_iterator end) { double sum = 0; for (auto i = begin; i != end; ++i) { sum+=(*i); } return sum; } , data.begin(), data.end()); control << some_task; cout << some_task->get() << endl; ...

टास्क क्लास

पहले आपको एक वर्ग बनाने की ज़रूरत है जो कार्य का वर्णन करता है:

 template <typename T> class task : public task<decltype(&T::operator())> { }; template <typename ClassType, typename ReturnType, typename ... Args> class task<ReturnType(ClassType::*)(Args...) const> { protected: const ClassType &m_func; std::tuple<Args...> m_vars; ReturnType m_return; public: task(const ClassType &v, Args... args): m_func(v), m_vars(args ...) {} virtual ~task() {} private: };

जैसा कि आप जानते हैं, एक लांबा फ़ंक्शन को ऑपरेटर () ऑपरेटर के साथ एक फ़नकार वर्ग में विस्तारित किया जाता है।

हमारा कार्य वर्ग टेम्प्लेट है, इसका प्रकार फ़नरेटर ऑपरेटर और टी :: ऑपरेटर के प्रकार से निकाला जाता है।

क्लास एक फ़ाइटर के लिए एक पॉइंटर को स्टोर करता है, std :: tuple और एक रिटर्न वैल्यू के रूप में कार्य करता है।

तो अब हम लैम्बडा फ़ंक्शन को ऑब्जेक्ट में मापदंडों के साथ स्टोर कर सकते हैं, अब हमें यह सीखने की जरूरत है कि इसे कैसे कॉल किया जाए।

ऐसा करने के लिए, m_vun में संग्रहीत मापदंडों के साथ m_func पर opertator () को कॉल करें।

शुरुआत से, मुझे नहीं पता था कि यह कैसे करना है, लेकिन Google के बढ़ते उपयोग और दूसरी कड़ी में संक्रमण के परिणामस्वरूप परिणाम आया:

  template<int ...> struct seq { }; template<int N, int ...S> struct gens : gens<N-1, N-1, S...> { }; template<int ...S> struct gens<0, S...> { typedef seq<S...> type; };

इस निर्माण का उपयोग करते हुए, आप निम्न कार्यों को कक्षा में जोड़ सकते हैं:

  ... public: void invoke() { ReturnType r = caller(typename gens<sizeof...(Args)>::type()); } private: template<int ...S> ReturnType caller(seq<S...>) const { return m_func(std::get<S>(m_vars) ...); } ...

कार्य का आधार वर्ग

अब हम कार्य के आधार वर्ग को लागू करते हैं:

  class abstract_task { protected: mutable std::mutex m_mutex; mutable std::condition_variable m_cond_var; mutable bool m_complete; public: abstract_task(): m_complete(false) {} virtual ~abstract_task() {} virtual void invoke() = 0; virtual void wait() const { std::unique_lock<std::mutex> lock(m_mutex); while (!m_complete) { m_cond_var.wait(lock); } } };

कक्षा में एक म्यूटेक्स और एक राज्य चर होता है जो कार्य के पूरा होने का संकेत देता है। तदनुसार, हमारी समस्या का वर्ग कुछ परिवर्तनों को भुगतना होगा, जिसे मैं छोड़ दूंगा, क्योंकि स्रोत कोड गितुब पर उपलब्ध है।

निर्माण कार्य

आइए कार्य बनाने के लिए एक आवरण कार्य करें:

  template <typename T, typename ... Args> std::shared_ptr<task<decltype(&T::operator())>> make_task(T func, Args ... args ) { return std::shared_ptr<task<decltype(&T::operator())>>(new task<decltype(&T::operator())>(func, args ...)); }

चूंकि हमारे पास एक वर्चुअल क्लास है, इसलिए पॉइंटर का उपयोग करना तार्किक है और हम इसे करेंगे, और न केवल एक पॉइंटर, बल्कि एक स्मार्ट पॉइंटर।

प्रबंधन वर्ग

अब हम पृष्ठभूमि थ्रेड्स में कार्यों को निष्पादित करने के लिए एक इकाई को लागू करते हैं।

मैं केवल कोड का हिस्सा दूंगा:

 ... class control { std::deque<std::shared_ptr<abstract_task>> m_tasks; std::vector<std::thread> m_pool; std::mutex m_mutex; std::condition_variable m_cond_var; std::condition_variable m_empty_cond; std::atomic<bool> m_run; std::vector<bool> m_active; public: control(std::size_t pool_size = 2) { m_run.store(true, std::memory_order_relaxed); auto func = [this](int n) { while (m_run.load(std::memory_order_relaxed)) { std::unique_lock<std::mutex> lock(m_mutex); m_active[n] = true; if (m_tasks.empty()) { m_empty_cond.notify_all(); m_active[n] = false; m_cond_var.wait(lock); } else { std::shared_ptr<abstract_task> t = m_tasks.front(); m_tasks.pop_front(); lock.unlock(); t->invoke(); lock.lock(); m_active[n] = false; } } }; pool_size = pool_size > 0 ? pool_size : 1; m_active.resize(pool_size, false); for(std::size_t i = 0; i < pool_size; ++i) { m_pool.emplace_back(func, i); } } ...

मज़े के लिए, मैंने नए मानक की सभी विशेषताओं का उपयोग किया, जिनमें से आवेदन मैं किसी भी तरह से उचित ठहरा सकता था।

यह वर्ग बाल धागों द्वारा कार्यों के निष्पादन की निगरानी के लिए थ्रेड्स की एक सरणी और एक्टिविटी स्टेट वेरिएबल्स की एक सरणी बनाता है।

बच्चे के धागे का मुख्य लूप एक परमाणु चर द्वारा नियंत्रित किया जाता है (सिद्धांत रूप में, इसे अस्थिर घोषित करने के लिए पर्याप्त था, क्योंकि कोई दौड़ राज्य नहीं है, मुख्य धागा केवल इसे लिखता है, और बच्चे केवल इसे पढ़ते हैं)

उत्पादकता

मैं इस लेख को सबसे अधिक संभावना नहीं लिखूंगा यदि यह मेरे समाधान के प्रदर्शन परीक्षण के लिए नहीं थे std :: async की तुलना में।

विन्यास:

इंटेल कोर (TM) i7-2600 CPU @ 3.40GHz

$ जीसी --version

जीसीसी (डेबियन 4.8.2-21) 4.8.2

परीक्षण में सरणियों के समानांतर जोड़ होते हैं, और फिर सभी परिवर्धन के परिणामों के अतुल्यकालिक जोड़ होते हैं। ऑपरेशन का परिणाम होगा:

res = sum (array) * N_P

संख्या मिलीसेकंड में हैं।

परीक्षण 1

अनुकूलन बंद कर दिया गया है, सरणी में तत्वों की संख्या 100,000,000 है, उत्पन्न कार्यों की संख्या 73 है, पूल में थ्रेड्स की संख्या 6 है

परिणाम:

test_act 16775 ठीक है

test_async 16028 ठीक है

प्रदर्शन तुलनीय है।

परीक्षण २

अनुकूलन सक्षम किया गया है, सरणी में तत्वों की संख्या 100,000,000 है, उत्पन्न कार्यों की संख्या 73 है, पूल में थ्रेड्स की संख्या 6 है

परिणाम:

test_act 1597.6 ठीक है

test_async 2530.5 ठीक है

मेरा कार्यान्वयन डेढ़ गुना तेज है।

परीक्षण ३

अनुकूलन सक्षम किया गया है, सरणी में तत्वों की संख्या 100,000,000 है, उत्पन्न कार्यों की संख्या 73 है, पूल में थ्रेड्स की संख्या 7 है

परिणाम:

test_act 1313.1 ठीक है

test_async 2503.7 ठीक है

टेस्ट 4

अनुकूलन सक्षम है, सरणी में तत्वों की संख्या 100,000,000 है, उत्पन्न कार्यों की संख्या 73 है, पूल में थ्रेड्स की संख्या 8 है

परिणाम:

test_act 1402 ठीक है

test_async 2492.2 ठीक है

परीक्षण ५

अनुकूलन सक्षम है, सरणी में तत्वों की संख्या 100,000,000 है, उत्पन्न कार्यों की संख्या 173 है, पूल में थ्रेड्स की संख्या 8 है

परिणाम:

test_act 4435.7 ठीक है

test_async 5789.4 ठीक है

निष्कर्ष और कीड़े

ये परिणाम इस तथ्य के कारण सबसे अधिक संभावना है कि async प्रत्येक कार्य के लिए अपना स्वयं का थ्रेड बनाता है, मेरे कार्यान्वयन में थ्रेड्स की संख्या निर्धारित है और उनके निर्माण के लिए कोई ओवरहेड नहीं है।

बग - एक लैम्ब्डा फ़ंक्शन में स्कोप गुंजाइश वेरिएबल ([] के माध्यम से) को SIGSEGV कहते हैं। हालांकि उन्हें मापदंडों के माध्यम से स्थानांतरित करना ठीक काम करता है।

मुझे नहीं पता कि यह लेख और पुस्तकालय स्वयं कितने उपयोगी हैं, लेकिन कम से कम मैंने अपने व्यवहार में नए मानक की कुछ विशेषताएं लागू कीं।

स्रोत कोड

C ++ 11 में अतुल्यकालिक कार्य