RAM-Auslastung der Windows Server 2008 R2-Metadatei

Ich habe einen Server, auf dem Windows Server 2008 R2 x64 mit 4 GB RAM ausgeführt wird, auf dem ungefähr 2-3 Millionen Dateien gespeichert sind, von denen die meisten Bilddateien sind.

Über einen Zeitraum von einer Woche habe ich festgestellt, dass die Anwendungen auf dem Server aufgrund von übermäßigem Paging auf der Festplatte aufgrund des geringen Arbeitsspeichers langsamer werden, was sich auf alle Dienste auswirkt, die derzeit auf dem Server ausgeführt werden Leistungsproblem.

Bei der Untersuchung im Task-Manager stellte ich fest, dass fast alle 4 GB belegt waren. Wenn Sie sich jedoch die Registerkarte "Prozesse" ansehen, summiert sich die Gesamtsumme der dort verwendeten Speicherkapazität nicht auf und es sollten höchstens 1,5 GB belegt sein.

Bei der Suche nach einer Lösung hat Google den Eindruck, dass der größte Teil des Arbeitsspeichers in der "Metadatei" verwendet wurde, bei der es sich um einen Cache mit NTFS-Informationen für Dateien im Dateisystem handelt, sodass das System die MFT nicht erneut nach Informationen abfragen muss. Dieser Cache wird im Task-Manager niemals gelöscht oder als "Cache" oder in Sysinternals RamMap als "Standby" markiert.

Es war ein Vorschlag das KB979149 - Hotfix zu installieren , aber beim Versuch , es zu installieren, sagt sie „Das Update auf Ihren Computer nicht anwendbar ist“.

Die einzigen vorübergehenden Korrekturen, die ich bisher gefunden habe, sind:

1. Verwenden Sie RAMmap von Sysinternals, um alle 1-3 Tage den Systemarbeitssatz zu leeren, wodurch der Cache im Task-Manager als "Standby" und "Cache" gekennzeichnet wird, damit der RAM von anderen Anwendungen verwendet werden kann.
2. Starten Sie den Computer neu, was unerwünscht ist, da dieser Server öffentliche Websites bedient.

Im Moment muss ich den 2. Fix alle paar Tage durchführen, um zu verhindern, dass er Engpässe erreicht.

Vorher: (800 MB RAM verwendet - andere Anwendungen können diesen RAM nicht verwenden)

After: (800 MB RAM als Cache markiert - für andere Anwendungen verfügbar)

Meine Frage an Sie alle lautet also: Gibt es eine Methode, um die RAM-Nutzung dieser Metadatei zu begrenzen?

Die beste Methode , mit diesem Problem umzugehen ist , die verwenden SetSystemFileCacheSizeAPI wie MS KB976618 anweist anweisen , verwendet .

Leeren Sie den Cache nicht regelmäßig

Wenn Sie die SetSystemFileCacheSizeFunktion verwenden, anstatt den Cache regelmäßig zu leeren, werden Leistung und Stabilität verbessert. Wenn der Cache regelmäßig geleert wird, werden zu viele Metadateien und andere Informationen aus dem Speicher entfernt, und Windows muss die erforderlichen Informationen erneut von der Festplatte in den Arbeitsspeicher zurücklesen. Dies führt zu einem plötzlichen und starken Leistungseinbruch für einige Sekunden, wenn Sie den Cache leeren, gefolgt von einer guten Leistung, die sich langsam verschlechtert, wenn sich der Speicher mit Metadateidaten füllt.

Durch die Verwendung der SetSystemFileCacheSizeFunktion werden Minimum und Maximum festgelegt, die dazu führen, dass Windows überschüssige alte Metadateidaten als Standby-Speicher kennzeichnet, den die normalen Caching-Funktionen je nach aktuellem Ressourcenbedarf und normalen Cache-Prioritäten verwenden oder verwerfen können. Dies ermöglicht auch, dass mehr Metadateidaten als der von Ihnen festgelegte Maximalwert für den aktiven Speicher als Standby-Daten gespeichert werden, wenn Windows den Speicher nicht für andere Zwecke verwendet, während genügend verfügbarer Speicher verfügbar bleibt. Dies ist die ideale Situation, um die Leistungseigenschaften des Systems jederzeit zu erhalten.

