विंडोज सर्वर 2008 R2 मेटाफ़ाइल रैम उपयोग


33

मेरे पास एक सर्वर है जो 4GB RAM के साथ Windows Server 2008 R2 x64 चलाता है जो लगभग 2-3 मिलियन फ़ाइलों को होस्ट करता है, जिनमें से अधिकांश छवि फ़ाइलें हैं।

एक सप्ताह के दौरान, मैंने देखा है कि कम मेमोरी के कारण डिस्क पर अत्यधिक पेजिंग के कारण सर्वर पर एप्लिकेशन क्रॉल की गति धीमी कर रहा था, जिसका वर्तमान में चल रही सभी सेवाओं पर असर पड़ा है, जिससे एक बड़ी गड़बड़ी हुई है प्रदर्शन की समस्याएं।

टास्क मैनेजर में जांच करने पर, मैंने देखा कि लगभग सभी 4 जीबी का उपयोग किया गया था, लेकिन जब आप प्रोसीज़ टैब में देखते हैं, तो वहां सभी मेमोरी उपयोग का योग नहीं जुड़ता है और कम से कम 1.5 जीबी का उपयोग होना चाहिए।

समाधान खोजने के लिए Google का उपयोग करते हुए, यह प्रतीत होता है कि अधिकांश रैम का उपयोग "मेटाफ़ाइल" में किया गया था, जो फ़ाइल सिस्टम पर फ़ाइलों के लिए NTFS जानकारी का एक कैश है ताकि सिस्टम को फिर से जानकारी के लिए एमएफटी को क्वेरी न करना पड़े। इस कैश को कभी टास्क मैनेजर में "कैश" के रूप में या सिसिनटर्न के रामपेप में "स्टैंडबाय" के रूप में चिह्नित नहीं किया जाता है।

KB979149 हॉटफ़िक्स स्थापित करने का सुझाव था लेकिन इसे स्थापित करने का प्रयास करने पर, यह कहता है "यह अपडेट आपके कंप्यूटर पर लागू नहीं है"।

अब तक मेरे पास केवल अस्थायी सुधार हैं:

  1. टास्क मैनेजर में कैश को "स्टैंडबाय" और "कैश" के रूप में चिह्नित करने वाले हर 1-3 दिनों में सिसिन्टर्नल्स से रैममैप का उपयोग "खाली सिस्टम वर्किंग सेट" के लिए करें ताकि रैम का उपयोग अन्य अनुप्रयोगों द्वारा किया जा सके।
  2. मशीन को रिबूट करें, जो अवांछनीय है क्योंकि यह सर्वर सार्वजनिक वेबसाइटों की सेवा कर रहा है।

फिलहाल मुझे 2 प्रदर्शन करने पड़ रहे हैं। इसे टालने के स्तर तक पहुंचने से रोकने के लिए हर कुछ दिन ठीक करें।

पहले: (800 एमबी रैम का उपयोग किया गया - अन्य एप्लिकेशन इस रैम का उपयोग नहीं कर सकते)

यहाँ छवि विवरण दर्ज करें

के बाद: (800 एमबी रैम कैश के रूप में चिह्नित - अन्य अनुप्रयोगों के लिए उपलब्ध)

तो आप सभी के लिए मेरा प्रश्न है: क्या इस मेटाफ़ाइल के RAM उपयोग को सीमित करने के लिए कोई विधि मौजूद है?


4
एक सर्वर पर 4GB RAM मेजबान को 2-3 मिलियन फ़ाइलों को बेतुका है। अपनी रैम को अपग्रेड करें या अपनी रैम को अपग्रेड करें।
pauska

1
कोई बात नहीं, CysSet by Sysinternals मुझे कैश आकार सेट करने देता है, वर्तमान में अंतराल पर चल रहा है और ऐसा करने से मेरे लिए समस्या हल हो गई है!
al2k4

6
RAM जोड़ने से समस्या हल नहीं होती है। मेटाफ़िल कैश उसे भी भरेगा। मैंने एक VMware अतिथि पर यह करने की कोशिश की है जो 4 जीबी के साथ शुरू हुआ और इसे बढ़ाकर 12 जीबी कर दिया और यही बात होती है। समस्या यह है कि यह मेमोरी कैश उद्देश्यों के लिए है, लेकिन विंडोज के अनुसार कैश के रूप में चिह्नित नहीं है। इसे गलत तरीके से एक्टिव / इन यूज़ मेमोरी के रूप में चिह्नित किया गया है, और दुर्भाग्य से, जैसा कि यह बढ़ता है यह असली कार्यक्रमों द्वारा उपयोग की जाने वाली वास्तविक एक्टिव / इन मेमोरी मेमोरी को भीड़ देता है और डिस्क पर पेजिंग शुरू करता है। जब भौतिक रैम भर जाती है तो सब कुछ धीमा हो जाता है और आपको बताए गए मूल समाधान के रूप में दो में से एक समाधान करना होगा।

