एल्गोरिदम मेमोरी के विभिन्न प्रकारों की गणना करने के लिए

Question

मैं स्मृति की गणना करने की कोशिश कर रहा हूं। मैं, उपलब्ध inuse, नि: शुल्क की गणना की है, और निम्न कोड

ObjectQuery wql = new ObjectQuery("SELECT * FROM Win32_OperatingSystem"); 
      ManagementObjectSearcher searcher = new ManagementObjectSearcher(wql); 
      ManagementObjectCollection results = searcher.Get(); 

      //total amount of free physical memory in bytes 
      var Available = new ComputerInfo().AvailablePhysicalMemory; 
      //total amount of physical memory in bytes 
      var Total = new ComputerInfo().TotalPhysicalMemory; 

      var PhysicalMemoryInUse = Total - Available; 
      Object Free = new object(); 
      foreach (var result in results) 
      { 
       //Free amount 
       Free = result["FreePhysicalMemory"]; 
      } 
      var Cached = Total - PhysicalMemoryInUse - UInt64.Parse(Free.ToString()); 

मैं कैसे की गणना कर सकते स्टैंडबाय, हार्डवेयर आरक्षित साथ कैश्ड, और संशोधित स्मृति के रूप में खिड़कियों में संसाधन मॉनिटर में दिखाया गया है?

Answer 1

हार्डवेयर सुरक्षित शारीरिक रूप से स्थापित मेमोरी की मात्रा और भौतिक स्मृति की कुल राशि ओएस द्वारा रिपोर्ट के बीच अंतर है।

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

public sealed class MemoryInfo : IDisposable 
{ 
    [DllImport("kernel32.dll", SetLastError = true)] 
    [return: MarshalAs(UnmanagedType.Bool)] 
    private static extern bool GetPhysicallyInstalledSystemMemory(out ulong memoryInKilobytes); 

    private readonly PerformanceCounter availableCounter; 
    private readonly PerformanceCounter modifiedCounter; 
    private readonly PerformanceCounter freeCounter; 
    private readonly PerformanceCounter standbyCoreCounter; 
    private readonly PerformanceCounter standbyNormalCounter; 
    private readonly PerformanceCounter standbyReserveCounter; 

    private ulong osTotalMemory; 

    public ulong ModifiedBytes { get; private set; } 
    public ulong InUseBytes { get; private set; } 
    public ulong StandbyBytes { get; private set; } 
    public ulong FreeBytes { get; private set; } 
    public ulong HardwareReserved { get; } 

    public MemoryInfo() 
    { 
     var computerInfo = new ComputerInfo(); 

     osTotalMemory = computerInfo.TotalPhysicalMemory; 

     ulong installedPhysicalMemInKb; 
     GetPhysicallyInstalledSystemMemory(out installedPhysicalMemInKb); 

     this.HardwareReserved = installedPhysicalMemInKb * 1024 - osTotalMemory; 

     modifiedCounter = new PerformanceCounter("Memory", "Modified Page List Bytes"); 
     standbyCoreCounter = new PerformanceCounter("Memory", "Standby Cache Core Bytes"); 
     standbyNormalCounter = new PerformanceCounter("Memory", "Standby Cache Normal Priority Bytes"); 
     standbyReserveCounter = new PerformanceCounter("Memory", "Standby Cache Reserve Bytes"); 
     freeCounter = new PerformanceCounter("Memory", "Free & Zero Page List Bytes"); 
     availableCounter = new PerformanceCounter("Memory", "Available Bytes"); 

     Refresh(); 
    } 

    public void Refresh() 
    { 
     ModifiedBytes = (ulong)modifiedCounter.NextSample().RawValue; 
     StandbyBytes = (ulong)standbyCoreCounter.NextSample().RawValue + 
         (ulong)standbyNormalCounter.NextSample().RawValue + 
         (ulong)standbyReserveCounter.NextSample().RawValue; 
     FreeBytes = (ulong)freeCounter.NextSample().RawValue; 
     InUseBytes = osTotalMemory - (ulong) availableCounter.NextSample().RawValue; 

    } 

    public void Dispose() 
    { 
     modifiedCounter.Dispose(); 
     standbyCoreCounter.Dispose(); 
     standbyNormalCounter.Dispose(); 
     standbyReserveCounter.Dispose(); 
     freeCounter.Dispose(); 
    } 
} 

इस तरह से यह कर रही है, पर्फ़ काउंटरों की तरह एक साथ समूहीकृत नहीं कर रहे हैं करने के लिए कमियां हैं, तो आप समय में एक विशिष्ट बिंदु पर सिस्टम स्मृति के एक 'असली' स्नैपशॉट नहीं मिलता है। आप शायद Pdh* win32 एपीआई फ़ंक्शंस का उपयोग करने के लिए PInvoke का उपयोग करके सुधार कर सकते हैं।

