MemoryCache कॉन्फ़िगरेशन में मेमोरी सीमा का पालन नहीं करता है

Question 1

मैं एक आवेदन में .NET 4.0 मेमोरीकैच क्लास के साथ काम कर रहा हूं और अधिकतम कैश आकार को सीमित करने की कोशिश कर रहा हूं, लेकिन मेरे परीक्षणों में ऐसा नहीं लगता कि कैश वास्तव में सीमा का पालन कर रहा है।

मैं उन सेटिंग्स का उपयोग कर रहा हूं, जो MSDN के अनुसार , कैश आकार को सीमित करने वाली हैं:

CacheMoryoryLimitMegabytes : मेगाबाइट में अधिकतम मेमोरी साइज़, जो किसी ऑब्जेक्ट की आवृत्ति को बढ़ा सकता है। "

PhysicalMemoryLimitPercentage : "भौतिक मेमोरी का वह प्रतिशत जिसे कैश उपयोग कर सकते हैं, को पूर्णांक मान के रूप में 1 से 100 तक व्यक्त किया जाता है। डिफ़ॉल्ट शून्य है, जो इंगित करता है कि MemoryCache इंस्टेंस स्मृतिकी मात्रा के आधार परअपनी स्वयं की मेमोरी¹ का प्रबंधनकरता है जोकि इंस्टॉल की गई मेमोरी पर आधारित है संगणक।" ^{1. यह पूरी तरह से सही नहीं है - 4 से नीचे के किसी भी मूल्य को अनदेखा किया जाता है और 4 से बदल दिया जाता है।}

मैं समझता हूं कि ये मूल्य अनुमानित नहीं हैं और कठोर सीमा नहीं है क्योंकि कैश को शुद्ध करने वाले धागे को हर एक्स सेकंड में निकाल दिया जाता है और यह मतदान अंतराल और अन्य अनिर्दिष्ट चर पर भी निर्भर है। हालाँकि, इन भिन्नताओं को ध्यान में रखते हुए, मैं कैशली असंगत कैश साइज़ देख रहा हूँ, जब CacheMemoryLimitMegabytes और PhysicalMemoryLimitPercentage या एक परीक्षण ऐप में एकवचन सेट करने के बाद पहला आइटम कैश से निकाला जा रहा है । यह सुनिश्चित करने के लिए कि मैंने प्रत्येक परीक्षण को 10 बार चलाया और औसत आंकड़ा की गणना की।

ये 3 जीबी रैम के साथ 32-बिट विंडोज 7 पीसी पर नीचे दिए गए उदाहरण कोड के परीक्षण के परिणाम हैं। पहली कॉल के बाद कैश का आकार लिया जाता है प्रत्येक परीक्षण पर CacheItemRemoved () के । (मुझे पता है कि कैश का वास्तविक आकार इससे बड़ा होगा)

MemLimitMB    MemLimitPct     AVG Cache MB on first expiry    
   1            NA              84
   2            NA              84
   3            NA              84
   6            NA              84
  NA             1              84
  NA             4              84
  NA            10              84
  10            20              81
  10            30              81
  10            39              82
  10            40              79
  10            49              146
  10            50              152
  10            60              212
  10            70              332
  10            80              429
  10           100              535
 100            39              81
 500            39              79
 900            39              83
1900            39              84
 900            41              81
 900            46              84

 900            49              1.8 GB approx. in task manager no mem errros
 200            49              156
 100            49              153
2000            60              214
   5            60              78
   6            60              76
   7           100              82
  10           100              541

यहाँ परीक्षण आवेदन है:

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Linq;
using System.Runtime.Caching;
using System.Text;
namespace FinalCacheTest
{       
    internal class Cache
    {
        private Object Statlock = new object();
        private int ItemCount;
        private long size;
        private MemoryCache MemCache;
        private CacheItemPolicy CIPOL = new CacheItemPolicy();