Programme von Drittanbietern werden von MS nicht unterstützt

Wenn Sie wie ich sind und keine Binärdatei von einem unbekannten Drittanbieter auf Ihren Produktionsservern ausführen möchten, benötigen Sie ein offizielles MS-Tool oder einen Code, den Sie überprüfen können, bevor Sie auf diesen Servern ausgeführt werden. Das DynCache-Tool für 2008 R2 ist ohne die Bezahlung eines Support-Falls praktisch nicht von M $ zu beziehen. Auf der Grundlage des Codes für 2008 scheint es für diese Aufgabe überlastet zu sein, da Windows bereits über die integrierte Logik verfügt, die für die dynamische Größe erforderlich ist der Cache - es muss nur ein angemessenes Maximum für Ihr System bekannt sein.

Lösung für alle oben genannten Probleme

Ich habe ein Powershell-Skript geschrieben, das auf 64-Bit-Computern funktioniert. Sie müssen es als Administrator mit erhöhten Rechten ausführen. Sie sollten in der Lage sein, es auf jedem x64-Windows Vista / Server 2008 bis einschließlich 10 / Server 2012 R2 mit beliebig viel RAM auszuführen. Sie müssen keine zusätzliche Software installieren und erhalten dadurch die vollständige Unterstützung Ihres Servers / Ihrer Workstation durch MS.

Sie sollten dieses Skript bei jedem Start mit erhöhten Rechten ausführen, damit die Einstellung dauerhaft ist. Windows Task Scheduler kann dies für Sie tun. Wenn sich die Windows-Installation in einer virtuellen Maschine befindet und Sie die dieser VM zugewiesene RAM-Größe ändern, sollten Sie sie auch nach der Änderung ausführen.

Sie können dieses Skript jederzeit auf einem laufenden System ausführen, auch wenn es in der Produktion verwendet wird, ohne das System neu starten oder Dienste herunterfahren zu müssen.

# 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

Oben in der Zeile steht, $MaxPercent = 12.5dass der neue maximale Arbeitsspeicher (aktiver Speicher) auf 12,5% des gesamten physischen Arbeitsspeichers festgelegt wird. Windows passt die Größe der Metadateidaten im aktiven Speicher dynamisch an die Systemanforderungen an, sodass Sie dieses Maximum nicht dynamisch anpassen müssen.

Hierdurch werden keine Probleme behoben, die auftreten, wenn der zugeordnete Dateicache zu groß wird.

Ich habe auch ein GetSystemFileCacheSizePowershell-Skript erstellt und auf StackOverflow veröffentlicht .

Bearbeiten: Ich möchte Sie auch darauf hinweisen, dass Sie keines dieser beiden Skripte mehr als einmal von derselben Powershell-Instanz ausführen sollten, da sonst die Fehlermeldung angezeigt wird, dass der Add-TypeAufruf bereits erfolgt ist.

Bearbeiten: Aktualisiertes SetSystemFileCacheSizeSkript auf Version 1.1, das einen angemessenen maximalen Cache-Wert für Sie berechnet und ein besseres Layout für die Statusausgabe aufweist.

Bearbeiten: Nachdem ich mein Windows 7-Notebook aktualisiert habe, kann ich Ihnen mitteilen, dass das Skript unter Windows 10 erfolgreich ausgeführt wird, obwohl ich nicht getestet habe, ob es noch benötigt wird. Aber mein System ist immer noch stabil, selbst wenn ich Festplattendateien von virtuellen Maschinen verschiebe.

Ich behaupte nicht, ein Experte in Bezug auf die interne Funktionsweise von Speicher oder Festplatten-Caching in einem Windows-Betriebssystem zu sein, aber ich habe zwei Beobachtungen:

1. Wenn das Betriebssystem die Daten nicht im Arbeitsspeicher zwischenspeichern würde, müsste es sie von der Festplatte lesen, die ein exponentiell langsameres Speichermedium als der Arbeitsspeicher ist, sodass das Leistungsproblem, das Sie jetzt sehen, mit ziemlicher Sicherheit schlimmer wäre.

2. Sie versuchen, das Problem zu lösen, indem Sie ein Symptom des Problems anstelle der Ursache des Problems behandeln. Die Ursache des Problems ist mit ziemlicher Sicherheit ein Mangel an ausreichend physischem RAM, und ich würde vorschlagen, dies zu beheben.

