Utilisation de la RAM de métafichier Windows Server 2008 R2

J'ai un serveur qui exécute Windows Server 2008 R2 x64 avec 4 Go de RAM qui héberge environ 2 à 3 millions de fichiers, dont la majorité sont des fichiers images.

Au cours d’une semaine, j’ai remarqué que le ralentissement excessif des applications sur le serveur était dû à une pagination excessive sur le disque en raison de la mémoire insuffisante, ce qui avait des répercussions sur tous les services en cours d’exécution, ce qui entraînait un problème majeur. problème de performance.

Lors de l’examen dans le Gestionnaire des tâches, j’ai constaté que la quasi-totalité des 4 Go était utilisée, mais lorsque vous consultez l’onglet Processus, la somme de l’utilisation de la mémoire n’ajoute rien et au plus 1,5 Go est supposé être utilisé.

En utilisant Google pour trouver une solution, il semble que la majeure partie de la RAM ait été utilisée dans le "métafichier", qui est un cache d'informations NTFS pour les fichiers du système de fichiers, de sorte que le système n'a pas à interroger à nouveau la MFT pour obtenir des informations. Ce cache n'est jamais effacé ni marqué comme "cache" dans le Gestionnaire des tâches ou en tant que "Veille" dans le RamMap de Sysinternal.

Il a été suggéré d'installer le correctif KB979149, mais après avoir essayé de l'installer, il indique "Cette mise à jour ne s'applique pas à votre ordinateur".

Les seuls correctifs temporaires que j'ai trouvés jusqu'à présent sont les suivants:

1. Utilisez RAMmap de Sysinternals pour "vider le système de travail du système" tous les 1 à 3 jours, ce qui marque le cache comme "veille" et "cache" dans le Gestionnaire des tâches afin que la RAM puisse être utilisée par d'autres applications.
2. Redémarrez l'ordinateur, ce qui n'est pas souhaitable car ce serveur dessert des sites Web publics.

Pour le moment, je dois effectuer la correction 2. tous les quelques jours afin d'éviter qu'elle n'atteigne un niveau de goulot d'étranglement.

Avant: (800 Mo de RAM utilisés - les autres applications ne peuvent pas utiliser cette RAM)