@ al2k4 यदि आपका प्रश्न हल हो गया है, तो कृपया उसे सही उत्तर के बगल में चेक मार्क पर क्लिक करके हल करें। सर्वर दोष में आपका स्वागत है !
माइकल हैम्पटन

जवाबों:


16

इस समस्या से निपटने के लिए सबसे अच्छा तरीका SetSystemFileCacheSizeएपीआई का उपयोग करना है क्योंकि एमएस केबी 976618 निर्देश देने के लिए उपयोग किया जाता है

समय-समय पर कैश को साफ न करें

SetSystemFileCacheSizeसमय-समय पर कैश को साफ़ करने के बजाय फ़ंक्शन का उपयोग करने से प्रदर्शन और स्थिरता में सुधार होता है। कैश को समय-समय पर साफ़ करने से बहुत अधिक मेटाफ़िल और अन्य जानकारी मेमोरी से शुद्ध हो जाएगी, और विंडोज को HDD से रैम में आवश्यक जानकारी को फिर से पढ़ना होगा। जब भी आप कैश को साफ़ करते हैं, तो यह कुछ सेकंड के लिए प्रदर्शन में अचानक और गंभीर गिरावट पैदा करता है, इसके बाद अच्छा प्रदर्शन जो धीरे-धीरे कम हो जाता है क्योंकि मेमोरी मेटाफ़ाइल डेटा से भर जाती है।

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

थर्ड पार्टी प्रोग्राम MS द्वारा असमर्थित हैं

यदि आप मेरे जैसे हैं और अपने उत्पादन सर्वर पर किसी अज्ञात तृतीय पक्ष से बाइनरी नहीं चलाना चाहते हैं, तो आप एक आधिकारिक एमएस उपकरण या कुछ कोड चाहते हैं जो आप उन सर्वरों पर चलने से पहले निरीक्षण कर सकते हैं। 2008 R2 के लिए DynCache टूल एक समर्थन मामले के लिए भुगतान किए बिना एम $ से प्राप्त करना व्यावहारिक रूप से असंभव है और काफी स्पष्ट रूप से, 2008 के लिए कोड के आधार पर, यह कार्य के लिए अत्यधिक फूला हुआ लगता है क्योंकि विंडोज में पहले से ही निर्मित डायनामिक आकार के लिए आवश्यक तर्क है कैश - यह सिर्फ आपके सिस्टम के लिए एक उपयुक्त अधिकतम पता करने की जरूरत है।

उपरोक्त सभी का समाधान

मैंने Powershell स्क्रिप्ट लिखी है जो 64 बिट मशीनों पर काम करती है। आपको इसे उन्नत विशेषाधिकार वाले व्यवस्थापक के रूप में चलाने की आवश्यकता है। आपको इसे चलाने में सक्षम होना चाहिए, जैसा कि किसी भी x64 विंडोज़ विस्टा / सर्वर 2008 पर है और 10 / सर्वर 2012 आर 2 को किसी भी मात्रा में रैम के साथ शामिल करना चाहिए। आपको कोई अतिरिक्त सॉफ़्टवेयर स्थापित करने की आवश्यकता नहीं है, और परिणामस्वरूप आपके सर्वर / कार्य केंद्र को पूरी तरह से एमएस द्वारा समर्थित रखा जाता है।

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

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

# Filename: setfc.ps1
$version = 1.1

#########################
# Settings
#########################

# The percentage of physical ram that will be used for SetSystemFileCache Maximum
$MaxPercent = 12.5

#########################
# Init multipliers
#########################
$OSBits = ([System.IntPtr]::Size) * 8
switch ( $OSBits)
{
    32 { $KiB = [int]1024 }
    64 { $KiB = [long]1024 }
    default {
        # not 32 or 64 bit OS. what are you doing??
        $KiB = 1024 # and hope it works anyway
        write-output "You have a weird OS which is $OSBits bit. Having a go anyway."
    }
}
# These values "inherit" the data type from $KiB
$MiB = 1024 * $KiB
$GiB = 1024 * $MiB
$TiB = 1024 * $GiB
$PiB = 1024 * $TiB
$EiB = 1024 * $PiB