        public Cache(long CacheSize)
        {
            CIPOL.RemovedCallback = new CacheEntryRemovedCallback(CacheItemRemoved);
            NameValueCollection CacheSettings = new NameValueCollection(3);
            CacheSettings.Add("CacheMemoryLimitMegabytes", Convert.ToString(CacheSize)); 
            CacheSettings.Add("physicalMemoryLimitPercentage", Convert.ToString(49));  //set % here
            CacheSettings.Add("pollingInterval", Convert.ToString("00:00:10"));
            MemCache = new MemoryCache("TestCache", CacheSettings);
        }

        public void AddItem(string Name, string Value)
        {
            CacheItem CI = new CacheItem(Name, Value);
            MemCache.Add(CI, CIPOL);

            lock (Statlock)
            {
                ItemCount++;
                size = size + (Name.Length + Value.Length * 2);
            }

        }

        public void CacheItemRemoved(CacheEntryRemovedArguments Args)
        {
            Console.WriteLine("Cache contains {0} items. Size is {1} bytes", ItemCount, size);

            lock (Statlock)
            {
                ItemCount--;
                size = size - 108;
            }

            Console.ReadKey();
        }
    }
}

namespace FinalCacheTest
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            int MaxAdds = 5000000;
            Cache MyCache = new Cache(1); // set CacheMemoryLimitMegabytes

            for (int i = 0; i < MaxAdds; i++)
            {
                MyCache.AddItem(Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
            }

            Console.WriteLine("Finished Adding Items to Cache");
        }
    }
}

MemoryCache कॉन्फ़िगर की गई स्मृति सीमाओं का पालन क्यों नहीं कर रहा है?

Question 2

वाह, तो मैंने सीएलआर में परावर्तक के साथ खुदाई करने के लिए बस पूरी तरह से बहुत अधिक समय बिताया, लेकिन मुझे लगता है कि आखिरकार यहां क्या चल रहा है, इस पर मेरे पास एक अच्छा हैंडल है।

सेटिंग्स को सही तरीके से पढ़ा जा रहा है, लेकिन लगता है कि सीएलआर में ही एक गहरी बैठी हुई समस्या है जो दिखता है कि यह अनिवार्य रूप से बेकार की मेमोरी सीमा को प्रस्तुत करेगा।

CacheMemoryMonitor वर्ग के लिए निम्न कोड System.Runtime.Caching DLL से बाहर परिलक्षित होता है (एक समान वर्ग है जो भौतिक मेमोरी की निगरानी करता है और अन्य सेटिंग से संबंधित है, लेकिन यह अधिक महत्वपूर्ण है):

protected override int GetCurrentPressure()
{
  int num = GC.CollectionCount(2);
  SRef ref2 = this._sizedRef;
  if ((num != this._gen2Count) && (ref2 != null))
  {
    this._gen2Count = num;
    this._idx ^= 1;
    this._cacheSizeSampleTimes[this._idx] = DateTime.UtcNow;
    this._cacheSizeSamples[this._idx] = ref2.ApproximateSize;
    IMemoryCacheManager manager = s_memoryCacheManager;
    if (manager != null)
    {
      manager.UpdateCacheSize(this._cacheSizeSamples[this._idx], this._memoryCache);
    }
  }
  if (this._memoryLimit <= 0L)
  {
    return 0;
  }
  long num2 = this._cacheSizeSamples[this._idx];
  if (num2 > this._memoryLimit)
  {
    num2 = this._memoryLimit;
  }
  return (int) ((num2 * 100L) / this._memoryLimit);
}

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

इसलिए मान लें कि एक Gen2 GC हुआ है, हम समस्या 2 में भाग लेते हैं, जो कि ref2.ApproximateSize वास्तव में कैश के आकार का अनुमान लगाने का एक भयानक काम करता है। सीएलआर कबाड़ के माध्यम से स्लोगन मैंने पाया कि यह एक System.SizedReference है, और यह वह है जो मूल्य प्राप्त करने के लिए कर रहा है (IntPtr एक मेमोरी मेमोरी ऑब्जेक्ट के लिए खुद को संभालता है):

