इस मामले में कास्ट का उपयोग करने के ओवरहेड को क्या समझा सकता है?

9

मैं यहां दीवार के खिलाफ अपना सिर पीट रहा हूं, इसलिए मुझे उम्मीद है कि आप में से कुछ मुझे शिक्षित करने में सक्षम हो सकते हैं। मैं बेंचमार्कडॉटनेट का उपयोग करते हुए कुछ प्रदर्शन बेंचमार्क कर रहा था और मैं इस अजीब मामले में भाग गया, जहां ऐसा लगता है कि सदस्य के constप्रदर्शन को काफी कम घोषित कर रहा है ।

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
using System;

namespace PerfTest
{
    [DisassemblyDiagnoser(printAsm: true, printSource: true)]
    public class Test
    {
        private int[] data;
        private int Threshold = 90;
        private const int ConstThreshold = 90;

        [GlobalSetup]
        public void GlobalSetup()
        {
            data = new int[1000];
            var random = new Random(42);
            for (var i = 0; i < data.Length; i++)
            {
                data[i] = random.Next(100);
            }
        }

        static void Main(string[] args)
        {
            var summary = BenchmarkRunner.Run<Test>();
        }

        [Benchmark(Baseline = true)]
        public void ClampToMemberValue()
        {
            for (var i = 0; i < data.Length; i++)
            {
                if (data[i] > Threshold) data[i] = Threshold;
            }
        }

        [Benchmark]
        public void ClampToConstValue()
        {
            for (var i = 0; i < data.Length; i++)
            {
                if (data[i] > ConstThreshold) data[i] = ConstThreshold;
            }
        }
    }
}

ध्यान दें कि दो परीक्षण विधियों के बीच एकमात्र अंतर यह है कि क्या वे एक नियमित सदस्य चर या एक सदस्य सदस्य के खिलाफ तुलना करते हैं।

बेंचमार्कडॉटनेट के अनुसार कास्ट वैल्यू का उपयोग करना काफी धीमा है और मुझे समझ नहीं आता कि क्यों।

BenchmarkDotNet=v0.11.5, OS=Windows 10.0.18362
Intel Core i7-5820K CPU 3.30GHz (Broadwell), 1 CPU, 12 logical and 6 physical cores
.NET Core SDK=3.0.100
  [Host]     : .NET Core 3.0.0 (CoreCLR 4.700.19.46205, CoreFX 4.700.19.46214), 64bit RyuJIT
  DefaultJob : .NET Core 3.0.0 (CoreCLR 4.700.19.46205, CoreFX 4.700.19.46214), 64bit RyuJIT


|             Method |     Mean |    Error |   StdDev | Ratio |
|------------------- |---------:|---------:|---------:|------:|
| ClampToMemberValue | 590.4 ns | 1.980 ns | 1.852 ns |  1.00 |
|  ClampToConstValue | 724.6 ns | 4.184 ns | 3.709 ns |  1.23 |

जेआईटी संकलित कोड को देखकर यह स्पष्ट नहीं करता है कि जहां तक ​​मैं बता सकता हूं। यहाँ दो तरीकों के लिए कोड है। फर्क सिर्फ इतना है कि तुलना एक रजिस्टर या शाब्दिक के खिलाफ की जाती है।

00007ff9`7f1b8500 PerfTest.Test.ClampToMemberValue()
            for (var i = 0; i < data.Length; i++)
                 ^^^^^^^^^
00007ff9`7f1b8504 33c0            xor     eax,eax
            for (var i = 0; i < data.Length; i++)
                            ^^^^^^^^^^^^^^^
00007ff9`7f1b8506 488b5108        mov     rdx,qword ptr [rcx+8]
00007ff9`7f1b850a 837a0800        cmp     dword ptr [rdx+8],0
00007ff9`7f1b850e 7e2e            jle     00007ff9`7f1b853e
00007ff9`7f1b8510 8b4910          mov     ecx,dword ptr [rcx+10h]
                if (data[i] > Threshold) data[i] = Threshold;
                ^^^^^^^^^^^^^^^^^^^^^^^^
00007ff9`7f1b8513 4c8bc2          mov     r8,rdx
00007ff9`7f1b8516 458b4808        mov     r9d,dword ptr [r8+8]
00007ff9`7f1b851a 413bc1          cmp     eax,r9d
00007ff9`7f1b851d 7324            jae     00007ff9`7f1b8543
00007ff9`7f1b851f 4c63c8          movsxd  r9,eax
00007ff9`7f1b8522 43394c8810      cmp     dword ptr [r8+r9*4+10h],ecx
00007ff9`7f1b8527 7e0e            jle     00007ff9`7f1b8537
                if (data[i] > Threshold) data[i] = Threshold;
                                         ^^^^^^^^^^^^^^^^^^^^