#########################
# Calculated Settings
#########################

# Note that because we are using signed integers instead of unsigned
# these values are "limited" to 2 GiB or 8 EiB for 32/64 bit OSes respectively

$PhysicalRam = 0
$PhysicalRam = [long](invoke-expression (((get-wmiobject -class "win32_physicalmemory").Capacity) -join '+'))
if ( -not $? ) {
    write-output "Trying another method of detecting amount of installed RAM."
 }
if ($PhysicalRam -eq 0) {
    $PhysicalRam = [long]((Get-WmiObject -Class Win32_ComputerSystem).TotalPhysicalMemory) # gives value a bit less than actual
}
if ($PhysicalRam -eq 0) {
    write-error "Cannot Detect Physical Ram Installed. Assuming 4 GiB."
    $PhysicalRam = 4 * $GiB
}
$NewMax = [long]($PhysicalRam * 0.01 * $MaxPercent)
# The default value
# $NewMax = 1 * $TiB


#########################
# constants
#########################

# Flags bits
$FILE_CACHE_MAX_HARD_ENABLE     = 1
$FILE_CACHE_MAX_HARD_DISABLE    = 2
$FILE_CACHE_MIN_HARD_ENABLE     = 4
$FILE_CACHE_MIN_HARD_DISABLE    = 8


################################
# C# code
# for interface to kernel32.dll
################################
$source = @"
using System;
using System.Runtime.InteropServices;

namespace MyTools
{
    public static class cache
    {
        [DllImport("kernel32", SetLastError = true, CharSet = CharSet.Unicode)]
        public static extern bool GetSystemFileCacheSize(
            ref IntPtr lpMinimumFileCacheSize,
            ref IntPtr lpMaximumFileCacheSize,
            ref IntPtr lpFlags
            );

        [DllImport("kernel32", SetLastError = true, CharSet = CharSet.Unicode)]
        public static extern bool SetSystemFileCacheSize(
          IntPtr MinimumFileCacheSize,
          IntPtr MaximumFileCacheSize,
          Int32 Flags
        );

        [DllImport("kernel32", CharSet = CharSet.Unicode)]
        public static extern int GetLastError();

        public static bool Get( ref IntPtr a, ref IntPtr c, ref IntPtr d )
        {
            IntPtr lpMinimumFileCacheSize = IntPtr.Zero;
            IntPtr lpMaximumFileCacheSize = IntPtr.Zero;
            IntPtr lpFlags = IntPtr.Zero;

            bool b = GetSystemFileCacheSize(ref lpMinimumFileCacheSize, ref lpMaximumFileCacheSize, ref lpFlags);

            a = lpMinimumFileCacheSize;
            c = lpMaximumFileCacheSize;
            d = lpFlags;
            return b;
        }


        public static bool Set( IntPtr MinimumFileCacheSize, IntPtr MaximumFileCacheSize, Int32 Flags )
        {
            bool b = SetSystemFileCacheSize( MinimumFileCacheSize, MaximumFileCacheSize, Flags );
            if ( !b ) {
                Console.Write("SetSystemFileCacheSize returned Error with GetLastError = ");
                Console.WriteLine( GetLastError() );
            }
            return b;
        }
    }

    public class AdjPriv
    {
        [DllImport("advapi32.dll", ExactSpelling = true, SetLastError = true)]
        internal static extern bool AdjustTokenPrivileges(IntPtr htok, bool disall, ref TokPriv1Luid newst, int len, IntPtr prev, IntPtr relen);

        [DllImport("advapi32.dll", ExactSpelling = true, SetLastError = true)]
        internal static extern bool OpenProcessToken(IntPtr h, int acc, ref IntPtr phtok);

        [DllImport("advapi32.dll", SetLastError = true)]
        internal static extern bool LookupPrivilegeValue(string host, string name, ref long pluid);

        [StructLayout(LayoutKind.Sequential, Pack = 1)]
        internal struct TokPriv1Luid
        {
            public int Count;
            public long Luid;
            public int Attr;
        }
        internal const int SE_PRIVILEGE_ENABLED = 0x00000002;
        internal const int SE_PRIVILEGE_DISABLED = 0x00000000;
        internal const int TOKEN_QUERY = 0x00000008;
        internal const int TOKEN_ADJUST_PRIVILEGES = 0x00000020;