[SecurityCritical]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern long GetApproximateSizeOfSizedRef(IntPtr h);

मैं मान रहा हूं कि बाहरी घोषणा का मतलब है कि यह इस बिंदु पर अप्रबंधित विंडोज़ भूमि में गोताखोरी करता है, और मुझे नहीं पता कि यह कैसे पता चलता है कि यह वहां क्या करता है। हालांकि मैंने जो देखा है, वह समग्र चीज़ के आकार को अनुमानित करने का एक भयानक काम करता है।

तीसरी ध्यान देने योग्य बात यह है कि manager.UpdateCacheSize में कॉल है जो लगता है कि उसे कुछ करना चाहिए। दुर्भाग्य से किसी भी सामान्य नमूने में यह कैसे काम करना चाहिए s_memoryCacheManager हमेशा शून्य रहेगा। फ़ील्ड को सार्वजनिक स्थैतिक सदस्य ObjectCache.Host से सेट किया गया है। यह उपयोगकर्ता के साथ खिलवाड़ करने के लिए उजागर होता है यदि वह ऐसा करता है, और मैं वास्तव में इस काम को करने में सक्षम था जैसे कि यह अपने स्वयं के IMemoryCacheManager कार्यान्वयन को एक साथ करने से माना जाता है, यह ObjectCache.Host पर सेट करता है, और फिर नमूना चला रहा है । उस बिंदु पर, ऐसा लगता है जैसे आप बस अपना खुद का कैश कार्यान्वयन कर सकते हैं और यह सब सामान के साथ परेशान भी नहीं करते हैं, खासकर जब से मुझे अपना कोई विचार नहीं करना है, तो अपना स्वयं का वर्ग ObjectCache.Host पर सेट करें (स्थैतिक)

मेरा मानना है कि कम से कम इसका हिस्सा (यदि एक जोड़ी नहीं) तो बस एक सीधा बग है। एमएस से किसी से यह सुनना अच्छा होगा कि इस चीज़ के साथ क्या सौदा हुआ था।

इस विशाल उत्तर का TLDR संस्करण: मान लें कि CacheMemoryLimitMegabytes इस समय इस बिंदु पर पूरी तरह से समाप्त हो गया है। आप इसे 10 एमबी पर सेट कर सकते हैं, और फिर कैश को ~ 2GB तक भरने के लिए आगे बढ़ सकते हैं और आइटम हटाने के ट्रिपिंग के साथ मेमोरी अपवाद को बाहर उड़ा सकते हैं।

Question 3

मुझे पता है कि यह उत्तर देर से पागल है, लेकिन पहले से कहीं ज्यादा देर से बेहतर है। मैं आपको बताना चाहता हूं कि मैंने एक संस्करण लिखा है MemoryCacheजो आपके लिए जनरल 2 संग्रह के मुद्दों को स्वचालित रूप से हल करता है। इसीलिए जब भी मतदान अंतराल स्मृति दबाव को इंगित करता है तो यह दुखद होता है। यदि आप इस समस्या का सामना कर रहे हैं, तो इसे दें!

http://www.nuget.org/packages/SharpMemoryCache

आप इसे GitHub पर भी पा सकते हैं यदि आप उत्सुक हैं कि मैंने इसे कैसे हल किया। कोड कुछ सरल है।

https://github.com/haneytron/sharpmemorycache

Question 4

मैंने @Canacourse के उदाहरण और @woany के संशोधन के साथ कुछ परीक्षण किए हैं और मुझे लगता है कि कुछ महत्वपूर्ण कॉल हैं जो मेमोरी कैश की सफाई को अवरुद्ध करती हैं।

