Uso de RAM de metarquivo do Windows Server 2008 R2

Eu tenho um servidor que executa o Windows Server 2008 R2 x64 com 4 GB de RAM que hospeda cerca de 2-3 milhões de arquivos, a maioria dos quais são arquivos de imagem.

Ao longo de uma semana, notei que os aplicativos no servidor estavam diminuindo o rastreamento devido à paginação excessiva no disco devido à falta de memória, o que tem um efeito indireto em todos os serviços atualmente em execução, causando uma grande problema de desempenho.

Após a investigação no Gerenciador de Tarefas, notei que quase todos os 4 GB estavam em uso, mas quando você olha na guia Processos, a soma de todo o uso de memória não é adicionada e, no máximo, apenas 1,5 GB deve estar em uso.

Usando o Google para encontrar uma solução, parece que a maior parte da RAM foi usada no "Metafile", que é um cache de informações NTFS para arquivos no sistema de arquivos, para que o sistema não precise consultar novamente a MFT. Esse cache nunca é limpo ou marcado como "cache" no Gerenciador de tarefas ou como "Em espera" no RamMap do Sysinternal.

Houve uma sugestão para instalar o hotfix KB979149, mas ao tentar instalá-lo, diz "Esta atualização não é aplicável ao seu computador".

As únicas correções temporárias que encontrei até agora são:

1. Use o RAMmap da Sysinternals para "Esvaziar o conjunto de trabalho do sistema" a cada 1-3 dias, que marca o cache como "em espera" e "cache" no Gerenciador de tarefas para que a RAM possa ser usada por outros aplicativos.
2. Reinicie a máquina, o que é indesejável, pois este servidor está servindo sites públicos.

No momento, estou tendo que executar a 2. correção a cada poucos dias para evitar que ela atinja níveis de gargalo.

Antes: (800 MB de RAM usada - outros aplicativos não podem usar esta RAM)

Depois: (800 MB de RAM marcado como cache - disponível para outros aplicativos)

Então, minha pergunta a todos é: Existe algum método para limitar o uso de RAM desse metarquivo?

O melhor método para lidar com este problema é usar a SetSystemFileCacheSizeAPI como MS KB976618 instrui usados para instruir .

Não limpe periodicamente o cache

Usar a SetSystemFileCacheSizefunção em vez de limpar o cache periodicamente melhora o desempenho e a estabilidade. Limpar o cache periodicamente resultará em excesso de metarquivo e outras informações sendo eliminadas da memória, e o Windows precisará reler as informações necessárias novamente na RAM do HDD. Isso cria uma queda súbita e severa no desempenho por vários segundos sempre que você limpa o cache, seguido por um bom desempenho que diminui lentamente à medida que a memória se enche de dados do metarquivo.

O uso da SetSystemFileCacheSizefunção define o mínimo e o máximo que resultarão no Windows sinalizando o excesso de dados antigos do metarquivo como memória em espera que as funções normais de cache podem usar ou descartar de acordo com as demandas atuais de recursos e as prioridades normais de cache. Isso também permite que mais dados do metarquivo do que o máximo de memória ativa que você definir, permaneçam na memória como dados em espera, se o Windows não estiver usando a memória para mais nada, mantendo bastante memória disponível. Essa é a situação ideal para manter as características de desempenho do sistema sempre boas.

Programas de terceiros não são suportados pelo MS

Se você é como eu e não deseja executar um binário de terceiros desconhecidos em seus servidores de produção, deseja uma ferramenta oficial da MS ou algum código que possa inspecionar antes de executar nesses servidores. A ferramenta DynCache para 2008 R2 é praticamente impossível obter do M $ sem pagar por um caso de suporte e, francamente, com base no código de 2008, parece inchada demais para a tarefa, pois o Windows já possui a lógica interna necessária para dimensionar dinamicamente o cache - ele só precisa saber o máximo apropriado para o seu sistema.

Solução para todos os itens acima

Eu escrevi um script do Powershell que funciona em máquinas de 64 bits. Você precisa executá-lo como administrador com privilégios elevados. Você deve poder executá-lo, como está, em qualquer Windows Vista / Server 2008 x64, inclusive 10 / Server 2012 R2, com qualquer quantidade de RAM. Você não precisa instalar nenhum software adicional e, como resultado, mantenha seu servidor / estação de trabalho totalmente suportado pela MS.

Você deve executar esse script a cada inicialização com privilégios elevados para que a configuração seja permanente. O Agendador de tarefas do Windows pode fazer isso por você. Se a instalação do Windows estiver dentro de uma máquina virtual e você alterar a quantidade de RAM alocada para essa VM, você também deve executá-la após a alteração.

Você pode executar esse script a qualquer momento em um sistema em execução, mesmo em uso de produção, sem precisar reinicializar o sistema ou desligar nenhum serviço.

# 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