        public static bool EnablePrivilege(long processHandle, string privilege, bool disable)
        {
            bool retVal;
            TokPriv1Luid tp;
            IntPtr hproc = new IntPtr(processHandle);
            IntPtr htok = IntPtr.Zero;
            retVal = OpenProcessToken(hproc, TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, ref htok);
            tp.Count = 1;
            tp.Luid = 0;
            if(disable)
            {
                tp.Attr = SE_PRIVILEGE_DISABLED;
            } else {
                tp.Attr = SE_PRIVILEGE_ENABLED;
            }
            retVal = LookupPrivilegeValue(null, privilege, ref tp.Luid);
            retVal = AdjustTokenPrivileges(htok, false, ref tp, 0, IntPtr.Zero, IntPtr.Zero);
            return retVal;
        }
    }
}
"@
# Add the c# code to the powershell type definitions
Add-Type -TypeDefinition $source -Language CSharp

#########################
# Powershell Functions
#########################
function output-flags ($flags)
{
    Write-output ("FILE_CACHE_MAX_HARD_ENABLE  : " + (($flags -band $FILE_CACHE_MAX_HARD_ENABLE) -gt 0) )
    Write-output ("FILE_CACHE_MAX_HARD_DISABLE : " + (($flags -band $FILE_CACHE_MAX_HARD_DISABLE) -gt 0) )
    Write-output ("FILE_CACHE_MIN_HARD_ENABLE  : " + (($flags -band $FILE_CACHE_MIN_HARD_ENABLE) -gt 0) )
    Write-output ("FILE_CACHE_MIN_HARD_DISABLE : " + (($flags -band $FILE_CACHE_MIN_HARD_DISABLE) -gt 0) )
    write-output ""
}

#########################
# Main program
#########################

write-output ""

#########################
# Get and set privilege info
$ProcessId = $pid
$processHandle = (Get-Process -id $ProcessId).Handle
$Privilege = "SeIncreaseQuotaPrivilege"
$Disable = $false
Write-output ("Enabling SE_INCREASE_QUOTA_NAME status: " + [MyTools.AdjPriv]::EnablePrivilege($processHandle, $Privilege, $Disable) )

write-output ("Program has elevated privledges: " + ([Security.Principal.WindowsPrincipal] [Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole] "Administrator") )
write-output ""
whoami /PRIV | findstr /I "SeIncreaseQuotaPrivilege" | findstr /I "Enabled"
if ( -not $? )  {
    write-error "user Security Token SE_INCREASE_QUOTA_NAME: Disabled`r`n"
}
write-output "`r`n"


#########################
# Get Current Settings
# Init variables
$SFCMin = 0
$SFCMax = 0
$SFCFlags = 0
#Get Current values from kernel
$status = [MyTools.cache]::Get( [ref]$SFCMin, [ref]$SFCMax, [ref]$SFCFlags )
#typecast values so we can do some math with them
$SFCMin = [long]$SFCMin
$SFCMax = [long]$SFCMax
$SFCFlags = [long]$SFCFlags
write-output "Return values from GetSystemFileCacheSize are: "
write-output "Function Result : $status"
write-output "            Min : $SFCMin"
write-output ("            Max : $SFCMax ( " + $SFCMax / 1024 / 1024 / 1024 + " GiB )")
write-output "          Flags : $SFCFlags"
output-flags $SFCFlags


#########################
# Output our intentions
write-output ("Physical Memory Detected : $PhysicalRam ( " + $PhysicalRam / $GiB + " GiB )")
write-output ("Setting Max to " + $MaxPercent + "% : $NewMax ( " + $NewMax / $MiB + " MiB )`r`n")

#########################
# Set new settings
$SFCFlags = $SFCFlags -bor $FILE_CACHE_MAX_HARD_ENABLE # set max enabled
$SFCFlags = $SFCFlags -band (-bnot $FILE_CACHE_MAX_HARD_DISABLE) # unset max dissabled if set
# or if you want to override this calculated value
# $SFCFlags = 0
$status = [MyTools.cache]::Set( $SFCMin, $NewMax, $SFCFlags ) # calls the c# routine that makes the kernel API call
write-output "Set function returned: $status`r`n"
# if it was successfull the new SystemFileCache maximum will be NewMax
if ( $status ) {
    $SFCMax = $NewMax
}


