Использование оперативной памяти метафайла в Windows Server 2008 R2

У меня есть сервер под управлением Windows Server 2008 R2 x64 с 4 ГБ ОЗУ, на котором размещено около 2-3 миллионов файлов, большинство из которых являются файлами изображений.

В течение недели я заметил, что приложения на сервере замедлялись до ползания из-за чрезмерной подкачки на диск из-за нехватки памяти, что оказывает влияние на все службы, работающие в настоящее время на нем, вызывая серьезную проблема производительности.

Проведя исследование в диспетчере задач, я заметил, что почти все 4 ГБ использовались, но когда вы смотрите на вкладке «Процессы», сумма использования всей памяти там не складывается, и предполагается, что используется максимум 1,5 ГБ.

Используя Google, чтобы найти решение, кажется, что большая часть оперативной памяти была использована в «Метафайле», который представляет собой кэш NTFS-информации для файлов в файловой системе, так что системе не нужно снова запрашивать информацию в MFT. Этот кеш никогда не очищается и не помечается как «кеш» в диспетчере задач или как «резервный» в RamSap Sysinternal.

Было предложено установить исправление KB979149, но при попытке установить его пишет «Это обновление не применимо к вашему компьютеру».

Единственные временные исправления, которые я нашел, это:

1. Используйте RAMmap из Sysinternals в «Пустой системный рабочий набор» каждые 1-3 дня, который помечает кэш как «резервный» и «кэш» в диспетчере задач, чтобы оперативная память могла использоваться другими приложениями.
2. Перезагрузите компьютер, что нежелательно, поскольку этот сервер обслуживает общедоступные веб-сайты.

В настоящее время мне приходится выполнять исправление 2. каждые несколько дней, чтобы оно не достигло уровня узкого места.

До: (используется 800 МБ ОЗУ - другие приложения не могут использовать эту ОЗУ)

После: (800 МБ ОЗУ помечено как кеш - доступно для других приложений)

Итак, мой вопрос ко всем вам: существует ли какой-либо метод для ограничения использования ОЗУ этого метафайла?

Лучший способ для решения этой проблемы заключается в использовании SetSystemFileCacheSizeAPI , как MS KB976618 инструктирует используется , чтобы инструктировать .

Не периодически очищать кеш

Использование SetSystemFileCacheSizeфункции вместо периодической очистки кэша повышает производительность и стабильность. Периодическая очистка кэша приведет к тому, что из памяти будет удалено слишком много метафайлов и другой информации, и Windows придется повторно считывать необходимую информацию обратно в ОЗУ с жесткого диска. Это приводит к внезапному и серьезному падению производительности в течение нескольких секунд при очистке кэша, после чего следует хорошая производительность, которая медленно снижается по мере заполнения памяти данными метафайла.

Используя SetSystemFileCacheSize функции устанавливает минимальное и максимальное значения, в результате чего Windows помечает избыточные старые данные метафайла как резервную память, которую обычные функции кэширования могут использовать или отбрасывать в соответствии с текущими требованиями к ресурсам и обычными приоритетами кэширования. Это также позволяет большему количеству данных метафайла, чем установленный вами максимум активной памяти, находиться в памяти в качестве резервных данных, если Windows не использует память для чего-либо другого, при этом сохраняя достаточно доступной памяти. Это идеальная ситуация, при которой постоянно сохраняются рабочие характеристики системы.

Программы сторонних производителей не поддерживаются MS

Если вы похожи на меня и не хотите запускать двоичный файл от неизвестного третьего лица на своих производственных серверах, вам нужен официальный инструмент MS или какой-то код, который вы можете проверить перед запуском на этих серверах. Инструмент DynCache для 2008 R2 практически невозможно получить от M $, не заплатив за поддержку, и, откровенно говоря, основываясь на коде 2008 года, он кажется слишком раздутым для этой задачи, поскольку Windows уже имеет встроенную логику, необходимую для динамического размера кеш - ему просто нужно знать соответствующий максимум для вашей системы.

Решение всего вышеперечисленного

Я написал скрипт Powershell, который работает на 64-битных машинах. Вы должны запустить его как администратор с повышенными привилегиями. Вы должны иметь возможность запускать его, как есть, на любой x64 Windows Vista / Server 2008 вплоть до 10 / Server 2012 R2 включительно с любым объемом оперативной памяти. Вам не нужно устанавливать дополнительное программное обеспечение, и в результате ваш сервер / рабочая станция полностью поддерживаются MS.

Этот скрипт следует запускать при каждой загрузке с повышенными привилегиями, чтобы параметр был постоянным. Windows Task Scheduler может сделать это за вас. Если установка Windows происходит внутри виртуальной машины, и вы меняете объем оперативной памяти, выделенной для этой виртуальной машины, вы также должны запустить ее после изменения.

Вы можете в любой момент запустить этот сценарий в работающей системе, даже находясь в производственном использовании, без необходимости перезагрузки системы или выключения каких-либо служб.