public void CacheItemRemoved(CacheEntryRemovedArguments Args)
{
    // this WriteLine() will block the thread of
    // the MemoryCache long enough to slow it down,
    // and it will never catch up the amount of memory
    // beyond the limit
    Console.WriteLine("...");

    // ...

    // this ReadKey() will block the thread of 
    // the MemoryCache completely, till you press any key
    Console.ReadKey();
}

लेकिन @woany का संशोधन स्मृति को समान स्तर पर रखने के लिए क्यों लगता है? सबसे पहले, RemoveedCallback सेट नहीं है और कोई कंसोल आउटपुट या इनपुट का इंतजार नहीं कर रहा है जो मेमोरी कैश के थ्रेड को ब्लॉक कर सकता है।

दूसरी बात यह है ...

public void AddItem(string Name, string Value)
{
    // ...

    // this WriteLine will block the main thread long enough,
    // so that the thread of the MemoryCache can do its work more frequently
    Console.WriteLine("...");
}

एक थ्रेड। सो (1) हर ~ 1000 वां AddItem () का एक ही प्रभाव होगा।

खैर, यह समस्या की बहुत गहरी जांच नहीं है, लेकिन ऐसा लगता है जैसे कि MemoryCache के धागे को सफाई के लिए पर्याप्त सीपीयू समय नहीं मिलता है, जबकि कई नए तत्व जोड़े जाते हैं।

Question 5

मैंने इस मुद्दे का भी सामना किया है। मैं उन वस्तुओं को कैशिंग कर रहा हूं जिन्हें मेरी प्रक्रिया में प्रति सेकंड दर्जनों बार निकाल दिया जाता है।

मैंने पाया है कि निम्नलिखित कॉन्फ़िगरेशन और उपयोग हर बार हर 5 सेकंड में वस्तुओं को मुक्त करता है ।

app.config:

कैशमेमोरीलिमिटमैगेबाइट्स पर ध्यान दें । जब यह शून्य पर सेट किया गया था, तो शुद्ध दिनचर्या उचित समय में आग नहीं लगाएगा।

   <system.runtime.caching>
    <memoryCache>
      <namedCaches>
        <add name="Default" cacheMemoryLimitMegabytes="20" physicalMemoryLimitPercentage="0" pollingInterval="00:00:05" />
      </namedCaches>
    </memoryCache>
  </system.runtime.caching>

कैश में जोड़ना:

MemoryCache.Default.Add(someKeyValue, objectToCache, new CacheItemPolicy { AbsoluteExpiration = DateTime.Now.AddSeconds(5), RemovedCallback = cacheItemRemoved });

कैश निकालने की पुष्टि करना काम कर रहा है:

void cacheItemRemoved(CacheEntryRemovedArguments arguments)
{
    System.Diagnostics.Debug.WriteLine("Item removed from cache: {0} at {1}", arguments.CacheItem.Key, DateTime.Now.ToString());
}

Question 6

जब मैं पहली बार MemoryCache का उपयोग करने का प्रयास कर रहा था, तो मैं (शुक्र है) कल इस उपयोगी पोस्ट से टकरा गया। मुझे लगा कि यह मूल्यों को स्थापित करने और कक्षाओं का उपयोग करने का एक सरल मामला होगा लेकिन मुझे ऊपर उल्लिखित समान मुद्दों का सामना करना पड़ा। कोशिश करने और यह देखने के लिए कि मैं क्या कर रहा था मैंने ILSpy का उपयोग करके स्रोत निकाला और फिर एक परीक्षण स्थापित किया और कोड के माध्यम से कदम रखा। मेरा परीक्षण कोड ऊपर दिए गए कोड के समान था इसलिए मैं इसे पोस्ट नहीं करूंगा। अपने परीक्षणों से मैंने देखा कि कैश आकार का माप कभी भी सटीक नहीं था (जैसा कि ऊपर बताया गया है) और वर्तमान में दिए गए कार्यान्वयन कभी भी मज़बूती से काम नहीं करेंगे। हालाँकि, शारीरिक माप ठीक था और यदि भौतिक स्मृति को हर सर्वेक्षण में मापा गया था, तो मुझे ऐसा लग रहा था कि कोड मज़बूती से काम करेगा। इसलिए, मैंने MemoryCacheStatistics के भीतर जनरल 2 कचरा संग्रह जांच को हटा दिया;