#########################
# After setting the new values, get them back from the system to confirm
# Re-Init variables
$SFCMin = 0
$SFCMax = 0
$SFCFlags = 0
#Get Current values from kernel
$status = [MyTools.cache]::Get( [ref]$SFCMin, [ref]$SFCMax, [ref]$SFCFlags )
#typecast values so we can do some math with them
$SFCMin = [long]$SFCMin
$SFCMax = [long]$SFCMax
$SFCFlags = [long]$SFCFlags
write-output "Return values from GetSystemFileCacheSize are: "
write-output "Function Result : $status"
write-output "            Min : $SFCMin"
write-output ("            Max : $SFCMax ( " + $SFCMax / 1024 / 1024 / 1024 + " GiB )")
write-output "          Flags : $SFCFlags"
output-flags $SFCFlags

शीर्ष के पास लाइन है जो कहती है $MaxPercent = 12.5कि कुल भौतिक रैम के 12.5% ​​के लिए नया अधिकतम कामकाजी सेट (सक्रिय मेमोरी) सेट करता है। विंडोज सिस्टम की मांगों के आधार पर सक्रिय मेमोरी में मेटाफ़ाइल डेटा की मात्रा को गतिशील रूप से आकार देगा, इसलिए आपको इसे अधिकतम डायनामिक रूप से समायोजित करने की आवश्यकता नहीं है।

यह आपके द्वारा मैप की गई फ़ाइल कैश के बहुत बड़े होने के साथ किसी भी समस्या को ठीक नहीं करेगा।

मैंने एक GetSystemFileCacheSizeपॉवरशेल स्क्रिप्ट भी बनाई है और इसे StackOverflow पर पोस्ट किया है


संपादित करें: मुझे यह भी इंगित करना चाहिए कि आपको इन 2 लिपियों में से एक ही पॉवर्सशेल इंस्टेंस से एक से अधिक बार नहीं चलना चाहिए, या आपको यह त्रुटि प्राप्त होगी कि Add-Typeकॉल पहले ही हो चुकी है।

संपादित करें: SetSystemFileCacheSizeसंस्करण 1.1 के लिए अद्यतन स्क्रिप्ट जो आपके लिए एक उपयुक्त अधिकतम कैश मान की गणना करता है और एक अच्छा स्थिति आउटपुट लेआउट है।

संपादित करें: अब मैंने अपना विंडोज 7 लैपटॉप अपग्रेड कर लिया है, मैं आपको बता सकता हूं कि स्क्रिप्ट विंडोज 10 में सफलतापूर्वक चलती है, हालांकि मैंने परीक्षण नहीं किया है अगर यह अभी भी आवश्यक है। लेकिन वर्चुअल मशीन HDD फ़ाइलों को चारों ओर ले जाने पर भी मेरा सिस्टम स्थिर है।


DynCache टूल microsoft.com/en-us/download/details.aspx?id=9258 से डाउनलोड के लिए स्वतंत्र रूप से उपलब्ध है और 2008 R2 का समर्थन करता है।
जैकब बेरेज़ांस्की

यह अभी है। R2 विंडो रिलीज़ और DynCache रिलीज़ के बीच एक लंबा समय था। एमएस ब्लॉग पोस्ट अपडेट के लिए blogs.technet.com/b/yongrhee/archive/2010/02/16/… देखें । मैं अभी भी अपने समाधान को पसंद करता हूं क्योंकि इसे अभी तक किसी अन्य सेवा को चलाने के लिए अतिरिक्त संसाधनों की आवश्यकता नहीं है। हमारे सर्वर मेरी स्क्रिप्ट के साथ बहुत स्थिर हो गए हैं, इसलिए मैं उन्हें DynCache पर नहीं बदल रहा हूं।
बियोवुल्फ़न्यूड42

@ BeowulfNode42 - हमें मैप की गई फ़ाइल कैश बड़ी होने की समस्या है। क्या आपके पास इसका समाधान करने के लिए कोई संकेत हैं? मैं इस धारणा के तहत था कि सिस्टम फ़ाइल कैश आकार सेट करना भी उस समस्या को हल करेगा ?! क्या आपके पास कोई विचार है अगर (फूला हुआ) DynCache टूल उस समस्या को हल कर देगा?
लेवेन केर्सेमेकर्स