Há uma linha na parte superior que diz $MaxPercent = 12.5que define o novo conjunto máximo de trabalho (memória ativa) para 12,5% da RAM física total. O Windows dimensionará dinamicamente a quantidade de dados do metarquivo na memória ativa com base nas demandas do sistema, para que você não precise ajustar dinamicamente esse máximo.

Isso não corrigirá nenhum problema que você tenha com o cache de arquivos mapeados ficando muito grande.

Também fiz um GetSystemFileCacheSizescript do Powershell e o publiquei no StackOverflow .

Editar: Devo também salientar que você não deve executar nenhum desses dois scripts da mesma instância do Powershell mais de uma vez, ou receberá o erro de que a Add-Typechamada já foi feita.

Edit: SetSystemFileCacheSizescript atualizado para a versão 1.1 que calcula um valor de cache máximo apropriado para você e possui um layout de saída de status melhor.

Edit: Agora que atualizei meu laptop com Windows 7, posso dizer que o script é executado com êxito no Windows 10, embora ainda não testei se ainda é necessário. Mas meu sistema ainda está estável, mesmo ao mover arquivos de HDD de máquinas virtuais.

Não pretendo ser um especialista em relação ao funcionamento interno da memória ou cache de disco em um sistema operacional Windows, mas tenho duas observações:

1. Se o sistema operacional não armazenasse em cache os dados na memória, ele teria que lê-los a partir do disco, que é uma mídia de armazenamento exponencialmente mais lenta que a memória, portanto o problema de desempenho que você está vendo agora seria quase certamente pior.

2. Você está tentando resolver o problema tratando um sintoma do problema em vez da causa do problema. A causa do problema é quase certamente a falta de RAM física suficiente e minha sugestão seria resolver isso.

Além disso, enquanto o cache pode estar usando 1,5 GB de RAM, eu me perguntaria qual é o uso de memória para outros processos e serviços e a solução seria investigar esse uso para possíveis problemas.

Para as pessoas que deram a solução óbvia, mas ineficaz, de apenas adicionar mais RAM, você claramente não lidou com esse problema em primeira mão.

Como afirmado em um pôster anterior, não importa quanta RAM você jogue no problema ... tudo será preenchido. Estou executando um conjunto de ferramentas Atlassian em nosso servidor de aplicativos que foi migrado de 32 bits (2003) para 64 bits (2008). Ficou imediatamente aparente que houve uma perda de desempenho.

Ao olhar para o gerenciador de tarefas, quase toda a memória foi gasta; mesmo que os processos em execução não reflitam isso. Quando aumentamos a memória de 8 GB para 16 GB, o problema também consumiu a memória adicional.

A única maneira de tratar o problema era reiniciar o servidor, reduzindo o uso de memória igual aos processos (cerca de 3,5 GB). Isso começou a subir novamente dentro de um dia ou mais.

Eu sabia que esse era um novo bug / recurso da Microsoft e fiquei feliz em encontrar este artigo. Adoro como a Microsoft deixa esses detalhes importantes para os usuários descobrirem. Eu baixei o RamMap, que você pensaria que seria um utilitário nativo, e agora posso ver o uso do Metafile. Definiremos o cache a ser limpo a cada poucos dias e, com sorte, isso resolverá o problema.

É interessante que eu só vi esse problema em um dos vários servidores migrados, por isso estou pensando se o metarquivo é alimentado apenas a partir de certos tipos de aplicativos.

Esse problema pode ser resolvido rapidamente e de graça, usando a ferramenta SysInternals CacheSet. Basta definir o conjunto de trabalho máximo para um valor adequado menor que a quantidade de RAM do sistema e aplicar.

Desculpe por ser tão direto, mas e você atualiza o servidor para uma quantidade de memória ram um pouco maior do que as estações de trabalho atualmente? Memroy de 16GB são muito baratos. Menos caro que meio dia do seu tempo.

Aqui está um link para baixar a ferramenta Microsoft DynCache - sem a necessidade de criar um ticket ou pagar. http://www.microsoft.com/en-us/download/details.aspx?displaylang=en&id=9258

(desculpas - só notando agora que isso não é para a versão R2)

O problema conhecido para o crescimento contínuo do cache está descrito aqui no blog da Microsoft: http://blogs.msdn.com/b/ntdebugging/archive/2007/11/27/too-much-cache.aspx

[atualização] correção de trabalho para o Windows Server 2008 R2.

Encontrei um exemplo de código C # no Codeplex, criei rapidamente um projeto de console C # com o Visual Studio e compilei, funcionou.

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

Observe que você precisará adicionar uma referência ao Microsoft.AnalysisServices.AdomdClient, que pode ser encontrada aqui:

C: \ Arquivos de Programas (x86) \ Microsoft.NET \ ADOMD.NET

e comente o método ClearAllCaches () com (no meu caso) referências desnecessárias ao XMLaDiscover. Jogue isso no TaskScheduler.

Você pode obter a ferramenta DynCache do MS que permitirá restringir o uso de RAM por metarquivo.

Clique aqui para obter a ferramenta da MS .