सी #: मेमोरी लीक अनुकरण करें

Question

मैं निम्नलिखित कोड को सी # में लिखना चाहता हूं। ए) छोटे कंसोल एप्लिकेशन जो स्मृति रिसाव को अनुकरण करता है। ख) छोटे सांत्वना अनुप्रयोग है कि इसके बाद के संस्करण आवेदन आह्वान और रिलीज के बाद उसे तुरंत प्रबंध स्मृति रिसाव समस्या का अनुकरण करेंगे ..

दूसरे शब्दों में (ख) आवेदन लगातार फोन और जारी आवेदन होगा (क) अनुकरण करने के लिए कैसे " विद्रोही "स्मृति रिसाव अनुप्रयोग मूल कारण को संबोधित करने के साथ निहित किया जा रहा है जो आवेदन (ए) है।

आवेदन (ए) और (बी) के लिए कुछ नमूना कोड बहुत उपयोगी होंगे।

धन्यवाद

Answer 1

लीक आवेदन प्रकार दिखाई देंगे:

public static void Main() 
{ 
    var list = new List<byte[]>(); 
    while (true) 
    { 
    list.Add(new byte[1024]); // Change the size here. 
    Thread.Sleep(100); // Change the wait time here. 
    } 
} 

और बुला आवेदन लग सकता है जैसे:

public static void Main() 
{ 
    Process process = Process.Start("leaker.exe"); 
    process.Kill(); 
} 

properties on the Process वर्ग पर एक नजर डालें। ऐसे कई हैं जो वापस लौटते हैं कि प्रक्रिया कितनी मेमोरी खा रही है। आप प्रक्रिया में सशर्त रूप से मारने के लिए उनमें से एक का उपयोग करने में सक्षम हो सकते हैं।

Answer 2

आप बस एक टाइमर पर एक वैश्विक सूची में वस्तुओं को जोड़कर एक स्मृति रिसाव अनुकरण कर सकते हैं।

Answer 3

बस IDISposable ऑब्जेक्ट बनाएं और उनका निपटान न करें! उदाहरण ImageGraphics या संसाधनों को बनाने/प्रबंधित करने के लिए अप्रबंधित कोड में शाखाओं के किसी भी प्रकार के हैंडल या कोड होने के उदाहरण हैं।

Answer 4

नीचे दिए गए पते जो आप चाहते हैं (ए) एक कंसोल ऐप से एक ग्रेडियल मेमोरी लीक जहां आप रिसाव की राशि निर्धारित कर सकते हैं और अवधि को रिसाव कर सकते हैं।

1. कंसोल अनुप्रयोग यही कारण है कि धीरे-धीरे स्मृति को खाती
2. पैरामीटर # 1 मेमोरी यह मेगाबाइट (यानी 6000 6 Gigs)
3. पैरामीटर # 2 प्रत्येक पुनरावृत्ति के लिए धीरे-धीरे देरी है में खा जाएगा
4. प्रतिबद्ध मेमोरी और कार्य सेट एक ही

यह करने के लिए डिजाइन किया गया था चारों ओर हो जाएगा (अर्थात 1000 1 सेकंड है) XmlNode का उपयोग उस ऑब्जेक्ट के रूप में करें जो मेमोरी लेता है क्योंकि तब COMMITTED MEMORY (ओएस में प्रक्रिया द्वारा आवंटित स्मृति) और वर्किंग सेट मेमरी (वास्तव में प्रक्रिया द्वारा उपयोग की जाने वाली मेमोरी) वही होगी। यदि एक प्राइमेटिव प्रकार का उपयोग बाइट [] सरणी जैसे मेमोरी लेने के लिए किया जाता है, तो वर्किंग सेट आमतौर पर कुछ भी नहीं है, क्योंकि स्मृति आवंटित नहीं किया जाता है, भले ही इसे आवंटित किया गया हो।

