Uso de RAM de metarchivo de Windows Server 2008 R2

33

Tengo un servidor que ejecuta Windows Server 2008 R2 x64 con 4 GB de RAM que aloja alrededor de 2-3 millones de archivos, la mayoría de los cuales son archivos de imagen.

En el transcurso de una semana, me di cuenta de que las aplicaciones en el servidor se ralentizaban debido a una paginación excesiva en el disco debido a la poca memoria, lo que tiene un efecto negativo en todos los servicios que se ejecutan actualmente en él, lo que causa un importante problema de rendimiento.

Tras la investigación en el Administrador de tareas, noté que casi todos los 4 GB estaban en uso, pero cuando mira en la pestaña Procesos, la suma de todo el uso de memoria no se acumula y, como máximo, se supone que solo 1.5 GB están en uso.

Al usar Google para encontrar una solución, parece que la mayor parte de la RAM se usó en el "Metarchivo", que es un caché de información NTFS para archivos en el sistema de archivos para que el sistema no tenga que consultar la MFT para obtener información nuevamente. Este caché nunca se borra o marca como "caché" en el Administrador de tareas o como "En espera" en el RamMap de Sysinternal.

Hubo una sugerencia para instalar la revisión KB979149, pero al intentar instalarla, dice "Esta actualización no es aplicable a su computadora".

Las únicas soluciones temporales que he encontrado hasta ahora son:

  1. Use RAMmap de Sysinternals para "Vaciar el sistema de trabajo del sistema" cada 1-3 días, lo que marca el caché como "en espera" y "caché" en el Administrador de tareas para que otras aplicaciones puedan utilizar la RAM.
  2. Reinicie la máquina, lo que no es deseable ya que este servidor está sirviendo a sitios web públicos.

En este momento tengo que realizar la 2. corrección cada pocos días para evitar que alcance niveles de cuello de botella.

Antes: (800 MB de RAM utilizada; otras aplicaciones no pueden usar esta RAM)

ingrese la descripción de la imagen aquí

Después: (800 MB de RAM marcados como caché, disponible para otras aplicaciones)

Entonces mi pregunta para todos ustedes es: ¿Existe algún método para limitar el uso de RAM de este metarchivo?

al2k4
fuente
44
4 GB de RAM en un servidor que aloja 2-3 millones de archivos es absurdo. Actualice su RAM o actualice su RAM.
pauska
1
No importa, CacheSet by Sysinternals me permite configurar el tamaño del caché, actualmente ejecutar esto a intervalos y ¡hacerlo me ha resuelto el problema!
al2k4
66
Agregar RAM no resuelve el problema. El caché de metarchivos también lo llenará. Intenté hacer esto en un huésped VMware que comenzó con 4 GB y lo aumentó a 12 GB y sucede lo mismo. El problema es que esta memoria es para propósitos de caché, pero no está marcada como caché de acuerdo con Windows. Está marcado incorrectamente como memoria activa / en uso, y desafortunadamente, a medida que crece, desplaza la memoria REAL activa / en uso utilizada por programas reales y comienza a paginar en el disco. Cuando la RAM física se llena, todo se ralentiza y tienes que hacer una de las dos soluciones como se menciona en la publicación original.
@ al2k4 Si su pregunta se ha resuelto, márquela como resuelta haciendo clic en la marca de verificación junto a la respuesta correcta. ¡Bienvenido a Server Fault !
Michael Hampton

Respuestas:

16

El mejor método para tratar este problema es usar la SetSystemFileCacheSizeAPI como MS KB976618 instruye para instruir .

No borre periódicamente el caché

Usar la SetSystemFileCacheSizefunción en lugar de borrar el caché periódicamente mejora el rendimiento y la estabilidad. Borrar el caché periódicamente dará como resultado que se eliminen demasiados metarchivos y otra información de la memoria, y Windows tendrá que volver a leer la información requerida nuevamente en la RAM desde el HDD. Esto crea una caída repentina y severa en el rendimiento durante varios segundos cada vez que borra el caché, seguido de un buen rendimiento que se degrada lentamente a medida que la memoria se llena de datos de metarchivos.

El uso de la SetSystemFileCacheSizefunción establece un mínimo y un máximo que dará como resultado que Windows marque el exceso de datos de metarchivos antiguos como memoria en espera que las funciones de almacenamiento en caché normales pueden usar o descartar de acuerdo con las demandas de recursos actuales y las prioridades de caché normales. Esto también permite que más datos de metarchivos que el máximo de memoria activa que establezca estén en la memoria como datos en espera si Windows no está usando la memoria para otra cosa, mientras mantiene una gran cantidad de memoria disponible. Esta es la situación ideal para mantener las características de rendimiento del sistema en todo momento.

