मेमोरी और स्पैन पीटी। 3

मेमोरी <T> और ReadOnlyMemory <T>

Memory<T> और Span<T> बीच दो दृश्य अंतर हैं। पहला यह है कि Memory<T> प्रकार में ref प्रकार शामिल नहीं है। दूसरे शब्दों में, Memory<T> प्रकार को स्थानीय चर, या विधि पैरामीटर, या इसके लौटा मूल्य और ढेर पर दोनों स्टैक पर आवंटित किया जा सकता है, वहां से स्मृति में कुछ डेटा संदर्भित करता है। हालाँकि, यह छोटा अंतर Span<T> की तुलना में Memory<T> के व्यवहार और क्षमताओं में बहुत बड़ा अंतर पैदा करता है। Span<T> विपरीत कुछ डेटा बफर का उपयोग करने के लिए कुछ तरीकों के लिए एक उपकरण है , Memory<T> प्रकार को बफर के बारे में जानकारी संग्रहीत करने के लिए डिज़ाइन किया गया है, लेकिन इसे संभालने के लिए नहीं। इस प्रकार, एपीआई में अंतर है।

• Memory<T> पास उस डेटा तक पहुंचने के तरीके नहीं हैं जिसके लिए वह जिम्मेदार है। इसके बजाय, इसमें Span प्रॉपर्टी और Slice विधि होती है जो Span प्रकार का एक उदाहरण Span ।
• इसके अतिरिक्त, Memory<T> में Pin() विधि का उपयोग परिदृश्यों के लिए किया जाता है जब एक संग्रहीत बफर डेटा को unsafe कोड में पारित किया जाना चाहिए। यदि .NET में मेमोरी आवंटित होने पर इस विधि को कॉल किया जाता है, तो बफर पिन किया जाएगा और GC सक्रिय होने पर स्थानांतरित नहीं होगा। यह विधि MemoryHandle संरचना का एक उदाहरण MemoryHandle , जो जीवन भर के एक खंड को इंगित करने के लिए और मेमोरी में सरणी बफर को पिन करने के लिए GCHandle को GCHandle करती है।

यह अध्याय रूसी से संयुक्त रूप से लेखक द्वारा और पेशेवर अनुवादकों द्वारा अनुवादित किया गया था । आप रूसी या अंग्रेजी से किसी अन्य भाषा में अनुवाद करने में हमारी मदद कर सकते हैं, मुख्यतः चीनी या जर्मन में।

इसके अलावा, यदि आप हमें धन्यवाद देना चाहते हैं, तो आप सबसे अच्छा तरीका यह कर सकते हैं कि हमें गितुब पर एक स्टार देना है या रिपॉजिटरी को फोर्क करना है github / sidristij / dotnetbook ।

हालांकि, मेरा सुझाव है कि हम कक्षाओं के पूरे सेट से परिचित हों। सबसे पहले, Memory<T> संरचना को देखें (यहां मैं केवल उन प्रकार के सदस्यों को दिखाता हूं जिन्हें मैंने सबसे महत्वपूर्ण पाया):

  public readonly struct Memory<T> { private readonly object _object; private readonly int _index, _length; public Memory(T[] array) { ... } public Memory(T[] array, int start, int length) { ... } internal Memory(MemoryManager<T> manager, int length) { ... } internal Memory(MemoryManager<T> manager, int start, int length) { ... } public int Length => _length & RemoveFlagsBitMask; public bool IsEmpty => (_length & RemoveFlagsBitMask) == 0; public Memory<T> Slice(int start, int length); public void CopyTo(Memory<T> destination) => Span.CopyTo(destination.Span); public bool TryCopyTo(Memory<T> destination) => Span.TryCopyTo(destination.Span); public Span<T> Span { get; } public unsafe MemoryHandle Pin(); } 