बिल्ड टैब के अंतर्गत प्रोजेक्ट गुणों के तहत x64 में संकलित करना सुनिश्चित करें। अन्यथा यदि यह x32 में संकलित है तो इसे 1.7 गीगा सीमा के आसपास आउटऑफमेमरी त्रुटि मिल जाएगी। X64 में जो मेमोरी खाती है वह सुंदर "असीमित" होगी।

using System; 
using System.Xml; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Threading; 
using System.Threading.Tasks; 
using System.Runtime.InteropServices; 

namespace MemoryHog 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      Console.WriteLine(" Total Memory To Eat Up in Megs: " + args[0]); 
      Console.WriteLine("Millisecs Pause Between Increments: " + args[1]);    
      int memoryTotalInMegaBytes  = Convert.ToInt32(args[0]); 
      int secondsToPause    = Convert.ToInt32(args[1]); 

      Console.WriteLine("Memory Usage:" +  Convert.ToString(GC.GetTotalMemory(false))); 

      long runningTotal = GC.GetTotalMemory(false); 
      long endingMemoryLimit = Convert.ToInt64(memoryTotalInMegaBytes) * 1000 *  1000; 
      List<XmlNode> memList = new List<XmlNode>(); 
      while (runningTotal <= endingMemoryLimit) 
      { 
       XmlDocument doc = new XmlDocument(); 
       for (int i=0; i < 1000000; i++) 
       { 
        XmlNode x = doc.CreateNode(XmlNodeType.Element, "hello", ""); 
        memList.Add(x); 
       } 
       runningTotal = GC.GetTotalMemory(false); 
       Console.WriteLine("Memory Usage:" +  Convert.ToString(GC.GetTotalMemory(false))); 
       Thread.Sleep(secondsToPause); 
      } 
      Console.ReadLine(); 

     } 

    } 
} 

और के रूप में ब्रायन गिदोन के जवाब पहले से ही की सिफारिश की, तो आपको निम्न कोड का उपयोग कर और उसके बाद की हत्या की प्रक्रिया अपनी ओर से इस कॉल कर सकते हैं (ख)।नीचे दिए गए उदाहरण MemoryHog.exe कॉल (ऊपर कोड से कार्यक्रम) 6 Gigs अप खाने के लिए और रोक हर 2 सेकंड

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Diagnostics; 
using System.Threading.Tasks; 

namespace ProcessLauncher 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      Process process = Process.Start("MemoryHog.exe", "6000 2000"); 
      Console.Read(); 
      process.Kill(); 

     } 
    } 
} 

Answer 5

मैं इस कोड के साथ मेरा बनाया:

internal class Program 
{ 
    private static void Main(string[] args) 
    { 
     try 
     { 
      var limit = 9400; 
      while (true) 
      { 
       var thread = new Thread(() => IncreaseMemory(limit)); 
       thread.Start(); 
      } 
     } 
     catch (Exception) 
     { 
      // swallow exception 
     } 

    } 

    private static void IncreaseMemory(long limity) 
    { 
     var limit = limity; 

     var list = new List<byte[]>(); 
     try 
     { 
      while(true) 
      { 
       list.Add(new byte[limit]); // Change the size here. 
       Thread.Sleep(1000); // Change the wait time here. 
      } 
     } 

     catch (Exception ex) 
     { 
      // do nothing 
     } 
    } 

} 

Answer 6

मेरे पास है स्वीकार किए गए उत्तर में वर्णित दृष्टिकोण का उपयोग करने की कोशिश की, लेकिन यह काम नहीं किया - ऐसा लगता है कि कंपाइलर या रनटाइम ने इसे अनुकूलित किया है।

मैं सबसे सरल संशोधन जो इस काम में आता है पाया है:

var rnd = new Random(); 
var list = new List<byte[]>(); 
while (true) 
{ 
    byte[] b = new byte[1024]; 
    b[rnd.Next(0, b.Length)] = byte.MaxValue; 
    list.Add(b); 

    Thread.Sleep(10); 
} 

इस कोड को आवेदन अधिक से अधिक स्मृति का उपभोग करता है।