C # एसिंक्रोनस प्रोग्रामिंग: आप प्रदर्शन के साथ कैसे कर रहे हैं?

हाल ही में, हमने पहले ही बात की कि क्या C # में प्रोग्रामिंग करते समय Equals और GetHashCode को ओवरराइड किया जाए। आज हम अतुल्यकालिक विधियों के प्रदर्शन मापदंडों से निपटेंगे। अब सम्मिलित हों!



Msdn ब्लॉग पर पिछले दो लेखों में, हमने C # में अतुल्यकालिक तरीकों की आंतरिक संरचना को देखा और विस्तार बिंदु बताते हैं कि C # संकलक अतुल्यकालिक तरीकों के व्यवहार को नियंत्रित करने के लिए प्रदान करता है।

पहले लेख में जानकारी के आधार पर, कंपाइलर अतुल्यकालिक प्रोग्रामिंग को यथासंभव तुल्यकालिक बनाने के लिए कई परिवर्तन करता है। ऐसा करने के लिए, वह राज्य मशीन का एक उदाहरण बनाता है, इसे अतुल्यकालिक विधि के बिल्डर को भेजता है, जो कार्य के लिए वेटर ऑब्जेक्ट को कॉल करता है, आदि, बेशक, इस तरह के तर्क की कीमत होती है, लेकिन यह हमें कितना खर्च करता है?

जब तक टीपीएल पुस्तकालय दिखाई नहीं दिया, तब तक अतुल्यकालिक संचालन इतनी बड़ी मात्रा में उपयोग नहीं किए गए थे, इसलिए, लागत अधिक नहीं थी। लेकिन आज, एक अपेक्षाकृत सरल अनुप्रयोग भी सैकड़ों प्रदर्शन कर सकता है, यदि हजारों नहीं, अतुल्यकालिक संचालन प्रति सेकंड। टीपीएल समानांतर टास्क लाइब्रेरी ऐसे कार्यभार को ध्यान में रखकर बनाई गई थी, लेकिन यहां कोई जादू नहीं है और आपको हर चीज के लिए भुगतान करना होगा।

अतुल्यकालिक तरीकों की लागत का अनुमान लगाने के लिए, हम पहले लेख से थोड़ा संशोधित उदाहरण का उपयोग करेंगे।

public class StockPrices { private const int Count = 100; private List<(string name, decimal price)> _stockPricesCache; // Async version public async Task<decimal> GetStockPriceForAsync(string companyId) { await InitializeMapIfNeededAsync(); return DoGetPriceFromCache(companyId); } // Sync version that calls async init public decimal GetStockPriceFor(string companyId) { InitializeMapIfNeededAsync().GetAwaiter().GetResult(); return DoGetPriceFromCache(companyId); } // Purely sync version public decimal GetPriceFromCacheFor(string companyId) { InitializeMapIfNeeded(); return DoGetPriceFromCache(companyId); } private decimal DoGetPriceFromCache(string name) { foreach (var kvp in _stockPricesCache) { if (kvp.name == name) { return kvp.price; } } throw new InvalidOperationException($"Can't find price for '{name}'."); } [MethodImpl(MethodImplOptions.NoInlining)] private void InitializeMapIfNeeded() { // Similar initialization logic. } private async Task InitializeMapIfNeededAsync() { if (_stockPricesCache != null) { return; } await Task.Delay(42); // Getting the stock prices from the external source. // Generate 1000 items to make cache hit somewhat expensive _stockPricesCache = Enumerable.Range(1, Count) .Select(n => (name: n.ToString(), price: (decimal)n)) .ToList(); _stockPricesCache.Add((name: "MSFT", price: 42)); } } 

StockPrices क्लास एक बाहरी स्रोत से स्टॉक की कीमतों को StockPrices और आपको एपीआई के माध्यम से उन्हें अनुरोध करने की अनुमति देता है। पहले लेख में उदाहरण से मुख्य अंतर एक शब्दकोश से कीमतों की एक सूची में संक्रमण है। तुल्यकालिक तरीकों की तुलना में विभिन्न अतुल्यकालिक तरीकों की लागत का अनुमान लगाने के लिए, ऑपरेशन को स्वयं एक निश्चित कार्य करना होगा, हमारे मामले में यह स्टॉक की कीमतों के लिए एक रैखिक खोज है।

GetPricesFromCache विधि जानबूझकर संसाधन आवंटन से बचने के लिए एक साधारण लूप के चारों ओर बनाई गई है।

तुल्यकालिक विधियों और कार्य-आधारित अतुल्यकालिक विधियों की तुलना

पहले प्रदर्शन परीक्षण में, हम अतुल्यकालिक पद्धति की तुलना करते हैं जो अतुल्यकालिक आरंभीकरण विधि ( GetStockPriceForAsync ) को कहते हैं, सिंक्रोनस विधि जो अतुल्यकालिक आरंभीकरण विधि ( GetStockPriceFor ) को कॉल करती है, और तुल्यकालिक विधि जो सिंक्रोनस आरंभीकरण विधि को कॉल करती है।