# 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% от общего объема физической памяти. Windows будет динамически изменять размер данных метафайла в активной памяти в зависимости от требований системы, поэтому вам не нужно динамически регулировать этот максимум.

Это не исправит проблемы, связанные с тем, что кэш отображаемых файлов становится слишком большим.

Я также сделал GetSystemFileCacheSizeскрипт Powershell и разместил его в StackOverflow .

Изменить: Я также должен отметить, что вы не должны запускать ни один из этих 2 сценариев из одного и того же экземпляра Powershell более одного раза, иначе вы получите ошибку, что Add-Typeвызов уже был сделан.

Редактировать: обновлен SetSystemFileCacheSizeскрипт до версии 1.1, который вычисляет подходящее максимальное значение кэша для вас и имеет более хороший формат вывода статуса.

Изменить: Теперь я обновил свой ноутбук с Windows 7, я могу сказать вам, что скрипт успешно работает в Windows 10, хотя я не проверял, если он все еще нужен. Но моя система остается стабильной даже при перемещении файлов с жесткого диска виртуальной машины.

Я не претендую на звание эксперта в отношении внутренней работы памяти или дискового кэширования в ОС Windows, но у меня есть два замечания:

1. Если операционная система не кэширует данные в памяти, она должна будет прочитать их с диска, который является экспоненциально более медленным носителем, чем память, поэтому проблема с производительностью, которую вы видите сейчас, почти наверняка будет хуже.

2. Вы пытаетесь решить проблему, рассматривая симптом проблемы вместо причины проблемы. Причиной проблемы почти наверняка является отсутствие достаточного физического ОЗУ, и я бы предложил решить эту проблему.

Кроме того, хотя кэш-память может использовать 1,5 ГБ ОЗУ, мне хотелось бы знать, как используется память для других процессов и служб, и может быть решение состоит в том, чтобы исследовать это использование на предмет потенциальных проблем.

Людям, которые дали очевидное, но неэффективное решение, просто добавив больше оперативной памяти, вы явно не сталкивались с этой проблемой из первых рук.

Как говорилось в предыдущем постере, не имеет значения, сколько оперативной памяти вы выбрасываете на проблему ... все будет заполнено. Я использую набор инструментов Atlassian на нашем сервере приложений, который был перенесен с 32-разрядного (2003 г.) на 64-разрядный (2008 г.). Сразу было видно, что произошла потеря производительности.

При просмотре диспетчера задач почти вся память была израсходована; даже если запущенные процессы не отражают это. Когда мы увеличили объем памяти с 8 до 16 ГБ, проблема потребляла и дополнительную память.

Единственный способ решить эту проблему - перезапустить сервер, что привело к уменьшению использования памяти, равного процессам (около 3,5 ГБ). Это начало расти снова через день или около того.

Я знал, что это была новая ошибка / особенность Microsoft, и был счастлив найти эту статью. Мне нравится, как Microsoft оставляет эту важную деталь для пользователей. Я скачал RamMap, который, как вы думаете, будет нативной утилитой, и теперь я вижу использование метафайла. Мы будем устанавливать кэш для очистки каждые несколько дней, и, надеюсь, это решит проблему.

Интересно, что я видел эту проблему только на одном из нескольких наших перенесенных серверов, поэтому мне интересно, если метафайл подается только из определенных типов приложений.

Эту проблему можно быстро и бесплатно решить с помощью инструмента SysInternals CacheSet. Просто установите максимальное значение рабочего набора на подходящее значение меньше, чем объем системной памяти, и примените.

Извините за такую ​​прямолинейность, но как насчет того, чтобы обновить сервер до уровня оперативной памяти, который немного выше, чем у тех рабочих станций, которые есть в наши дни? Память на 16 ГБ чертовски дешева. Менее дорогой, чем даже полдня вашего времени.

Вот ссылка для загрузки инструмента Microsoft DynCache - не нужно создавать билет или платить. http://www.microsoft.com/en-us/download/details.aspx?displaylang=en&id=9258

(извинения - только замечая теперь, что это не для версии R2)

Известный вопрос для дальнейшего роста кэша описано здесь , на Microsoft блоге: http://blogs.msdn.com/b/ntdebugging/archive/2007/11/27/too-much-cache.aspx

[обновление] рабочее исправление для Windows Server 2008 R2.

Я нашел пример кода C # на Codeplex, быстро создал консольный проект C # с Visual Studio и скомпилировал, работал.

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

Обратите внимание, вам нужно добавить ссылку на Microsoft.AnalysisServices.AdomdClient, которую можно найти здесь:

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

и закомментируйте метод ClearAllCaches () с помощью (в моем случае) ненужных ссылок на XMLaDiscover. Добавьте это в TaskScheduler.

Вы можете получить инструмент MS DynCache, который позволит ограничить использование оперативной памяти метафайлом.

Нажмите здесь, чтобы получить инструмент от MS .