जैसा कि हम देखते हैं कि संरचना में सरणियों के आधार पर कंस्ट्रक्टर है, लेकिन ऑब्जेक्ट में डेटा संग्रहीत करता है। यह अतिरिक्त रूप से संदर्भ स्ट्रिंग्स के लिए है, जिनके पास उनके लिए डिज़ाइन किया गया एक कंस्ट्रक्टर नहीं है, लेकिन AsMemory() string विधि के साथ इसका उपयोग किया जा सकता है, यह ReadOnlyMemory देता है। हालाँकि, जैसा कि दोनों प्रकार बाइनरी समान होना चाहिए, Object _object फ़ील्ड का प्रकार है।

इसके बाद, हम MemoryManager पर आधारित दो कंस्ट्रक्टर देखते हैं। हम उनके बारे में बाद में बात करेंगे। एक खाली सेट के लिए Length (आकार) और IsEmpty प्राप्त करने के गुण। इसके अलावा, एक सबसेट पाने के लिए Slice विधि के साथ-साथ CopyTo और TryCopyTo की प्रतिलिपि बनाने के तरीके भी हैं।

Memory बारे में बात करते हुए मैं इस प्रकार के दो तरीकों का विस्तार से वर्णन करना चाहता हूं: Span संपत्ति और Pin विधि।