Während der Cache möglicherweise 1,5 GB RAM verwendet, würde ich mich fragen, wie viel Speicher für andere Prozesse und Dienste verwendet wird, und könnte die Lösung darin bestehen, diese Verwendung auf potenzielle Probleme zu untersuchen.

Für die Leute, die die offensichtliche, aber ineffektive Lösung angaben, einfach mehr RAM hinzuzufügen, haben Sie dieses Problem offensichtlich nicht aus erster Hand gelöst.

Wie in einem früheren Poster angegeben, spielt es keine Rolle, wie viel RAM Sie für das Problem verwenden ... es wird alles voll sein. Ich verwende ein Atlassian-Toolset auf unserem App-Server, das von 32-Bit (2003) auf 64-Bit (2008) migriert wurde. Es war sofort ersichtlich, dass es einen Leistungsverlust gab.

Beim Anzeigen des Task-Managers war fast der gesamte Speicher belegt. obwohl die Prozesse, die ausgeführt werden, dies nicht widerspiegeln. Als wir den Arbeitsspeicher von 8 GB auf 16 GB erhöhten, wurde durch das Problem auch der zusätzliche Arbeitsspeicher belegt.

Die einzige Möglichkeit, das Problem zu beheben, bestand darin, den Server neu zu starten, wodurch die Speichernutzung entsprechend den Prozessen sank (ca. 3,5 GB). Dies begann innerhalb eines Tages wieder zu klettern.

Ich wusste, dass dies ein neuer Fehler / eine neue Funktion von Microsoft ist, und war froh, diesen Artikel zu finden. Ich finde es toll, wie Microsoft dieses wichtige Detail den Benutzern überlässt, um es herauszufinden. Ich habe RamMap heruntergeladen, von dem Sie denken, dass es ein natives Dienstprogramm ist, und jetzt kann ich die Metafile-Verwendung sehen. Wir werden den Cache so einstellen, dass er alle paar Tage geleert wird, und hoffen, dass dies das Problem löst.

Es ist interessant, dass ich dieses Problem nur auf einem von mehreren unserer migrierten Server gesehen habe. Daher frage ich mich, ob die Metadatei nur von bestimmten Arten von Anwendungen gespeist wird.

Dieses Problem kann mit dem SysInternals CacheSet-Tool schnell und kostenlos behoben werden. Stellen Sie einfach das Arbeitssatzmaximum auf einen geeigneten Wert ein, der geringer ist als die Größe des System-RAM, und wenden Sie es an.

Tut mir leid, dass Sie so direkt sind, aber was ist mit dem Upgrade des Servers auf eine RAM-Größe, die etwas höher ist als die der heutigen Workstations? 16GB Memroy sind verdammt billig. Günstiger als ein halber Tag Ihrer Zeit.

Hier finden Sie einen Link zum Herunterladen des Microsoft DynCache-Tools - Sie müssen weder ein Ticket erstellen noch bezahlen. http://www.microsoft.com/en-us/download/details.aspx?displaylang=de&id=9258

(Entschuldigung - erst jetzt bemerkt, dass dies nicht für die R2-Version ist)

Das bekannte Problem für ein kontinuierliches Cache-Wachstum wird hier im Microsoft-Blog beschrieben: http://blogs.msdn.com/b/ntdebugging/archive/2007/11/27/too-much-cache.aspx

[Update] Arbeitsfix für Windows Server 2008 R2.

Ich fand Beispiel-C # -Code auf Codeplex, erstellte schnell ein Konsolen-C # -Projekt mit Visual Studio und kompilierte, arbeitete.

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

Beachten Sie, dass Sie einen Verweis auf Microsoft.AnalysisServices.AdomdClient hinzufügen müssen. Diesen finden Sie hier:

C: \ Programme (x86) \ Microsoft.NET \ ADOMD.NET

und kommentieren Sie die ClearAllCaches () -Methode mit (in meinem Fall) nicht benötigten Verweisen auf XMLaDiscover aus. Wirf dies in den TaskScheduler.

Sie können das DynCache-Tool von MS beziehen, mit dem Sie die RAM-Nutzung durch Metadateien einschränken können.

Klicken Sie hier, um das Tool von MS zu erhalten .