00007ff9`7f1b8529 4c8bc2          mov     r8,rdx
00007ff9`7f1b852c 448bc9          mov     r9d,ecx
00007ff9`7f1b852f 4c63d0          movsxd  r10,eax
00007ff9`7f1b8532 47894c9010      mov     dword ptr [r8+r10*4+10h],r9d
            for (var i = 0; i < data.Length; i++)
                                             ^^^
00007ff9`7f1b8537 ffc0            inc     eax
00007ff9`7f1b8539 394208          cmp     dword ptr [rdx+8],eax
00007ff9`7f1b853c 7fd5            jg      00007ff9`7f1b8513
        }
        ^
00007ff9`7f1b853e 4883c428        add     rsp,28h

तथा

00007ff9`7f1a8500 PerfTest.Test.ClampToConstValue()
            for (var i = 0; i < data.Length; i++)
                 ^^^^^^^^^
00007ff9`7f1a8504 33c0            xor     eax,eax
            for (var i = 0; i < data.Length; i++)
                            ^^^^^^^^^^^^^^^
00007ff9`7f1a8506 488b5108        mov     rdx,qword ptr [rcx+8]
00007ff9`7f1a850a 837a0800        cmp     dword ptr [rdx+8],0
00007ff9`7f1a850e 7e2d            jle     00007ff9`7f1a853d
                if (data[i] > ConstThreshold) data[i] = ConstThreshold;
                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
00007ff9`7f1a8510 488bca          mov     rcx,rdx
00007ff9`7f1a8513 448b4108        mov     r8d,dword ptr [rcx+8]
00007ff9`7f1a8517 413bc0          cmp     eax,r8d
00007ff9`7f1a851a 7326            jae     00007ff9`7f1a8542
00007ff9`7f1a851c 4c63c0          movsxd  r8,eax
00007ff9`7f1a851f 42837c81105a    cmp     dword ptr [rcx+r8*4+10h],5Ah
00007ff9`7f1a8525 7e0f            jle     00007ff9`7f1a8536
                if (data[i] > ConstThreshold) data[i] = ConstThreshold;
                                              ^^^^^^^^^^^^^^^^^^^^^^^^^
00007ff9`7f1a8527 488bca          mov     rcx,rdx
00007ff9`7f1a852a 4c63c0          movsxd  r8,eax
00007ff9`7f1a852d 42c74481105a000000 mov   dword ptr [rcx+r8*4+10h],5Ah
            for (var i = 0; i < data.Length; i++)
                                             ^^^
00007ff9`7f1a8536 ffc0            inc     eax
00007ff9`7f1a8538 394208          cmp     dword ptr [rdx+8],eax
00007ff9`7f1a853b 7fd3            jg      00007ff9`7f1a8510
        }
        ^
00007ff9`7f1a853d 4883c428        add     rsp,28h

मुझे यकीन है कि वहाँ कुछ है जिसे मैंने अनदेखा किया है, लेकिन मैं इसे इस बिंदु पर नहीं कर सकता, इसलिए मैं इस बारे में इनपुट की तलाश कर रहा हूं कि यह क्या समझा सकता है।