Los programas de terceros no son compatibles con MS

Si eres como yo y no quieres ejecutar un binario de un tercero desconocido en tus servidores de producción, quieres una herramienta oficial de MS o algún código que puedas inspeccionar antes de ejecutar en esos servidores. La herramienta DynCache para 2008 R2 es prácticamente imposible de obtener de M $ sin pagar un caso de soporte y, francamente, según el código para 2008, parece demasiado hinchada para la tarea ya que Windows ya tiene la lógica integrada necesaria para dimensionar dinámicamente el caché, solo necesita saber un máximo apropiado para su sistema.

Solución a todo lo anterior.

Escribí un script de Powershell que funciona en máquinas de 64 bits. Debe ejecutarlo como administrador con privilegios elevados. Debería poder ejecutarlo, tal cual, en cualquier x64 Windows Vista / Server 2008 hasta 10 / Server 2012 R2 incluido con cualquier cantidad de RAM. No necesita instalar ningún software adicional y, como resultado, mantener su servidor / estación de trabajo totalmente compatible con MS.

Debe ejecutar este script en cada arranque con privilegios elevados para que la configuración sea permanente. El Programador de tareas de Windows puede hacer esto por usted. Si la instalación de Windows está dentro de una máquina virtual y usted cambia la cantidad de RAM asignada a esa VM, también debe ejecutarla después del cambio.

Puede ejecutar este script en cualquier momento en un sistema en ejecución, incluso mientras está en uso de producción sin tener que reiniciar el sistema o cerrar ningún servicio.

# 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

Hay una línea cerca de la parte superior que dice $MaxPercent = 12.5que establece el nuevo conjunto de trabajo máximo (memoria activa) en 12.5% ​​de la RAM física total. Windows dimensionará dinámicamente la cantidad de datos de metarchivos en la memoria activa según las demandas del sistema, por lo que no necesita ajustar dinámicamente este máximo.

Esto no solucionará ningún problema que tenga con el caché del archivo asignado que se vuelve demasiado grande.

También hice un GetSystemFileCacheSizescript de Powershell y lo publiqué en StackOverflow .


Editar: También debo señalar que no debe ejecutar ninguno de estos 2 scripts desde la misma instancia de Powershell más de una vez, o recibirá el error de que la Add-Typellamada ya se ha realizado.

Editar: SetSystemFileCacheSizescript actualizado a la versión 1.1 que calcula un valor de caché máximo apropiado para usted y tiene un diseño de salida de estado más agradable.

Editar: ahora que actualicé mi computadora portátil con Windows 7, puedo decirle que el script se ejecuta con éxito en Windows 10, aunque no he probado si todavía es necesario. Pero mi sistema aún es estable incluso cuando muevo archivos HDD de máquinas virtuales.

BeowulfNode42
fuente
La herramienta DynCache está disponible gratuitamente para descargar desde microsoft.com/en-us/download/details.aspx?id=9258 y es compatible con 2008 R2.
Jakub Berezanski
Esto es ahora. Hubo mucho tiempo entre el lanzamiento de Windows R2 y el lanzamiento de DynCache. Ver blogs.technet.com/b/yongrhee/archive/2010/02/16/… para la actualización de la publicación del blog de ms. Todavía prefiero mi solución, ya que no requiere recursos adicionales para ejecutar otro servicio. Nuestros servidores se han vuelto muy estables con mi script, por lo que no los voy a cambiar a DynCache.
BeowulfNode42
@ BeowulfNode42 - Estamos teniendo problemas con el caché de archivos mapeados llegando a ser grande. ¿Tienes alguna sugerencia sobre cómo resolver eso? Supuse que establecer el tamaño de la caché del archivo del sistema también resolvería ese problema. ¿Tienes alguna idea de si la herramienta DynCache (hinchada) resolvería ese problema?
Lieven Keersmaekers
fwiw: acabo de probar un servidor de prueba y el archivo mapeado (rammap) pasó de 12 GB activo, 0 GB en espera a 8 GB activo, 4 GB en espera. Para todos los efectos, ¿esto parece funcionar también para los archivos mapeados?
Lieven Keersmaekers
@LievenKeersmaekers eso es raro. Quizás es algún tipo de flujo en efecto. No he encontrado una buena manera de resolver el problema de caché de archivos mapeados que se experimenta al copiar archivos de almacenamiento rápido a lento, aunque no he probado la herramienta DynCache, porque para nosotros el problema de caché de archivos mapeados es principalmente un molesto temporal disminuya la velocidad en nuestros servidores que administran nuestras copias de seguridad. Para referencia futura, ¿cuánto RAM tiene ese sistema de prueba y estaba ejecutando el script tal como se publicó con la configuración del 12.5%, y si recuerda o tiene registros de los otros tipos de tamaños de memoria?
BeowulfNode42
4