एक परीक्षण परिदृश्य में यह स्पष्ट रूप से एक बड़ा अंतर बनाता है क्योंकि कैश लगातार हिट हो रहा है इसलिए वस्तुओं को कभी भी जीन प्राप्त करने का मौका नहीं मिलता है। मुझे लगता है कि हम इस dll के संशोधित निर्माण का उपयोग अपनी परियोजना पर करने जा रहे हैं और आधिकारिक MS का उपयोग करेंगे .net 4.5 का निर्माण तब होता है जब (जो ऊपर उल्लिखित कनेक्ट लेख के अनुसार ठीक होना चाहिए)। तार्किक रूप से मैं देख सकता हूं कि जीन 2 की जांच क्यों की गई है, लेकिन व्यवहार में मुझे यकीन नहीं है कि यह बहुत समझ में आता है। यदि मेमोरी 90% (या जो भी सीमा निर्धारित की गई है) तक पहुंचती है, तो इससे कोई फर्क नहीं पड़ता कि एक जनरल 2 संग्रह में गिरावट आई है या नहीं, आइटम को बेदखल किया जाना चाहिए।

मैंने अपना परीक्षण कोड लगभग 15 मिनट के लिए चालू कर दिया, जिसमें एक भौतिकमेमोरीलिमिटपेरेंटेज 65% है। मैंने देखा कि परीक्षण के दौरान मेमोरी का उपयोग 65-68% के बीच रहता है और देखा कि चीजों को ठीक से निकाला जा रहा है। अपने परीक्षण में मैंने 5 सेकंड के लिए मतदान केंद्र को निर्धारित किया है, और इसे डिफ़ॉल्ट करने के लिए physicalMemoryLimitPercentage को 65 और physicalMemoryLimitPercentage को 0 पर सेट किया है।

उपरोक्त सलाह के बाद; IMemoryCacheManager का कार्यान्वयन कैश से चीजों को निकालने के लिए किया जा सकता है। हालांकि यह उल्लेख किए गए जीन 2 चेक मुद्दे से पीड़ित होगा। हालांकि, परिदृश्य के आधार पर, यह उत्पादन कोड में समस्या नहीं हो सकती है और लोगों के लिए पर्याप्त रूप से काम कर सकती है।

Question 7

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

 private static readonly NameValueCollection Collection = new NameValueCollection
        {
            {"CacheMemoryLimitMegabytes", "20"},
           {"PollingInterval", TimeSpan.FromMilliseconds(60000).ToString()}, // this will check the limits each 60 seconds

        };

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

Question 8

यदि आप निम्न संशोधित वर्ग का उपयोग करते हैं और टास्क मैनेजर के माध्यम से मेमोरी की निगरानी करते हैं तो वास्तव में छंटनी होती है:

internal class Cache
{
    private Object Statlock = new object();
    private int ItemCount;
    private long size;
    private MemoryCache MemCache;
    private CacheItemPolicy CIPOL = new CacheItemPolicy();

    public Cache(double CacheSize)
    {
        NameValueCollection CacheSettings = new NameValueCollection(3);
        CacheSettings.Add("cacheMemoryLimitMegabytes", Convert.ToString(CacheSize));
        CacheSettings.Add("pollingInterval", Convert.ToString("00:00:01"));
        MemCache = new MemoryCache("TestCache", CacheSettings);
    }

    public void AddItem(string Name, string Value)
    {
        CacheItem CI = new CacheItem(Name, Value);
        MemCache.Add(CI, CIPOL);

        Console.WriteLine(MemCache.GetCount());
    }
}