c#  performance  benchmarkdotnet 
— ब्रायन रासमुसेन
स्रोत
@OlivierRogier मुझे डिबग में चलने पर बेंचमार्कडॉटनेट फेल होना याद है।
— युफोरिक
वास्तव में, स्टॉपवॉच का उपयोग करने से साबित होता है कि कास्ट इंट का उपयोग करना एक साधारण * a ... पर फ़ील्ड की तुलना में थोड़ा धीमा है, भले ही IL कोड अधिक ऑपरेंड का उपयोग करता हो।
— ओलिवियर रोजियर
1
बेंचमार्कडॉटनेट 12.0 और .नेट फ्रेमवर्क 4,8 का उपयोग करते हुए, मैं प्रश्न से सटीक कोड निष्पादित करता हूं और x86 में चलने पर दो तरीकों के बीच के परिणामों में कोई सार्थक अंतर नहीं देखता। मैं x64 पर स्विच करते समय मनाया गया अंतर देख सकता हूं।
— निनेबॉर्न
cmpऔर movनिर्देश जो स्थिरांक पथ के लिए उपयोग किया जाता है एक रजिस्टर आधारित निर्देश की तुलना में अधिक स्मृति पर कब्जा क्योंकि एक नंबर एन्कोडिंग अतिरिक्त बाइट्स और कुल ले में और अधिक CPU चक्र निष्पादित करने के लिए (9 बाइट्स बनाम के लिए 5 बाइट्स की आवश्यकता है movऔर 6 बाइट्स बनाम सीएमपी के लिए 5 बाइट्स) । और फिर भी mov ecx,dword ptr [rcx+10h]गैर-कास्ट संस्करण के लिए अतिरिक्त निर्देश है, यह JIT कंपाइलर द्वारा रिलीज़ संस्करण में लूप के बाहर होने की संभावना है।
— दिमित्रो मुकलोव
@DmytroMukalov लेकिन गैर-कॉन्स्टेंस संस्करण के लिए ऑप्टिमाइज़ेशन के कारण इसका समानांतर निष्पादन में भिन्न व्यवहार नहीं होता है? जब चर को विभिन्न थ्रेड में बदला जा सकता है तो कंपाइलर इसे कैसे ऑप्टिमाइज़ कर सकते हैं।
— जश्न

जवाबों:

4

Https://benchmarkdotnet.org/articles/features/setup-and-cleanup.html पर देख रहे हैं

मेरा मानना ​​है कि आपको [IterationSetup]इसके बजाय उपयोग करना चाहिए [GlobalSetup]। वैश्विक सेटअप के साथ, dataएक बार बदल दिया जाता है और फिर बदला dataहुआ बेंचमार्क भर में पुन: उपयोग किया जाता है।

इसलिए, मैंने उचित इनिशियलाइज़ेशन का उपयोग करने के लिए कोड को बदल दिया है। बार-बार जाँच करने के लिए परिवर्तित चर। और कुछ और बदलाव जोड़े।

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
using System;

namespace PerfTest
{
    [DisassemblyDiagnoser(printAsm: true, printSource: true)]
    public class Test
    {
        private int[] data;
        private int[] data_iteration;

        private int Threshold = 50;
        private const int ConstThreshold = 50;

        [GlobalSetup]
        public void GlobalSetup()
        {
            data = new int[100000];
            var random = new Random(42);
            for (var i = 0; i < data.Length; i++)
            {
                data[i] = random.Next(100);
            }
        }

        [IterationSetup]
        public void IterationSetup()
        {
            data_iteration = new int[data.Length];
            Array.Copy(data, data_iteration, data.Length);
        }

        static void Main(string[] args)
        {
            var summary = BenchmarkRunner.Run<Test>();
        }

        [Benchmark]
        public void ClampToClassConstValue()
        {
            for (var i = 0; i < data_iteration.Length; i++)
            {
                if (data_iteration[i] > ConstThreshold) data_iteration[i] = ConstThreshold;
            }
        }

        [Benchmark]
        public void ClampToLocalConstValue()
        {
            const int ConstThresholdLocal = 50;
            for (var i = 0; i < data_iteration.Length; i++)
            {
                if (data_iteration[i] > ConstThresholdLocal) data_iteration[i] = ConstThresholdLocal;
            }
        }

        [Benchmark]
        public void ClampToInlineValue()
        {
            for (var i = 0; i < data_iteration.Length; i++)
            {
                if (data_iteration[i] > 50) data_iteration[i] = 50;
            }
        }

        [Benchmark]
        public void ClampToLocalVariable()
        {
            var ThresholdLocal = 50;
            for (var i = 0; i < data_iteration.Length; i++)
            {
                if (data_iteration[i] > ThresholdLocal) data_iteration[i] = ThresholdLocal;
            }
        }