fwiw - मैंने सिर्फ एक टेस्टर पर कोशिश की और मैप की गई फ़ाइल (rammap) को 12GB Active, 0GB Standby से 8GB Active, 4GB Standby से मिला। सभी इरादों और उद्देश्यों के लिए, यह मैप्ड फ़ाइलों के लिए भी काम करने लगता है ?!
लेवेन केर्सेमेकर्स

@LievenKeersmaekers जो अजीब है। शायद यह प्रभाव पर किसी प्रकार का प्रवाह है। मैं एक अच्छी तरह से मैप की गई फ़ाइल कैश समस्या को हल करने के लिए एक अच्छे तरीके से नहीं आया हूं जब फास्ट स्टोरेज से फ़ाइलों को धीमी गति से कॉपी करने का अनुभव होता है, हालांकि मैंने डायनेचे टूल की कोशिश नहीं की है, क्योंकि हमारे लिए मैप की गई फ़ाइल कैश समस्या मुख्य रूप से सिर्फ एक कष्टप्रद अस्थायी है हमारे बैकअप को प्रबंधित करने वाले हमारे सर्वर पर धीमा। भविष्य के संदर्भ के लिए कि टेस्ट सिस्टम में कितना रैम है और क्या आप स्क्रिप्ट को 12.5% ​​सेटिंग के साथ पोस्ट कर रहे थे, और यदि आप याद करते हैं या अन्य प्रकार के मेमोरी साइज रिकॉर्ड करते हैं?
BeowulfNode42

4

मैं विंडोज़ ओएस में मेमोरी या डिस्क कैशिंग के आंतरिक कामकाज के बारे में एक विशेषज्ञ होने का दावा नहीं करता, लेकिन मेरे पास दो अवलोकन हैं:

  1. यदि ओएस ने मेमोरी में डेटा को कैश नहीं किया है, तो इसे डिस्क से पढ़ना होगा, जो कि एक तेजी से धीमा स्टोरेज मीडिया है, फिर मेमोरी, इसलिए आप जो प्रदर्शन समस्या देख रहे हैं वह लगभग निश्चित रूप से बदतर होगी।

  2. आप समस्या के कारण के बजाय समस्या के एक लक्षण का इलाज करके समस्या को हल करने का प्रयास कर रहे हैं। समस्या का कारण निश्चित रूप से पर्याप्त शारीरिक रैम की कमी है और मेरा सुझाव यह होगा कि इसका समाधान किया जाए।

इसके अलावा, जबकि कैश 1.5GB RAM का उपयोग कर रहा है, मुझे आश्चर्य होगा कि स्मृति का उपयोग अन्य प्रक्रियाओं और सेवाओं के लिए क्या है और संभावित समस्याओं के लिए उस उपयोग की जांच करने के लिए समाधान हो सकता है।


ठीक ठीक। यदि ओपी ने मेटाफ़ाइल का रैम उपयोग कम कर दिया है, तो सिस्टम को डिस्क से अधिक मेटाडेटा लोड करना होगा क्योंकि यह कम मेमोरी में होगा, जिससे चीजें खराब हो सकती हैं।
डेविड श्वार्ट्ज

1
प्रतिक्रिया के लिए धन्यवाद। कुछ चीजें, सर्वर मुख्य रूप से एक MySQL डेटाबेस वाला एक वेब सर्वर है और फाइलों को बहुत बार नहीं पढ़ता है इसलिए कैश में नहीं होने के मेटाडेटा का मामूली प्रभाव न्यूनतम है, जब मंजूरी दे दी जाती है तो प्रदर्शन नाटकीय रूप से बढ़ जाता है। यह विभिन्न फाइलों की संख्या है जो समय के साथ पढ़ती है यही कारण है कि कैश का आकार उच्च और उच्च हो जाता है। मुझे अच्छी तरह पता है कि अधिक RAM इसे हल करेगा, लेकिन "कैश" का विचार स्मृति को मुक्त करने के लिए नहीं है जब सर्वर पर एप्लिकेशन या स्क्रिप्ट को पेजिंग से बचने के लिए वास्तव में इसकी आवश्यकता होती है? क्यों इस निश्चित कैश को हमेशा सक्रिय के रूप में चिह्नित किया जाता है।
al2k4

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

ज्यादा ट्रोल? यह सवाल दो साल से अधिक पुराना है।
जोकेवेटी