आप इसे WMI का उपयोग करने के लिए भी बदल सकते हैं (डेटा Win32_PerfRawData_PerfOS_Memory में है) लेकिन मुझे नहीं पता कि यह कैसा प्रदर्शन करेगा।

Answer 2

देखने के लिए कि क्या तुम यहाँ हो जाने के बाद कर रहे हैं - एक सांत्वना अनुप्रयोग बना सकते हैं और Program.cs की सामग्री पर पेस्ट करें। इसे कमांड लाइन से>> फ़ाइल में चलाएं और प्रासंगिक मेमोरी काउंटर देखें।

using System; 
using System.Diagnostics; 

namespace ConsoleApplication2 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      var categories = PerformanceCounterCategory.GetCategories(); 

      foreach (var cat in categories) 
      { 
       if (cat.CategoryType != PerformanceCounterCategoryType.MultiInstance) 
       { 
        Console.WriteLine("Category: " + cat.CategoryName); 
        foreach (var counter in cat.GetCounters()) 
        { 
         Console.WriteLine("Counter: " + counter.CounterName + ": " + counter.NextSample().RawValue); 
        } 
       } 
       else //if (cat.CategoryType == PerformanceCounterCategoryType.MultiInstance) 
       { 
        foreach (var instance in cat.GetInstanceNames()) 
        { 
         Console.WriteLine("Instance: " + instance); 
         foreach (var counter in cat.GetCounters(instance)) 
         { 
          try 
          { 
           Console.WriteLine("Counter: " + counter.CounterName + ": " + counter.NextSample().RawValue); 
          } catch 
          { 
           // swallow exceptions for counter that require a set base. 
          } 
         } 
        } 
       } 
      } 

      Console.ReadLine();   
     }  
    } 
} 

Answer 3

मैंने क्रिस्टोफर के नमूने का उपयोग किया और इसे हार्डवेयर आरक्षित करने के लिए सभी डब्लूएमआई के रूप में विस्तारित किया।

using System; 
using System.Management; 

namespace ConsoleApplication2 
{ 
    class Program 
    { 

     static void Main(string[] args) 
     { 
      try 
      { 
       ManagementScope Scope; 
       Scope = new ManagementScope(String.Format("\\\\{0}\\root\\CIMV2", "."), null); 
       Scope.Connect(); 

       double totalVisibleMemory = 0; 

       ObjectQuery wql = new ObjectQuery("SELECT * FROM Win32_OperatingSystem"); 
       ManagementObjectSearcher searcher = new ManagementObjectSearcher(wql); 
       ManagementObjectCollection results = searcher.Get(); 

       foreach (ManagementObject result in results) 
       { 
        totalVisibleMemory = double.Parse(result["TotalVisibleMemorySize"].ToString())/1024; 
        Console.WriteLine("Total Visible Memory: {0:0} mb", totalVisibleMemory); 
        Console.WriteLine("Free Physical Memory: {0:0} mb", double.Parse(result["FreePhysicalMemory"].ToString())/1024); 
        Console.WriteLine("Total Virtual Memory: {0:0} mb", double.Parse(result["TotalVirtualMemorySize"].ToString())/1024); 
        Console.WriteLine("Free Virtual Memory: {0:0} mb", double.Parse(result["FreeVirtualMemory"].ToString())/1024); 
       } 

       ObjectQuery Query = new ObjectQuery("SELECT Capacity FROM Win32_PhysicalMemory"); 
       ManagementObjectSearcher Searcher = new ManagementObjectSearcher(Scope, Query); 
       UInt64 Capacity = 0; 
       foreach (ManagementObject WmiObject in Searcher.Get()) 
       { 
        Capacity += (UInt64)WmiObject["Capacity"]; 
       } 

       var totalPhysicalMemory = Capacity/(1024 * 1024); 
       Console.WriteLine(String.Format("Total Physical Memory {0:0} mb", Capacity/(1024 * 1024))); 
       var hardwareReserved = totalPhysicalMemory - totalVisibleMemory; 

        Console.WriteLine(string.Format("Hardware Reserved Memory {0:0} mb", hardwareReserved)); 
      } 
      catch (Exception e) 
      { 
       Console.WriteLine(string.Format("Exception {0} Trace {1}", e.Message, e.StackTrace)); 
      } 
      Console.WriteLine("Press Enter to exit"); 
      Console.Read(); 
     } 
    } 
}