No pretendo ser un experto en el funcionamiento interno de la memoria o el almacenamiento en caché de disco en un sistema operativo Windows, pero tengo dos observaciones:

  1. Si el sistema operativo no almacena en caché los datos en la memoria, tendría que leerlos desde el disco, que es un medio de almacenamiento exponencialmente más lento que la memoria, por lo que el problema de rendimiento que está viendo ahora seguramente será peor.

  2. Está tratando de resolver el problema tratando un síntoma del problema en lugar de la causa del problema. La causa del problema es casi seguro la falta de RAM física suficiente y mi sugerencia sería abordar eso.

Además, aunque el caché puede estar usando 1.5GB de RAM, me pregunto cuál es el uso de la memoria para otros procesos y servicios, y la solución podría ser investigar ese uso en busca de posibles problemas.

joeqwerty
fuente
Exactamente. Si el OP redujo el uso de RAM del metarchivo, el sistema tendría que cargar más metadatos del disco, ya que una menor cantidad estaría en la memoria, lo que empeoraría las cosas.
David Schwartz
1
Gracias por la respuesta. Pocas cosas, el servidor es principalmente un servidor web con una base de datos MySQL y no lee archivos con mucha frecuencia, por lo que el ligero impacto de los metadatos de no estar en la caché es mínimo, el rendimiento aumenta drásticamente cuando se borra. La cantidad de archivos diferentes que lee con el tiempo es la razón por la cual el tamaño de la memoria caché aumenta. Soy consciente de que más RAM lo resolvería, pero ¿no es la idea de un "caché" que liberar memoria cuando las aplicaciones o los scripts en el servidor realmente lo necesitan para evitar la paginación? Por qué este cierto caché siempre está marcado como activo me confunde.
al2k4
Obviamente, nunca ha experimentado este problema usted mismo. Muchas personas con 32, 64 y 128 GB de RAM tienen este problema cuando los datos del metarchivo ocupan demasiada RAM y Windows no la libera, ya que está marcada como memoria activa y no en espera (también conocida como caché). El uso de la API SetSystemFileCacheSize como he descrito en mi respuesta obliga a Windows a marcar gran parte de los datos del metarchivo como memoria en espera y el sistema de gestión de caché puede priorizar qué guardar en la RAM y qué descartar.
BeowulfNode42
Troll mucho? Esta pregunta tiene más de dos años.
joeqwerty
@joeqwerty Veo nuevas publicaciones en toda la red sobre este problema todo el tiempo. Muchas de las búsquedas relacionadas llegan a esta pregunta. Como estaba actualizando mi propia respuesta y creo que su respuesta "no es útil" la marqué como tal y comenté por qué. Si eso me convierte en un troll, que así sea.
BeowulfNode42
3

Para las personas que dieron la solución obvia pero ineficaz de simplemente agregar más RAM, claramente no han abordado este problema de primera mano.

Como se indicó en un póster anterior, no importa la cantidad de RAM que arroje al problema ... todo se llenará. Estoy ejecutando un conjunto de herramientas Atlassian en nuestro servidor de aplicaciones que se migró de 32 bits (2003) a 64 bits (2008). Inmediatamente se hizo evidente que había una pérdida de rendimiento.

Al mirar el administrador de tareas, casi toda la memoria se agotó; a pesar de que los procesos que se ejecutan no reflejan esto. Cuando aumentamos la memoria de 8 GB a 16 GB, el problema también consumió la memoria adicional.

La única forma de tratar el problema era reiniciar el servidor, lo que redujo el uso de memoria igual a los procesos (aproximadamente 3,5 GB). Esto comenzó a subir nuevamente dentro de un día más o menos.

Sabía que se trataba de una nueva función / error de Microsoft y me alegró encontrar este artículo. Me encanta cómo Microsoft deja este detalle tan importante para que los usuarios lo descubran. Descargué RamMap, que pensarías que sería una utilidad nativa, y ahora puedo ver el uso del Metarchivo. Configuraremos el caché para que se borre cada pocos días y esperamos que esto resuelva el problema.

Es interesante que solo haya visto este problema en uno de varios de nuestros servidores migrados, por lo que me pregunto si el metarchivo solo se alimenta de ciertos tipos de aplicaciones.