 private readonly StockPrices _stockPrices = new StockPrices(); public SyncVsAsyncBenchmark() { // Warming up the cache _stockPrices.GetStockPriceForAsync("MSFT").GetAwaiter().GetResult(); } [Benchmark] public decimal GetPricesDirectlyFromCache() { return _stockPrices.GetPriceFromCacheFor("MSFT"); } [Benchmark(Baseline = true)] public decimal GetStockPriceFor() { return _stockPrices.GetStockPriceFor("MSFT"); } [Benchmark] public decimal GetStockPriceForAsync() { return _stockPrices.GetStockPriceForAsync("MSFT").GetAwaiter().GetResult(); } 

परिणाम नीचे दिखाए गए हैं:



पहले से ही इस स्तर पर हमें काफी दिलचस्प आंकड़े मिले हैं:

• अतुल्यकालिक विधि बहुत तेज है। GetPricesForAsync इस परीक्षण में समकालिक रूप से चलता है और विशुद्ध रूप से तुल्यकालिक विधि की तुलना में लगभग 15% (*) धीमा है।
• सिंक्रोनस GetPricesFor विधि, जिसे एसिंक्रोनस InitializeMapIfNeededAsync विधि कहते हैं, की लागत भी कम है, लेकिन सबसे आश्चर्यजनक रूप से, यह संसाधनों को आवंटित नहीं करता है (उपरोक्त तालिका में आवंटित कॉलम में, यह GetPricesDirectlyFromCache और GetStockPriceFor दोनों के लिए लागत 0 है।

(*) बेशक, यह नहीं कहा जा सकता है कि एसिंक्रोनस पद्धति को सिंक्रोनाइज़ करने की लागत सभी संभावित मामलों के लिए 15% है। यह मान सीधे विधि द्वारा निष्पादित कार्यभार पर निर्भर करता है। एक अतुल्यकालिक विधि (जो कुछ नहीं करता है) और एक तुल्यकालिक विधि (जो कुछ नहीं करता है) के शुद्ध आह्वान के ओवरहेड के बीच का अंतर बहुत बड़ा होगा। इस तुलनात्मक परीक्षण का विचार यह दिखाना है कि अतुल्यकालिक विधि की लागत, जो अपेक्षाकृत कम मात्रा में कार्य करती है, अपेक्षाकृत कम हैं।

यह कैसे है कि जब आप InitializeMapIfNeededAsync कहते हैं, तो संसाधन बिल्कुल आवंटित नहीं होते हैं? इस श्रृंखला के पहले लेख में, मैंने उल्लेख किया है कि एक अतुल्यकालिक विधि को प्रबंधित हेडर में कम से कम एक ऑब्जेक्ट आवंटित करना चाहिए - कार्य उदाहरण स्वयं। आइए इस बिंदु पर अधिक विस्तार से चर्चा करें।

अनुकूलन # 1: जब संभव हो तो कैशिंग कार्य उदाहरण

उपरोक्त प्रश्न का उत्तर बहुत सरल है: AsyncMethodBuilder प्रत्येक सफलतापूर्वक पूरा किए गए अतुल्यकालिक ऑपरेशन के लिए कार्य के एक उदाहरण का उपयोग करता है । एसिंक्रोनस विधि जो Task रिटर्न का उपयोग करता है वह SetResult को SetResult तर्क पद्धति में निम्नलिखित तर्क के साथ करता है:

 // AsyncMethodBuilder.cs from mscorlib public void SetResult() { // Ie the resulting task for all successfully completed // methods is the same -- s_cachedCompleted. m_builder.SetResult(s_cachedCompleted); } 

SetResult विधि SetResult केवल सफलतापूर्वक पूरा किए गए अतुल्यकालिक तरीकों के लिए कहा जाता है, और प्रत्येक Task आधारित विधि के लिए एक सफल परिणाम का उपयोग स्वतंत्र रूप से एक साथ किया जा सकता है । हम निम्नलिखित परीक्षण के साथ भी इस व्यवहार का पता लगा सकते हैं:

 [Test] public void AsyncVoidBuilderCachesResultingTask() { var t1 = Foo(); var t2 = Foo(); Assert.AreSame(t1, t2); async Task Foo() { } } 

लेकिन यह एकमात्र संभव अनुकूलन नहीं है। AsyncTaskMethodBuilder<T> एक समान तरीके से काम का अनुकूलन करता है: यह Task<bool> और कुछ अन्य सरल प्रकारों के लिए कार्यों को कैश करता है। उदाहरण के लिए, यह पूर्णांक प्रकारों के समूह के लिए सभी डिफ़ॉल्ट मानों को कैश करता है और Task<int> लिए एक विशेष कैश का उपयोग करता है, मानों को रेंज से [-1; 9] (अधिक जानकारी के लिए, AsyncTaskMethodBuilder<T>.GetTaskForResult() ) देखें।

यह निम्नलिखित परीक्षण द्वारा पुष्टि की गई है:

 [Test] public void AsyncTaskBuilderCachesResultingTask() { // These values are cached Assert.AreSame(Foo(-1), Foo(-1)); Assert.AreSame(Foo(8), Foo(8)); // But these are not Assert.AreNotSame(Foo(9), Foo(9)); Assert.AreNotSame(Foo(int.MaxValue), Foo(int.MaxValue)); async Task<int> Foo(int n) => n; } 

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

अनुकूलन # 2: ValueTask का उपयोग करना

ऊपर वर्णित अनुकूलन विधि केवल कुछ मामलों में काम करती है। इसलिए, इसके बजाय, हम ValueTask<T> (**) का उपयोग कर सकते हैं, कार्य के समान एक विशेष प्रकार का मूल्य; यदि संसाधन समकालिक रूप से चलता है तो यह संसाधनों को आवंटित नहीं करेगा।

ValueTask<T> T और Task<T> ValueTask<T> का एक अलग संयोजन है: यदि "value-task" पूरा हो गया है, तो आधार मान का उपयोग किया जाएगा। यदि मूल आवंटन अभी तक समाप्त नहीं हुआ है, तो कार्य के लिए संसाधन आवंटित किए जाएंगे।

यह विशेष प्रकार एक ऑपरेशन को सिंक्रोनाइज़ करते समय अत्यधिक हीप प्रोविजनिंग को रोकने में मदद करता है। ValueTask<T> उपयोग करने के लिए, आपको GetStockPriceForAsync लिए रिटर्न प्रकार को बदलने की आवश्यकता है: Task<decimal> बजाय Task<decimal> ValueTask<decimal> निर्दिष्ट करना चाहिए:

 public async ValueTask<decimal> GetStockPriceForAsync(string companyId) { await InitializeMapIfNeededAsync(); return DoGetPriceFromCache(companyId); } 

अब हम एक अतिरिक्त तुलनात्मक परीक्षण का उपयोग करके अंतर का मूल्यांकन कर सकते हैं:

 [Benchmark] public decimal GetStockPriceWithValueTaskAsync_Await() { return _stockPricesThatYield.GetStockPriceValueTaskForAsync("MSFT").GetAwaiter().GetResult(); } 

जैसा कि आप देख सकते हैं, ValueTask वाला संस्करण टास्क वाले संस्करण की तुलना में थोड़ा तेज है। मुख्य अंतर यह है कि ढेर आवंटन को रोका जाता है। एक मिनट में हम इस तरह के संक्रमण की व्यवहार्यता पर चर्चा करेंगे, लेकिन इससे पहले मैं एक मुश्किल अनुकूलन के बारे में बात करना चाहूंगा।

अनुकूलन नंबर 3: एक सामान्य पथ के भीतर अतुल्यकालिक तरीकों को छोड़ना

यदि आप अक्सर कुछ अतुल्यकालिक विधि का उपयोग करते हैं और लागत को और भी कम करना चाहते हैं, तो मैं आपको निम्नलिखित अनुकूलन का सुझाव देता हूं: एस्किंस संशोधक को हटा दें, और फिर विधि के अंदर कार्य की स्थिति की जांच करें और पूरे ऑपरेशन को तुल्यकालिक रूप से निष्पादित करें, पूरी तरह से अतुल्यकालिक दृष्टिकोण को छोड़ दें।

जटिल लग रहा है? एक उदाहरण पर विचार करें।

 public ValueTask<decimal> GetStockPriceWithValueTaskAsync_Optimized(string companyId) { var task = InitializeMapIfNeededAsync(); // Optimizing for acommon case: no async machinery involved. if (task.IsCompleted) { return new ValueTask<decimal>(DoGetPriceFromCache(companyId)); } return DoGetStockPricesForAsync(task, companyId); async ValueTask<decimal> DoGetStockPricesForAsync(Task initializeTask, string localCompanyId) { await initializeTask; return DoGetPriceFromCache(localCompanyId); } } 

इस स्थिति में, async संशोधक का उपयोग GetStockPriceWithValueTaskAsync_Optimized विधि में नहीं किया जाता है, इसलिए जब इसे InitializeMapIfNeededAsync विधि से कोई कार्य प्राप्त होता है, तो यह इसकी निष्पादन स्थिति की जांच करता है। यदि कार्य पूरा हो गया है, तो विधि तुरंत परिणाम प्राप्त करने के लिए DoGetPriceFromCache का उपयोग DoGetPriceFromCache है। यदि प्रारंभिक कार्य अभी भी प्रगति पर है, तो विधि एक स्थानीय फ़ंक्शन को कॉल करती है और परिणामों की प्रतीक्षा करती है।

स्थानीय फ़ंक्शन का उपयोग करना केवल एकमात्र नहीं है, बल्कि सबसे आसान तरीकों में से एक है। लेकिन एक कैविएट है। सबसे प्राकृतिक कार्यान्वयन के दौरान, स्थानीय फ़ंक्शन को एक बाहरी राज्य (स्थानीय चर और तर्क) प्राप्त होगा:

 public ValueTask<decimal> GetStockPriceWithValueTaskAsync_Optimized2(string companyId) { // Oops! This will lead to a closure allocation at the beginning of the method! var task = InitializeMapIfNeededAsync(); // Optimizing for acommon case: no async machinery involved. if (task.IsCompleted) { return new ValueTask<decimal>(DoGetPriceFromCache(companyId)); } return DoGetStockPricesForAsync(); async ValueTask<decimal> DoGetStockPricesForAsync() { await task; return DoGetPriceFromCache(companyId); } } 

लेकिन, दुर्भाग्य से, एक संकलक त्रुटि के कारण , यह कोड एक क्लोजर उत्पन्न करेगा, भले ही वह विधि सामान्य पथ के भीतर निष्पादित हो। यहां बताया गया है कि यह विधि अंदर से कैसी दिखती है:

 public ValueTask<decimal> GetStockPriceWithValueTaskAsync_Optimized(string companyId) { var closure = new __DisplayClass0_0() { __this = this, companyId = companyId, task = InitializeMapIfNeededAsync() }; if (closure.task.IsCompleted) { return ... } // The rest of the code } 

जैसा कि लेख में चर्चा की गई है कि C # में स्थानीय कार्यों को भंग कर रहा है , संकलक एक विशिष्ट क्षेत्र में सभी स्थानीय चर और तर्कों के लिए बंद होने के एक सामान्य उदाहरण का उपयोग करता है। नतीजतन, ऐसी कोड पीढ़ी में कुछ समझदारी होती है, लेकिन यह पूरे संघर्ष को बेकार बना देता है।

टीआईपी । इस तरह के अनुकूलन एक बहुत ही कपटी बात है। लाभ नगण्य हैं, और यहां तक ​​कि अगर आप सही मूल स्थानीय फ़ंक्शन लिखते हैं, तो आप गलती से एक बाहरी राज्य प्राप्त कर सकते हैं जो ढेर को आवंटित करने का कारण बनता है। आप अभी भी अनुकूलन का सहारा ले सकते हैं यदि आप एक सामान्य रूप से उपयोग किए गए पुस्तकालय (उदाहरण के लिए, बीसीएल) के साथ एक विधि में काम करते हैं जो निश्चित रूप से कोड के लोड किए गए अनुभाग पर उपयोग किया जाएगा।

किसी कार्य की प्रतीक्षा करने से संबंधित लागतें

फिलहाल, हमने केवल एक विशिष्ट मामले पर विचार किया है: एक अतुल्यकालिक विधि का ओवरहेड जो समकालिक रूप से चलता है। यह उद्देश्य पर किया जाता है। जितना छोटा अतुल्यकालिक तरीका है, उतना ही ध्यान देने योग्य इसके समग्र प्रदर्शन में लागतें हैं। अधिक विस्तृत अतुल्यकालिक तरीके, एक नियम के रूप में, समकालिक रूप से चलते हैं और एक छोटा कार्यभार करते हैं। और हम आमतौर पर उन्हें अधिक बार कहते हैं।

लेकिन हमें अतुल्यकालिक तंत्र की लागतों के बारे में पता होना चाहिए जब एक उत्कृष्ट कार्य के पूरा होने के लिए विधि "इंतजार" करती है। इन लागतों का अनुमान लगाने के लिए, हम InitializeMapIfNeededAsync परिवर्तन करेंगे और कैश प्रारंभ होने पर भी Task.Yield() को कॉल करेंगे:

 private async Task InitializeMapIfNeededAsync() { if (_stockPricesCache != null) { await Task.Yield(); return; } // Old initialization logic } 

हम तुलनात्मक परीक्षण के लिए अपने बेंचमार्क पैकेज में निम्नलिखित तरीके जोड़ते हैं:

 [Benchmark] public decimal GetStockPriceFor_Await() { return _stockPricesThatYield.GetStockPriceFor("MSFT"); } [Benchmark] public decimal GetStockPriceForAsync_Await() { return _stockPricesThatYield.GetStockPriceForAsync("MSFT").GetAwaiter().GetResult(); } [Benchmark] public decimal GetStockPriceWithValueTaskAsync_Await() { return _stockPricesThatYield.GetStockPriceValueTaskForAsync("MSFT").GetAwaiter().GetResult(); } 

जैसा कि आप देख सकते हैं, अंतर स्पष्ट है - दोनों गति के संदर्भ में, और स्मृति उपयोग के संदर्भ में। संक्षेप में परिणाम बताएं।

• अपूर्ण कार्य के लिए प्रत्येक प्रतीक्षा ऑपरेशन में लगभग 4 माइक्रोसेकंड लगते हैं और प्रत्येक कॉल के लिए लगभग 300 बाइट्स (**) आवंटित करते हैं। यही कारण है कि GetStockPriceFor लगभग दो बार GetStockPriceForAsync के रूप में तेजी से चलता है और कम मेमोरी आवंटित करता है।
• ValueTask पर आधारित एक एसिंक्रोनस विधि टास्क के साथ वेरिएंट की तुलना में थोड़ा अधिक समय लेती है, जब इस विधि को सिंक्रोनाइज़ नहीं किया जाता है। ValueTask पर आधारित एक विधि की एक राज्य मशीन <T> टास्क <T> पर आधारित विधि की एक राज्य मशीन की तुलना में अधिक डेटा संग्रहीत करना चाहिए।

(**) यह प्लेटफ़ॉर्म (x64 या x86) और कई स्थानीय चर और अतुल्यकालिक विधि के तर्कों पर निर्भर करता है।

अतुल्यकालिक विधि प्रदर्शन 101

• यदि एसिंक्रोनस विधि तुल्यकालिक रूप से चलती है, तो ओवरहेड बहुत छोटा है।
• यदि एसिंक्रोनस विधि को समकालिक रूप से निष्पादित किया जाता है, तो निम्न मेमोरी ओवरहेड होती है: एसिंक्स टास्क विधियों के लिए, कोई ओवरहेड नहीं है, और एसिंक्स टास्क <टी> विधियों के लिए, ओवररन प्रति ऑपरेशन 88 xtes (x 64 प्लेटफार्मों के लिए) है।
• ValueTask <T> सिंक्रोनस तरीके से निष्पादित अतुल्यकालिक तरीकों के लिए उपर्युक्त ओवरहेड को समाप्त करता है।
• जब ValueTask पर आधारित एक अतुल्यकालिक विधि <T> को सिंक्रोनस रूप से निष्पादित किया जाता है, तो टास्क <T> के साथ विधि की तुलना में थोड़ा कम समय लगता है, अन्यथा दूसरे विकल्प के पक्ष में मामूली अंतर होते हैं।
• अधूरा काम पूरा करने के लिए प्रतीक्षा कर रहे अतुल्यकालिक तरीकों के लिए प्रदर्शन ओवरहेड काफी अधिक है (लगभग 300 बाइट्स प्रति ऑपरेशन xx प्लेटफॉर्म के लिए)।

बेशक, माप हमारे सब कुछ हैं। यदि आप देखते हैं कि एक एसिंक्रोनस ऑपरेशन प्रदर्शन समस्याओं का कारण बन रहा है, तो आप Task<T> से ValueTask<T> स्विच कर सकते हैं, Task<T> को कैश कर सकते हैं, या यदि संभव हो तो समग्र निष्पादन पथ को तुल्यकालिक बना सकते हैं। आप अपने अतुल्यकालिक ऑपरेशनों को संयोजित करने का भी प्रयास कर सकते हैं। यह प्रदर्शन को बेहतर बनाने, डिबगिंग को सरल बनाने और कोड विश्लेषण को सामान्य बनाने में मदद करेगा। कोड का हर छोटा टुकड़ा एसिंक्रोनस नहीं होना चाहिए।