मेमोरी <टी> .Span

 public Span<T> Span { get { if (_index < 0) { return ((MemoryManager<T>)_object).GetSpan().Slice(_index & RemoveFlagsBitMask, _length); } else if (typeof(T) == typeof(char) && _object is string s) { // This is dangerous, returning a writable span for a string that should be immutable. // However, we need to handle the case where a ReadOnlyMemory<char> was created from a string // and then cast to a Memory<T>. Such a cast can only be done with unsafe or marshaling code, // in which case that's the dangerous operation performed by the dev, and we're just following // suit here to make it work as best as possible. return new Span<T>(ref Unsafe.As<char, T>(ref s.GetRawStringData()), s.Length).Slice(_index, _length); } else if (_object != null) { return new Span<T>((T[])_object, _index, _length & RemoveFlagsBitMask); } else { return default; } } } 

अर्थात्, वे तार जो प्रबंधन को संभालते हैं। वे कहते हैं कि अगर हम ReadOnlyMemory<T> को Memory<T> परिवर्तित करते हैं (ये चीजें बाइनरी प्रतिनिधित्व में समान हैं और यहां तक ​​कि एक टिप्पणी है कि इन प्रकारों को द्विआधारी तरीके से मेल खाना चाहिए क्योंकि एक दूसरे से Unsafe.As कॉल करके Unsafe.As ) स्ट्रिंग्स को बदलने के अवसर के साथ हमें एक गुप्त कक्ष में ~ पहुंच मिलेगी। यह एक अत्यंत खतरनाक तंत्र है:

 unsafe void Main() { var str = "Hello!"; ReadOnlyMemory<char> ronly = str.AsMemory(); Memory<char> mem = (Memory<char>)Unsafe.As<ReadOnlyMemory<char>, Memory<char>>(ref ronly); mem.Span[5] = '?'; Console.WriteLine(str); } --- Hello? 

स्ट्रिंग इंटर्निंग के साथ संयुक्त यह तंत्र गंभीर परिणाम पैदा कर सकता है।

मेमोरी <टी>। पिन

दूसरी विधि जो मजबूत ध्यान आकर्षित करती है वह है Pin :

 public unsafe MemoryHandle Pin() { if (_index < 0) { return ((MemoryManager<T>)_object).Pin((_index & RemoveFlagsBitMask)); } else if (typeof(T) == typeof(char) && _object is string s) { // This case can only happen if a ReadOnlyMemory<char> was created around a string // and then that was cast to a Memory<char> using unsafe / marshaling code. This needs // to work, however, so that code that uses a single Memory<char> field to store either // a readable ReadOnlyMemory<char> or a writable Memory<char> can still be pinned and // used for interop purposes. GCHandle handle = GCHandle.Alloc(s, GCHandleType.Pinned); void* pointer = Unsafe.Add<T>(Unsafe.AsPointer(ref s.GetRawStringData()), _index); return new MemoryHandle(pointer, handle); } else if (_object is T[] array) { // Array is already pre-pinned if (_length < 0) { void* pointer = Unsafe.Add<T>(Unsafe.AsPointer(ref array.GetRawSzArrayData()), _index); return new MemoryHandle(pointer); } else { GCHandle handle = GCHandle.Alloc(array, GCHandleType.Pinned); void* pointer = Unsafe.Add<T>(Unsafe.AsPointer(ref array.GetRawSzArrayData()), _index); return new MemoryHandle(pointer, handle); } } return default; } 

यह एकीकरण के लिए एक महत्वपूर्ण साधन भी है क्योंकि यदि हम किसी अनवांटेड कोड को एक बफर पास करना चाहते हैं, तो हमें सिर्फ Pin() विधि को कॉल करने और इस कोड को एक पॉइंटर पास करने की आवश्यकता है, इससे कोई फर्क नहीं पड़ता कि Memory<T> किस प्रकार का डेटा संदर्भित करता है। यह पॉइंटर एक परिणामी संरचना की संपत्ति में संग्रहीत किया जाएगा।

 void PinSample(Memory<byte> memory) { using(var handle = memory.Pin()) { WinApi.SomeApiMethod(handle.Pointer); } } 

इससे कोई फर्क नहीं पड़ता कि इस कोड में Pin() क्या कहा गया था: यह Memory हो सकती है जो या तो T[] प्रतिनिधित्व करती है, या एक string या अनवांटेड मेमोरी का बफर। GCHandle.Alloc(array, GCHandleType.Pinned) सरणियों और स्ट्रिंग को एक वास्तविक GCHandle.Alloc(array, GCHandleType.Pinned) और अप्रबंधित मेमोरी के मामले में कुछ भी नहीं होगा।

MemoryManager, IMemoryOwner, MemoryPool

संरचना क्षेत्रों को इंगित करने के अलावा, मैं यह नोट करना चाहता हूं कि अन्य इकाई के आधार पर दो अन्य internal प्रकार के निर्माता हैं - MemoryManager । यह एक क्लासिक मेमोरी मैनेजर नहीं है जिसे आपने सोचा होगा और हम इसके बारे में बाद में बात करने जा रहे हैं। क्लासिक मेमोरी मैनेजर, जिसके बारे में आपने सोचा होगा और हम बाद में इसके बारे में बात करने जा रहे हैं। Span तरह, Memory में एक नेविगेट की गई वस्तु, एक ऑफसेट और एक आंतरिक बफर का आकार होता है। ध्यान दें कि आप केवल एक सरणी से Memory बनाने के लिए new ऑपरेटर का उपयोग कर सकते हैं। या, आप एक स्ट्रिंग, एक सरणी या सरणी से Memory बनाने के लिए एक्सटेंशन विधियों का उपयोग कर सकते हैं। मेरा मतलब है कि इसे मैन्युअल रूप से अप्रबंधित मेमोरी से बनाया नहीं गया है। हालाँकि, हम देख सकते हैं कि MemoryManager का उपयोग करके इस संरचना को बनाने के लिए एक आंतरिक विधि है।

फ़ाइल MemoryManager.cs

 public abstract class MemoryManager<T> : IMemoryOwner<T>, IPinnable { public abstract MemoryHandle Pin(int elementIndex = 0); public abstract void Unpin(); public virtual Memory<T> Memory => new Memory<T>(this, GetSpan().Length); public abstract Span<T> GetSpan(); protected Memory<T> CreateMemory(int length) => new Memory<T>(this, length); protected Memory<T> CreateMemory(int start, int length) => new Memory<T>(this, start, length); void IDisposable.Dispose() protected abstract void Dispose(bool disposing); } 

यह संरचना एक मेमोरी रेंज के मालिक को इंगित करती है। दूसरे शब्दों में, Span Memory साथ काम करने वाला एक उपकरण है, Memory एक विशेष मेमोरी रेंज के बारे में जानकारी संग्रहीत करने का एक उपकरण है और MemoryManager इस रेंज के जीवनकाल को नियंत्रित करने का एक उपकरण है, अर्थात इसका मालिक। उदाहरण के लिए, हम NativeMemoryManager<T> प्रकार को देख सकते हैं। यद्यपि इसका उपयोग परीक्षणों के लिए किया जाता है, यह प्रकार स्पष्ट रूप से "स्वामित्व" की अवधारणा का प्रतिनिधित्व करता है।

फ़ाइल NativeMemoryManager.cs

 internal sealed class NativeMemoryManager : MemoryManager<byte> { private readonly int _length; private IntPtr _ptr; private int _retainedCount; private bool _disposed; public NativeMemoryManager(int length) { _length = length; _ptr = Marshal.AllocHGlobal(length); } public override void Pin() { ... } public override void Unpin() { lock (this) { if (_retainedCount > 0) { _retainedCount--; if (_retainedCount== 0) { if (_disposed) { Marshal.FreeHGlobal(_ptr); _ptr = IntPtr.Zero; } } } } } // Other methods } 

इसका मतलब है कि वर्ग Pin() विधि के नेस्टेड कॉल के लिए अनुमति देता है, इस प्रकार unsafe दुनिया से उत्पन्न संदर्भों की गिनती करता है।

Memory साथ निकटता से जुड़ी एक अन्य इकाई MemoryPool जो कि Memory MemoryPool इंस्टेंस (वास्तव में IMemoryOwner ) को पूल IMemoryOwner है:

फ़ाइल MemoryPool.cs

 public abstract class MemoryPool<T> : IDisposable { public static MemoryPool<T> Shared => s_shared; public abstract IMemoryOwner<T> Rent(int minBufferSize = -1); public void Dispose() { ... } } 

इसका उपयोग अस्थायी उपयोग के लिए आवश्यक आकार के बफ़र्स को पट्टे पर देने के लिए किया जाता है। कार्यान्वित IMemoryOwner<T> इंटरफ़ेस के साथ पट्टे के उदाहरणों में एरे के पूल में पट्टे पर दिए गए सरणी को वापस करने के लिए IMemoryOwner<T> Dispose() विधि है। डिफ़ॉल्ट रूप से, आप ArrayMemoryPool पर निर्मित बफ़र्स के साझा करने योग्य पूल का उपयोग कर सकते हैं:

फ़ाइल ArrayMemoryPool.cs

 internal sealed partial class ArrayMemoryPool<T> : MemoryPool<T> { private const int MaximumBufferSize = int.MaxValue; public sealed override int MaxBufferSize => MaximumBufferSize; public sealed override IMemoryOwner<T> Rent(int minimumBufferSize = -1) { if (minimumBufferSize == -1) minimumBufferSize = 1 + (4095 / Unsafe.SizeOf<T>()); else if (((uint)minimumBufferSize) > MaximumBufferSize) ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.minimumBufferSize); return new ArrayMemoryPoolBuffer(minimumBufferSize); } protected sealed override void Dispose(bool disposing) { } } 

इस वास्तुकला के आधार पर, हमारे पास निम्नलिखित चित्र हैं:

• यदि आप डेटा ( ReadOnlySpan ) पढ़ना चाहते हैं या डेटा ( Span ) पढ़ना और लिखना चाहते हैं, तो Span डेटा प्रकार को एक विधि पैरामीटर के रूप में उपयोग किया जाना चाहिए। हालांकि, भविष्य के उपयोग के लिए इसे किसी वर्ग के क्षेत्र में संग्रहीत नहीं किया जाना चाहिए।
• यदि आपको एक वर्ग के क्षेत्र से डेटा बफर में एक संदर्भ संग्रहीत करने की आवश्यकता है, तो आपको अपने लक्ष्यों के आधार पर Memory<T> या ReadOnlyMemory<T> का उपयोग करने की आवश्यकता है।
• MemoryManager<T> डेटा बफर (वैकल्पिक) का मालिक है। यह आवश्यक हो सकता है यदि आपको उदाहरण के लिए Pin() कॉल की गणना करने की आवश्यकता है। या, यदि आपको यह जानने की आवश्यकता है कि मेमोरी कैसे जारी करें।
• यदि Memory एक अनवांटेड मेमोरी रेंज के आसपास बनाई गई है, तो Pin() कुछ नहीं कर सकता है। हालांकि, विभिन्न प्रकार के बफ़र्स के साथ काम करने वाली यह वर्दी: प्रबंधित और अप्रबंधित कोड दोनों के लिए इंटरैक्शन इंटरफ़ेस समान होगा।
• हर प्रकार के सार्वजनिक निर्माता हैं। इसका मतलब है कि आप Span सीधे उपयोग कर सकते हैं या Memory से इसका उदाहरण प्राप्त कर सकते हैं। Memory को इस तरह से, आप इसे व्यक्तिगत रूप से बना सकते हैं या आप IMemoryOwner स्वामित्व वाली मेमोरी रेंज बना सकते हैं और Memory द्वारा संदर्भित कर सकते हैं। MemoryManger पर आधारित किसी भी प्रकार को एक विशिष्ट मामले के रूप में माना जा सकता है जो कुछ स्थानीय मेमोरी रेंज (जैसे unsafe दुनिया से संदर्भों की गिनती के साथ) का मालिक है। इसके अलावा, यदि आपको ऐसे बफ़र्स (लगभग समान रूप से बफ़र्स के लगातार ट्रैफ़िक की उम्मीद है) को पूल करने की आवश्यकता है, तो आप MemoryPool प्रकार का उपयोग कर सकते हैं।
• यदि आप वहां डेटा बफर पास करके unsafe कोड के साथ काम करने का इरादा रखते हैं, तो आपको Memory प्रकार का उपयोग करना चाहिए जिसमें Pin() विधि है जो स्वचालित रूप से .NET हीप पर एक बफर पिन करता है यदि यह वहां बनाया गया था।
• यदि आपके पास बफ़र्स का कुछ ट्रैफ़िक है (उदाहरण के लिए आप किसी प्रोग्राम या डीएसएल का पाठ पार्स करते हैं), तो MemoryPool टाइप का उपयोग करना बेहतर है। आप पूल से एक आवश्यक आकार के बफ़र्स को आउटपुट करने के लिए इसे ठीक से लागू कर सकते हैं (उदाहरण के लिए थोड़ा बड़ा बफर अगर कोई उपयुक्त नहीं है, लेकिन originalMemory.Slice(requiredSize) विखंडन से बचने के लिए originalMemory.Slice(requiredSize) का उपयोग करके)।

प्रदर्शन

नए डेटा प्रकारों के प्रदर्शन को मापने के लिए मैंने एक पुस्तकालय का उपयोग करने का फैसला किया है जो पहले से ही मानक बेंचमार्कडॉटनेट बन गया है:

 [Config(typeof(MultipleRuntimesConfig))] public class SpanIndexer { private const int Count = 100; private char[] arrayField; private ArraySegment<char> segment; private string str; [GlobalSetup] public void Setup() { str = new string(Enumerable.Repeat('a', Count).ToArray()); arrayField = str.ToArray(); segment = new ArraySegment<char>(arrayField); } [Benchmark(Baseline = true, OperationsPerInvoke = Count)] public int ArrayIndexer_Get() { var tmp = 0; for (int index = 0, len = arrayField.Length; index < len; index++) { tmp = arrayField[index]; } return tmp; } [Benchmark(OperationsPerInvoke = Count)] public void ArrayIndexer_Set() { for (int index = 0, len = arrayField.Length; index < len; index++) { arrayField[index] = '0'; } } [Benchmark(OperationsPerInvoke = Count)] public int ArraySegmentIndexer_Get() { var tmp = 0; var accessor = (IList<char>)segment; for (int index = 0, len = accessor.Count; index < len; index++) { tmp = accessor[index]; } return tmp; } [Benchmark(OperationsPerInvoke = Count)] public void ArraySegmentIndexer_Set() { var accessor = (IList<char>)segment; for (int index = 0, len = accessor.Count; index < len; index++) { accessor[index] = '0'; } } [Benchmark(OperationsPerInvoke = Count)] public int StringIndexer_Get() { var tmp = 0; for (int index = 0, len = str.Length; index < len; index++) { tmp = str[index]; } return tmp; } [Benchmark(OperationsPerInvoke = Count)] public int SpanArrayIndexer_Get() { var span = arrayField.AsSpan(); var tmp = 0; for (int index = 0, len = span.Length; index < len; index++) { tmp = span[index]; } return tmp; } [Benchmark(OperationsPerInvoke = Count)] public int SpanArraySegmentIndexer_Get() { var span = segment.AsSpan(); var tmp = 0; for (int index = 0, len = span.Length; index < len; index++) { tmp = span[index]; } return tmp; } [Benchmark(OperationsPerInvoke = Count)] public int SpanStringIndexer_Get() { var span = str.AsSpan(); var tmp = 0; for (int index = 0, len = span.Length; index < len; index++) { tmp = span[index]; } return tmp; } [Benchmark(OperationsPerInvoke = Count)] public void SpanArrayIndexer_Set() { var span = arrayField.AsSpan(); for (int index = 0, len = span.Length; index < len; index++) { span[index] = '0'; } } [Benchmark(OperationsPerInvoke = Count)] public void SpanArraySegmentIndexer_Set() { var span = segment.AsSpan(); for (int index = 0, len = span.Length; index < len; index++) { span[index] = '0'; } } } public class MultipleRuntimesConfig : ManualConfig { public MultipleRuntimesConfig() { Add(Job.Default .With(CsProjClassicNetToolchain.Net471) // Span not supported by CLR .WithId(".NET 4.7.1")); Add(Job.Default .With(CsProjCoreToolchain.NetCoreApp20) // Span supported by CLR .WithId(".NET Core 2.0")); Add(Job.Default .With(CsProjCoreToolchain.NetCoreApp21) // Span supported by CLR .WithId(".NET Core 2.1")); Add(Job.Default .With(CsProjCoreToolchain.NetCoreApp22) // Span supported by CLR .WithId(".NET Core 2.2")); } } 

अब, परिणाम देखें।

उन्हें देखते हुए हम निम्नलिखित जानकारी प्राप्त कर सकते हैं:

• ArraySegment भयानक है। लेकिन अगर आप इसे Span में लपेटते हैं तो आप इसे कम भयानक बना सकते हैं। इस मामले में, प्रदर्शन 7 गुना बढ़ जाएगा।
• यदि हम .NET फ्रेमवर्क 4.7.1 (यही बात 4.5 के लिए है) पर विचार करते हैं, तो डेटा बफ़र्स के साथ काम करते समय Span का उपयोग प्रदर्शन को काफी कम कर देगा। इसमें 30-35% की कमी आएगी।
• हालाँकि, यदि हम .NET कोर 2.1+ को देखते हैं, तो प्रदर्शन समान रहता है या यहां तक ​​कि बढ़ जाता है, जो Span डेटा बफर के एक हिस्से का उपयोग कर सकता है, संदर्भ बना सकता है। ArraySegment में समान कार्यक्षमता पाई जा सकती है, लेकिन यह बहुत धीमी गति से काम करती है।

इस प्रकार, हम इन डेटा प्रकारों के उपयोग के बारे में सरल निष्कर्ष निकाल सकते हैं:

• .NET Framework 4.5+ और .NET Core उनके पास एकमात्र लाभ है: वे मूल सरणी के सबसेट के साथ काम करते समय ArraySegment तुलना में तेज़ हैं;
• .NET Core 2.1+ उनका उपयोग ArraySegment और Slice किसी भी मैनुअल कार्यान्वयन पर एक निर्विवाद लाभ देता है;
• सभी तीन तरीके यथासंभव उत्पादक हैं और सरणियों को एकजुट करने के लिए किसी भी उपकरण के साथ प्राप्त नहीं किया जा सकता है।
  

  यह अध्याय रूसी से संयुक्त रूप से लेखक द्वारा और पेशेवर अनुवादकों द्वारा अनुवादित किया गया था । आप रूसी या अंग्रेजी से किसी अन्य भाषा में अनुवाद करने में हमारी मदद कर सकते हैं, मुख्यतः चीनी या जर्मन में।