@joeqwerty मैं इस समस्या के बारे में नेट पर हर समय नए पोस्ट देखता हूं। इस सवाल पर संबंधित खोजों में से कई आते हैं। चूंकि मैं अपना जवाब अपडेट कर रहा था और मुझे विश्वास है कि आपका उत्तर "उपयोगी नहीं है" मैंने इसे ऐसे ही चिह्नित किया और टिप्पणी की कि क्यों। अगर वह मुझे ट्रोल करता है, तो ऐसा ही हो।
बेवुल्फनोडे42

3

जिन लोगों ने स्पष्ट रूप से अप्रभावी समाधान दिया, उनमें केवल अधिक रैम जोड़ने के लिए, आपने स्पष्ट रूप से इस मुद्दे को पहले हाथ से नहीं निपटाया है।

जैसा कि पहले के एक पोस्टर द्वारा कहा गया है, इससे कोई फर्क नहीं पड़ता कि आप समस्या में कितना रैम फेंकते हैं ... यह सभी को भर देगा। मैं अपने ऐप सर्वर पर एक एटलसियन टूल सेट चला रहा हूं जो 32 बिट (2003) से 64 बिट (2008) में माइग्रेट किया गया था। यह तुरंत स्पष्ट हो गया था कि एक प्रदर्शन हानि हुई थी।

जब कार्य प्रबंधक को देखते हैं, तो लगभग सभी मेमोरी का उपयोग किया जाता था; हालाँकि जो प्रक्रियाएँ चल रही हैं, वे इसे प्रतिबिंबित नहीं करती हैं। जब हमने मेमोरी को 8 जीबी से बढ़ाकर 16 जीबी कर दिया, तो समस्या ने अतिरिक्त मेमोरी को भी खा लिया।

समस्या का इलाज करने का एकमात्र तरीका सर्वर को पुनरारंभ करना था, जिसने प्रक्रियाओं के बराबर मेमोरी उपयोग को कम किया (लगभग 3.5 जीबी)। एक-एक दिन में यह फिर से चढ़ने लगा।

मुझे पता था कि यह एक नया Microsoft बग / फीचर था और इस लेख को पाकर खुश था। मुझे पता है कि Microsoft उपयोगकर्ताओं के लिए यह सब महत्वपूर्ण विवरण कैसे छोड़ता है। मैंने RamMap डाउनलोड किया, जो आपको लगता है कि एक देशी उपयोगिता होगी, और अब मैं मेटाफ़ाइल का उपयोग देख सकता हूं। हम कैश को हर कुछ दिनों में साफ़ करने के लिए सेट करेंगे और उम्मीद है कि इससे समस्या हल हो जाएगी।

यह दिलचस्प है कि मैंने इस समस्या को हमारे कई माइग्रेट किए गए सर्वरों में से एक पर देखा है, इसलिए मैं सोच रहा हूं कि क्या मेटाफ़ाइल केवल कुछ प्रकार के अनुप्रयोगों से खिलाया जाता है।


1
मेरे अनुभव में, फ़ाइल सिस्टम मेटाडेटा के आकार से परे मेटाफ़ाइल मेमोरी का उपयोग बहुत अधिक नहीं बढ़ेगा (जो कि यह कैशिंग है, सब के बाद), इसलिए फ़ाइल को सिस्टम मेटाडेटा को मेमोरी में फिट होने देने के लिए रैम को अपग्रेड करना कम से कम कुछ मामलों में एक व्यवहार्य समाधान है। मैंने यह भी सिफारिश की है कि ग्राहक करोड़ों अस्थायी फ़ाइलों जैसे cruft को हटाकर फाइलसिस्टम मेटाडेटा के आकार को कम कर दें जो महीनों में छुआ नहीं गया है। यह बल्कि अजीब है कि विंडोज प्रभावी रूप से एप्लिकेशन मेमोरी में एनटीएफएस मेटाडेटा को प्राथमिकता देता है, लेकिन किसी फ़ाइल के लिए क्लस्टर को देखना स्मृति में एमएफटी के बिना बहुत धीमा हो सकता है।
जेम्स एल

2
मैं सहमत हूं - अधिक राम जोड़ना समस्या को ठीक नहीं करता है, यह सिर्फ अधिक उपभोग करेगा और अन्य सभी प्रक्रियाएं अंततः रुक जाएगी। मैंने हाल ही में 24 जीबी में अपग्रेड किया है, केवल एसक्यूएल 8 (फाइन) लेने के लिए, और मेटाफ़ाइल में 12 है .. जेम्स एन - आप समय-समय पर इसे साफ़ करने के लिए किस टूल का उपयोग कर रहे हैं?
सिरथोमास