James N.
fuente
1
En mi experiencia, el uso de la memoria de metarchivos no crecerá mucho más allá del tamaño de los metadatos del sistema de archivos (después de todo, eso es el almacenamiento en caché), por lo que actualizar la RAM para permitir que los metadatos del sistema de archivos quepan en la memoria sea una solución viable en al menos algunos casos. También he recomendado a los clientes que reduzcan el tamaño de los metadatos del sistema de archivos mediante la eliminación de datos cruzados, como millones de archivos temporales que no se han tocado en meses. Es bastante incómodo que Windows prefiera efectivamente los metadatos NTFS en la memoria sobre la memoria de la aplicación, pero buscar grupos de archivos para un archivo puede ser terriblemente lento sin la MFT en la memoria.
James L
2
Estoy de acuerdo: agregar más RAM no corrige el problema, solo consumirá más y todos los demás procesos eventualmente se detendrán. Recientemente actualicé a 24 GB, solo para que SQL ocupe 8 (bien) y tenga 12 en el metarchivo. James N: ¿qué herramienta está utilizando para borrarlo periódicamente?
sirthomas
2

Este problema se puede solucionar de forma rápida y gratuita con la herramienta SysInternals CacheSet. Simplemente establezca el máximo de conjunto de trabajo en un valor adecuado menor que la cantidad de RAM del sistema, y ​​aplique.

OneSpeed
fuente
1

Lamento ser tan directo, pero ¿qué pasa si actualiza el servidor a una cantidad de RAM que es un poco más alta que la que tienen las estaciones de trabajo en estos días? 16gb memroy son muy baratos. Menos costoso que incluso medio día de su tiempo.

TomTom
fuente
2
Eso lo resolvería para siempre, pero nuestros servidores están alojados de forma remota por un tercero. Nuestros anfitriones cobrarán una gran suma solo para aumentar la RAM mensualmente. Así que nos gustaría evitar eso si es posible.
al2k4
2
Sí. Adivina qué;) Por eso compro mi hardware. Los anfitriones están locos: puedes comprar la RAM en 3 meses. Bueno, lecciones para aprender: una configuración poco profesional vuelve para morderte.
TomTom
Todos los sistemas de Windows de 64 bits tienen una configuración de 1TB para la cantidad máxima de datos de metarchivo que se debe tener en la memoria activa (no se trata como memoria de reserva en caché lista para usarse cuando otras cosas necesitan más memoria). No sé sobre ti, pero todavía no he visto ninguna ventana de Windows con tanta memoria. No debería tener que instalar más RAM para utilizar más archivos almacenados en un HDD. Se supone que NTFS admite hasta 4,294,967,295 archivos por volumen. Una sola unidad NTFS de 4 TB debería poder soportar más de 900 millones de archivos. Intente ejecutar desfragmentación o copia de seguridad en eso y fallará o se rastreará.
BeowulfNode42
1
Sí, debería haberlo hecho si su "Servidor" tiene menos memoria RAM que una computadora portátil potente. No se trata de "ponerse ridículamente alto". Se trata de "obtener lo suficiente como para que el servidor merezca ese nombre".
TomTom
1

Aquí hay un enlace para descargar la herramienta Microsoft DynCache, sin necesidad de crear un boleto o pagar. http://www.microsoft.com/en-us/download/details.aspx?displaylang=en&id=9258

(disculpas, solo notando ahora que esto no es para la versión R2)

El problema conocido para el crecimiento continuo de la memoria caché se describe aquí en el blog de Microsoft: http://blogs.msdn.com/b/ntdebugging/archive/2007/11/27/too-much-cache.aspx

[actualización] corrección de trabajo para Windows Server 2008 R2.

Encontré código de muestra C # en Codeplex, creé rápidamente un proyecto de consola C # con Visual Studio y lo compilé, funcionó.

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

Tenga en cuenta que deberá agregar una referencia a Microsoft.AnalysisServices.AdomdClient que se puede encontrar aquí:

C: \ Archivos de programa (x86) \ Microsoft.NET \ ADOMD.NET

y comente el método ClearAllCaches () con (en mi caso) referencias innecesarias a XMLaDiscover. Lanza esto en TaskScheduler.

sirthomas
fuente
0

Puede obtener la herramienta DynCache de MS que permitirá restringir el uso de RAM por metarchivo.

Haga clic aquí para obtener la herramienta de MS .

cakiran
fuente
Ese enlace no proporciona nada para los sistemas 2008 R2. M $ todavía quiere su tarjeta de crédito para que pueda pagar para solucionar este problema conocido.
BeowulfNode42