Après: (800 Mo de RAM marqué comme cache - disponible pour d'autres applications)

Ma question est donc la suivante: existe-t-il une méthode permettant de limiter l’utilisation de la RAM dans ce métafichier?

La meilleure méthode pour traiter ce problème consiste à utiliser l' SetSystemFileCacheSizeAPI en suivant les instructions de MS KB976618 utilisées .

Ne pas vider le cache périodiquement

L'utilisation de la SetSystemFileCacheSizefonction plutôt que la suppression du cache améliore périodiquement les performances et la stabilité. Si vous effacez le cache périodiquement, trop de métafichiers et d’autres informations seront purgés de la mémoire. Windows devra alors relire les informations requises dans la RAM du disque dur. Cela entraîne une baisse soudaine et sévère des performances pendant plusieurs secondes chaque fois que vous effacez le cache, suivie d'une performance satisfaisante qui se dégrade lentement à mesure que la mémoire se remplit de données de métafichier.

L'utilisation des SetSystemFileCacheSizefonctions définit les valeurs minimale et maximale qui permettront à Windows de marquer les anciennes données de métafichier en excès comme mémoire de secours que les fonctions de mise en cache normales peuvent utiliser ou rejeter en fonction des demandes de ressources actuelles et des priorités de mémoire cache normales. Cela permet également à plus de métafichiers que le maximum de mémoire active défini de rester en mémoire en tant que données en attente si Windows n'utilise pas la mémoire pour autre chose, tout en conservant une grande quantité de mémoire disponible. Il s’agit de la situation idéale pour maintenir les performances du système en permanence.

Les programmes tiers ne sont pas pris en charge par MS

Si vous êtes comme moi et que vous ne souhaitez pas exécuter un fichier binaire provenant d'un tiers inconnu sur vos serveurs de production, vous souhaitez un outil MS officiel ou un code que vous pouvez inspecter avant de l'exécuter sur ces serveurs. L'outil DynCache pour 2008 R2 est pratiquement impossible à obtenir auprès de M $ sans avoir à payer pour une demande d'assistance et, très franchement, basé sur le code de 2008, il semble excessivement lourd pour la tâche, car Windows dispose déjà de la logique intégrée nécessaire pour dimensionner de manière dynamique. le cache - il suffit de connaître un maximum approprié pour votre système.

Solution à tout ce qui précède

J'ai écrit un script Powershell qui fonctionne sur des machines 64 bits. Vous devez l'exécuter en tant qu'administrateur avec des privilèges élevés. Vous devriez pouvoir l'exécuter, tel quel, sur tout ordinateur Windows Vista / Server 2008 x64 jusqu'à 10 / Server 2012 R2 inclus, avec n'importe quelle quantité de RAM. Vous n'avez pas besoin d'installer de logiciel supplémentaire. Par conséquent, maintenez votre serveur / poste de travail entièrement pris en charge par MS.

Vous devez exécuter ce script à chaque démarrage avec des privilèges élevés pour que le paramètre soit permanent. Le Planificateur de tâches Windows peut le faire pour vous. Si l'installation Windows se trouve sur une machine virtuelle et que vous modifiez la quantité de RAM allouée à cette machine virtuelle, vous devez également l'exécuter après la modification.

Vous pouvez exécuter ce script à tout moment sur un système en fonctionnement, même en cours de production, sans avoir à redémarrer le système ou à arrêter tous les services.

# 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

Une ligne vers le haut indique $MaxPercent = 12.5que le nouvel ensemble de travail maximal (mémoire active) est défini sur 12,5% de la RAM physique totale. Windows dimensionnera dynamiquement la quantité de métafichiers dans la mémoire active en fonction des exigences du système. Vous n'avez donc pas besoin d'ajuster dynamiquement ce maximum.

Cela ne résoudra pas les problèmes que vous avez avec le cache de fichiers mappé qui devient trop gros.

J'ai également créé un GetSystemFileCacheSizescript Powershell et l' ai posté sur StackOverflow .

Edit: Je dois également signaler que vous ne devez exécuter aucun de ces 2 scripts à partir de la même instance Powershell plusieurs fois, sinon vous recevrez le Add-Typemessage d' erreur indiquant que l' appel a déjà été passé.

Edit: SetSystemFileCacheSizescript mis à jour vers la version 1.1 qui calcule une valeur de cache maximale appropriée pour vous et présente une présentation de sortie de statut plus agréable.

Edit: Maintenant que j'ai mis à niveau mon ordinateur portable Windows 7, je peux vous dire que le script s'exécute correctement dans Windows 10, bien que je n'ai pas encore vérifié s'il était toujours nécessaire. Mais mon système reste stable même lorsque je déplace des fichiers HDD de machines virtuelles.

Je ne prétends pas être un expert en ce qui concerne le fonctionnement interne de la mémoire ou de la mise en cache de disque dans un système d'exploitation Windows, mais j'ai deux observations:

1. Si le système d'exploitation ne cache pas les données en mémoire, il devra les lire à partir du disque, qui est un support de stockage beaucoup plus lent que la mémoire, de sorte que le problème de performance que vous constatez maintenant serait certainement pire.

2. Vous essayez de résoudre le problème en traitant un symptôme du problème au lieu de la cause du problème. La cause du problème est presque certainement un manque de RAM physique et ma suggestion serait de remédier à cela.

En outre, bien que le cache utilise peut-être 1,5 Go de RAM, je me demande quelle est l'utilisation de la mémoire pour d'autres processus et services et la solution pourrait consister à rechercher les problèmes potentiels dans cette utilisation.

Pour les personnes qui ont donné la solution évidente mais inefficace d'ajouter simplement plus de RAM, vous n'avez clairement pas traité cette question de première main.

Comme indiqué par une précédente affiche, peu importe la quantité de mémoire RAM que vous utilisez pour régler le problème ... tout se remplira. J'utilise un ensemble d'outils Atlassian sur notre serveur d'applications, qui est passé de 32 bits (2003) à 64 bits (2008). Il était immédiatement évident qu'il y avait une perte de performance.

En regardant le gestionnaire de tâches, presque toute la mémoire était épuisée; bien que les processus en cours ne reflètent pas cela. Lorsque nous avons augmenté la mémoire de 8 Go à 16 Go, le problème a également consommé de la mémoire supplémentaire.

Le seul moyen de traiter le problème consistait à redémarrer le serveur, ce qui rendait l'utilisation de la mémoire égale à celle des processus (environ 3,5 Go). Cela a recommencé à grimper en un jour ou deux.

Je savais que c'était un nouveau bug / fonctionnalité de Microsoft et j'étais heureux de trouver cet article. J'adore la façon dont Microsoft laisse ce détail essentiel aux utilisateurs. J'ai téléchargé RamMap, qui, selon vous, constituerait un utilitaire natif, et je peux maintenant voir l'utilisation de Metafile. Nous allons régler le cache pour qu'il soit vidé tous les deux ou trois jours et j'espère que cela résoudra le problème.

Il est intéressant de noter que je n'ai vu ce problème que sur l'un des serveurs migrés sur plusieurs. Je me demande donc si le métafichier est uniquement alimenté par certains types d'applications.

Ce problème peut être résolu rapidement et gratuitement à l'aide de l'outil SysInternals CacheSet. Définissez simplement le maximum de jeu de travail sur une valeur appropriée inférieure à la quantité de RAM système et appliquez-le.

Désolé d’être aussi direct, mais qu’en est-il de la mise à niveau du serveur avec une quantité de mémoire RAM légèrement supérieure à celle des postes de travail actuels? 16gb memroy sont terriblement bon marché. Moins cher que même une demi-journée de votre temps.

Voici un lien pour télécharger l'outil Microsoft DynCache - inutile de créer un ticket ou de payer. http://www.microsoft.com/en-us/download/details.aspx?displaylang=fr&id=9258

(excuses - remarquant seulement que ce n'est pas pour la version R2)

Le problème connu de la croissance continue du cache est décrit ici sur le blog Microsoft: http://blogs.msdn.com/b/ntdebugging/archive/2007/11/27/too-much-cache.aspx

[mise à jour] correctif de travail pour Windows Server 2008 R2.

J'ai trouvé un exemple de code C # sur Codeplex, rapidement créé un projet de console C # avec Visual Studio et compilé, travaillé.

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

Notez que vous devrez ajouter une référence à Microsoft.AnalysisServices.AdomdClient qui peut être trouvée ici:

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

et commentez la méthode ClearAllCaches () avec (dans mon cas) des références inutiles à XMLaDiscover. Jetez ceci dans TaskScheduler.

Vous pouvez obtenir l’outil DynCache auprès de MS qui permettra de limiter l’utilisation de la RAM par métafichier.

Cliquez ici pour obtenir l'outil de MS .