2

इस समस्या को जल्दी और SysInternals CacheSet टूल का उपयोग करके मुफ्त में संबोधित किया जा सकता है। सिस्टम रैम की मात्रा से कम उपयुक्त मान के लिए अधिकतम सेटिंग वर्क सेट करें, और लागू करें।


1

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


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

2
हाँ। क्या लगता है;) यही कारण है कि मैं अपना हार्डवेयर खरीदता हूं। होस्ट पागल हैं - आप 3 महीने में रैम खरीद सकते हैं। ठीक है, सीखने के लिए सबक: एक अव्यवसायिक सेटअप आपको काटने के लिए वापस आता है।
टॉमटॉम

सभी 64 बिट विंडो सिस्टम में मेटाटाइल डेटा की अधिकतम मात्रा के लिए सक्रिय स्मृति में 1TB की सेटिंग है (अन्य चीजों की अधिक स्मृति की आवश्यकता होने पर उपयोग किए जाने के लिए तैयार कैश्ड स्टैंडबाय मेमोरी के रूप में नहीं माना जाता है)। मैं आपके बारे में नहीं जानता, लेकिन मैंने अभी तक इसमें कोई मेमोरी वाला कोई विंडो बॉक्स नहीं देखा है। HDD पर संग्रहीत अधिक फ़ाइलों का उपयोग करने के लिए आपको अधिक RAM स्थापित नहीं करना चाहिए। NTFS प्रति वॉल्यूम 4,294,967,295 फ़ाइलों का समर्थन करने वाला है। एक 4TB NTFS ड्राइव को तब 900 मिलियन से अधिक फ़ाइलों का समर्थन करने में सक्षम होना चाहिए। कोशिश करें और उस पर डीफ़्रैग या बैकअप चलाएं और यह विफल या क्रॉल हो जाएगा।
बेवुल्फनोडे42

1
हां, आपके पास होना चाहिए अगर आपके "सर्वर" में एक शक्तिशाली लैपटॉप की तुलना में कम रैम है। यह "हास्यास्पद रूप से उच्च हो" के बारे में नहीं है। यह "पर्याप्त प्राप्त करें कि सर्वर उस नाम के योग्य है"।
टॉमटॉम

1

यहां Microsoft DynCache टूल डाउनलोड करने के लिए एक लिंक दिया गया है - टिकट बनाने या भुगतान करने की आवश्यकता नहीं है। http://www.microsoft.com/en-us/download/details.aspx?displaylang=en&id=9258

(क्षमायाचना - अब केवल यह देखना कि यह R2 संस्करण के लिए नहीं है)

जाना जाता निरंतर कैश विकास के लिए इस मुद्दे को माइक्रोसॉफ्ट ब्लॉग पर यहाँ वर्णित है: http://blogs.msdn.com/b/ntdebugging/archive/2007/11/27/too-much-cache.aspx

[अद्यतन] विंडोज सर्वर 2008 R2 के लिए काम कर फिक्स।

मुझे कोडप्लेक्स पर नमूना सी # कोड मिला, जल्दी से विज़ुअल स्टूडियो के साथ कंसोल सी # प्रोजेक्ट बनाया और संकलित, काम किया।

https://asstoredprocedures.svn.codeplex.com/svn/ASSP/FileSystemCache.cs

ध्यान दें, आपको Microsoft.AnalysisServices.AdomdClient का संदर्भ जोड़ना होगा जो यहां पाया जा सकता है:

C: \ Program Files (x86) \ Microsoft.NET \ ADOMD.NET

और XMLADiscover के अनावश्यक संदर्भ के साथ ClearAllCaches () विधि (मेरे मामले में) पर टिप्पणी करें। इसे टास्कस्किडर में फेंक दें।


0

आप MS से DynCache टूल प्राप्त कर सकते हैं जो मेटाफ़ाइल द्वारा रैम के उपयोग को प्रतिबंधित करने की अनुमति देगा।

MS से टूल प्राप्त करने के लिए यहां क्लिक करें


यह लिंक 2008 R2 सिस्टम के लिए कुछ भी नहीं प्रदान करता है। एम $ अभी भी अपना क्रेडिट कार्ड चाहते हैं ताकि आप इस ज्ञात समस्या को ठीक करने के लिए भुगतान कर सकें।
बियोवुल्फ़्नोडे42
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.