        [Benchmark(Baseline = true)]
        public void ClampToMemberValue()
        {
            for (var i = 0; i < data_iteration.Length; i++)
            {
                if (data_iteration[i] > Threshold) data_iteration[i] = Threshold;
            }
        }
    }
}

परिणाम सामान्य दिखते हैं: 

BenchmarkDotNet=v0.12.0, OS=Windows 10.0.17134.1069 (1803/April2018Update/Redstone4)
Intel Core i7-8850H CPU 2.60GHz (Coffee Lake), 1 CPU, 12 logical and 6 physical cores
Frequency=2531250 Hz, Resolution=395.0617 ns, Timer=TSC
.NET Core SDK=3.0.100
  [Host]     : .NET Core 3.0.0 (CoreCLR 4.700.19.46205, CoreFX 4.700.19.46214), X64 RyuJIT
  Job-INSHHX : .NET Core 3.0.0 (CoreCLR 4.700.19.46205, CoreFX 4.700.19.46214), X64 RyuJIT

InvocationCount=1  UnrollFactor=1

|                 Method |     Mean |    Error |   StdDev |   Median | Ratio | RatioSD |
|----------------------- |---------:|---------:|---------:|---------:|------:|--------:|
| ClampToClassConstValue | 391.5 us | 17.86 us | 17.54 us | 384.2 us |  1.02 |    0.05 |
| ClampToLocalConstValue | 399.6 us |  9.49 us | 11.66 us | 399.0 us |  1.05 |    0.07 |
|     ClampToInlineValue | 384.1 us |  5.99 us |  5.00 us | 383.0 us |  1.00 |    0.06 |
|   ClampToLocalVariable | 382.7 us |  3.60 us |  3.00 us | 382.0 us |  1.00 |    0.05 |
|     ClampToMemberValue | 379.6 us |  8.48 us | 16.73 us | 371.8 us |  1.00 |    0.00 |

वहाँ विभिन्न वेरिएंट के बीच कोई अंतर नहीं लगता है। या तो सब कुछ अनुकूलित है या इस परिदृश्य में किसी भी तरह से अनुकूलित नहीं है।

— जश्न
स्रोत
मैं इस के साथ भी खेल रहा था और मुझे लगता है कि आप किसी चीज़ पर हैं, इसलिए इनपुट के लिए धन्यवाद। यदि सरणी बेंचमार्क के बीच बच जाती है, तो दो मामलों के बीच शाखा की भविष्यवाणी अलग होगी। मैं कुछ और आसपास घूमूंगा।
— ब्रायन रासमुसेन
@BrianRasmussen मुझे लगता है कि एक मुख्य अंतर यह है कि जब सरणी अपने मूल्यों के साथ जीवित रहती है, तो केवल पहला बेंचमार्क जो रन को बदलने का काम करता है। एक ही सरणी पर सभी अन्य बेंचमार्क के लिए, यदि यह कभी भी सच नहीं होगा।
— नौवेबटीन
@ नेनेबरी गुड पॉइंट। अगर अधिकांश परीक्षण बदल गए मूल्यों के साथ चलते हैं, तो मैं अभी भी अंतर नहीं बता सकता, लेकिन पुनरावृत्ति सेटअप के लिए ऐसा लगता है कि यहाँ कुछ खोदने के लिए है। आप दोनों को शुक्रिया!
— ब्रायन रासमुसेन
दरअसल मेरी बात इतनी अच्छी नहीं थी। प्रश्न में मूल कोड को देखते हुए, GlobalSetupप्रत्येक बेंचमार्क से एक बार पहले दो बार निष्पादित किया जाता है, इसलिए दोनों विधियां एक ही पूर्व-स्थिति से शुरू होती हैं।
— निनेबॉर्न
@ निन्यानबे हाँ। लेकिन चरम सीमा को सुचारू करने के लिए प्रत्येक विधि को कई बार निष्पादित किया जाता है। इसलिए प्रत्येक विधि के लिए एक पुनरावृत्ति है जो ठीक है और फिर अन्य सभी पुनरावृत्तियों जो अलग-अलग व्यवहार करते हैं।
— जश्न
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.