Utilizzo della RAM del metafile di Windows Server 2008 R2


33

Ho un server che esegue Windows Server 2008 R2 x64 con 4 GB di RAM che ospita circa 2-3 milioni di file, la maggior parte dei quali sono file di immagine.

Nel corso di una settimana, ho notato che le applicazioni sul server stavano rallentando a una scansione a causa di un paging eccessivo sul disco a causa della memoria insufficiente, che ha un effetto a catena su tutti i servizi attualmente in esecuzione su di esso, causando un grave problema di prestazioni.

Dopo un'indagine in Task Manager, ho notato che quasi tutti i 4 GB erano in uso ma quando si guarda nella scheda Processi, la somma di tutto l'utilizzo della memoria non si somma e si suppone che al massimo solo 1,5 GB siano in uso.

Utilizzando Google per trovare una soluzione, sembra che la maggior parte della RAM sia stata utilizzata nel "Metafile", che è una cache di informazioni NTFS per i file sul file system in modo che il sistema non debba interrogare nuovamente la MFT per informazioni. Questa cache non viene mai cancellata o contrassegnata come "cache" in Task Manager o come "Standby" nella RamMap di Sysinternal.

C'è stato un suggerimento per installare l'aggiornamento rapido KB979149 ma quando si tenta di installarlo, si dice "Questo aggiornamento non è applicabile al computer".

Le uniche correzioni temporanee che ho trovato finora sono:

  1. Utilizzare RAMmap da Sysinternals a "Empty System Working Set" ogni 1-3 giorni che contrassegna la cache come "standby" e "cache" in Task Manager in modo che la RAM possa essere utilizzata da altre applicazioni.
  2. Riavvia il computer, il che è indesiderabile in quanto questo server serve siti Web pubblici.

Al momento devo eseguire la correzione 2. ogni pochi giorni per evitare che raggiunga i livelli di collo di bottiglia.

Prima: (800 MB di RAM utilizzati - altre applicazioni non possono utilizzare questa RAM)

inserisci qui la descrizione dell'immagine

Dopo: (800 MB di RAM contrassegnati come cache - disponibile per altre applicazioni)

Quindi la mia domanda a tutti voi è: esiste qualche metodo là fuori per limitare l'utilizzo della RAM di questo metafile?


4
4 GB di RAM su un server che ospita 2-3 milioni di file è assurdo. Aggiorna la tua RAM o aggiorna la tua RAM.
pauska,

1
Non importa, CacheSet di Sysinternals mi permette di impostare la dimensione della cache, attualmente eseguirla a intervalli e farlo ha risolto il problema per me!
al2k4,

6
L'aggiunta di RAM non risolve il problema. Anche la cache del metafile lo riempirà. Ho provato a farlo su un guest VMware che è iniziato con 4 GB e lo ha aumentato a 12 GB e succede la stessa cosa. Il problema è che questa memoria è per scopi di cache, ma non è contrassegnata come cache secondo Windows. È erroneamente contrassegnato come memoria Attivo / In uso e, sfortunatamente, man mano che cresce, elimina la memoria REAL Attivo / In uso utilizzata dai programmi reali e avvia il paging su disco. Quando la RAM fisica si riempie tutto rallenta e devi fare una delle due soluzioni come menzionato nel post originale.

@ al2k4 Se la tua domanda è stata risolta, contrassegnala come risolta facendo clic sul segno di spunta accanto alla risposta corretta. Benvenuti in Server Fault !
Michael Hampton

Risposte:


16

Il metodo migliore per affrontare questo problema è utilizzare l' SetSystemFileCacheSizeAPI come istruzioni MS KB976618 utilizzate per istruire .

Non cancellare periodicamente la cache

L'uso della SetSystemFileCacheSizefunzione anziché la cancellazione periodica della cache migliora le prestazioni e la stabilità. Svuotare periodicamente la cache comporterà l'eliminazione di troppo metafile e altre informazioni dalla memoria e Windows dovrà rileggere le informazioni richieste nella RAM dall'HDD. Ciò crea un calo improvviso e grave delle prestazioni per diversi secondi ogni volta che si svuota la cache, seguito da buone prestazioni che si deteriorano lentamente quando la memoria si riempie di dati metafile.

L'uso della SetSystemFileCacheSizefunzione imposta il minimo e il massimo che comporteranno la segnalazione di Windows dei vecchi dati metafile in eccesso come memoria di standby che le normali funzioni di memorizzazione nella cache possono utilizzare o scartare in base alle attuali esigenze di risorse e alle normali priorità della cache. Ciò consente inoltre di disporre di un maggior numero di dati metafile rispetto al massimo della memoria attiva impostato, per essere in memoria come dati di standby se Windows non utilizza la memoria per qualcos'altro, pur mantenendo molta memoria disponibile. Questa è la situazione ideale che mantiene sempre le caratteristiche prestazionali del sistema.

I programmi di terze parti non sono supportati dagli Stati membri

Se sei come me e non vuoi eseguire un binario da terze parti sconosciute sui tuoi server di produzione, vuoi uno strumento MS ufficiale o del codice che puoi controllare prima di eseguirlo su quei server. Lo strumento DynCache per 2008 R2 è praticamente impossibile da ottenere da M $ senza pagare per un caso di supporto e francamente, basato sul codice per il 2008, sembra eccessivamente gonfio per l'attività poiché Windows ha già la logica integrata necessaria per dimensionare dinamicamente la cache: deve solo conoscere il massimo appropriato per il proprio sistema.

Soluzione a tutto quanto sopra

Ho scritto uno script Powershell che funziona su macchine a 64 bit. È necessario eseguirlo come amministratore con privilegi elevati. Dovresti essere in grado di eseguirlo, così com'è, su qualsiasi Windows Vista / Server 2008 x64 fino al 10 / Server 2012 R2 incluso con qualsiasi quantità di RAM. Non è necessario installare alcun software aggiuntivo e, di conseguenza, mantenere il proprio server / workstation pienamente supportato da MS.

È necessario eseguire questo script ad ogni avvio con privilegi elevati affinché l'impostazione sia permanente. L'Utilità di pianificazione di Windows può farlo per te. Se l'installazione di Windows si trova all'interno di una macchina virtuale e si modifica la quantità di RAM allocata a quella VM, è necessario eseguirla anche dopo la modifica.

È possibile eseguire questo script in qualsiasi momento su un sistema in esecuzione anche durante l'uso in produzione senza dover riavviare il sistema o chiudere alcun servizio.

# 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

C'è una linea nella parte superiore che dice $MaxPercent = 12.5che imposta il nuovo set di lavoro massimo (memoria attiva) sul 12,5% della RAM fisica totale. Windows ridimensiona dinamicamente la quantità di dati metafile nella memoria attiva in base alle esigenze del sistema, quindi non è necessario regolare dinamicamente questo massimo.

Ciò non risolverà alcun problema con la cache dei file mappati che diventa troppo grande.

Ho anche creato uno GetSystemFileCacheSizescript Powershell e l' ho pubblicato su StackOverflow .


Modifica: dovrei anche sottolineare che non dovresti eseguire uno di questi 2 script dalla stessa istanza di Powershell più di una volta, o riceverai l'errore che la Add-Typechiamata è già stata fatta.

Modifica: SetSystemFileCacheSizescript aggiornato alla versione 1.1 che calcola un valore di cache massimo appropriato per te e ha un layout di output dello stato migliore.

Modifica: ora ho aggiornato il mio laptop Windows 7, posso dirti che lo script funziona correttamente in Windows 10, anche se non ho testato se è ancora necessario. Ma il mio sistema è ancora stabile anche quando si spostano file HDD di macchine virtuali.


Lo strumento DynCache è disponibile gratuitamente per il download da microsoft.com/en-us/download/details.aspx?id=9258 e supporta 2008 R2.
Jakub Berezanski,

È adesso. C'è stato molto tempo tra la versione di Windows R2 e la versione di DynCache. Vedi blogs.technet.com/b/yongrhee/archive/2010/02/16/… per l'aggiornamento del post sul blog ms. Preferisco ancora la mia soluzione in quanto non richiede risorse extra per eseguire ancora un altro servizio. I nostri server sono diventati molto stabili con il mio script, quindi non li sto cambiando in DynCache.
BeowulfNode42,

@ BeowulfNode42 - Stiamo riscontrando problemi con l'ottimizzazione della cache dei file mappati. Hai qualche suggerimento su come risolverlo? Supponevo che l'impostazione della dimensione della cache del file di sistema avrebbe risolto anche questo problema ?! Hai idea se lo strumento (gonfio) di DynCache risolverà quel problema?
Lieven Keersmaekers,

fwiw - Ho appena provato un server di test e il file mappato (rammap) è passato da 12 GB attivo, 0 GB in standby a 8 GB attivo, 4 GB in standby. A tutti gli effetti, questo sembra funzionare anche per i file mappati ?!
Lieven Keersmaekers,

@LievenKeersmaekers che è strano. Forse è una sorta di flusso sull'effetto. Non ho trovato un buon modo per risolvere il problema di cache di file mappato riscontrato quando si copiano file da archiviazione veloce a lenta, anche se non ho provato lo strumento DynCache, perché per noi il problema di cache di file mappato è principalmente solo un fastidioso temporaneo rallentare sui nostri server che gestiscono i nostri backup. Per riferimento futuro quanta RAM ha quel sistema di test e stavi eseguendo lo script come pubblicato con l'impostazione del 12,5% e se ricordi o hai registrato altri tipi di dimensioni della memoria?
BeowulfNode42

4

Non pretendo di essere un esperto per quanto riguarda il funzionamento interno della memoria o la memorizzazione nella cache del disco in un sistema operativo Windows, ma ho due osservazioni:

  1. Se il sistema operativo non memorizza nella cache i dati in memoria, dovrebbe leggerli dal disco, che è un supporto di archiviazione esponenzialmente più lento della memoria, quindi il problema di prestazioni che stai vedendo ora sarebbe quasi sicuramente peggiore.

  2. Stai cercando di risolvere il problema trattando un sintomo del problema anziché la causa del problema. La causa del problema è quasi sicuramente la mancanza di RAM fisica sufficiente e il mio suggerimento sarebbe di risolverlo.

Inoltre, mentre la cache utilizza 1,5 GB di RAM, mi chiedo quale sia l'utilizzo della memoria per altri processi e servizi e potrebbe essere la soluzione per indagare su tale utilizzo per potenziali problemi.


Esattamente. Se l'OP riduce l'utilizzo della RAM del metafile, il sistema dovrebbe caricare più metadati dal disco poiché meno di esso sarebbe in memoria, peggiorando le cose.
David Schwartz,

1
Grazie per il feedback. Poche cose, il server è principalmente un web server con un database MySQL e non legge i file molto spesso, quindi il leggero impatto dei metadati di non essere nella cache è minimo, le prestazioni aumentano notevolmente quando vengono cancellate. È il numero di diversi file che legge nel tempo ed è per questo che la dimensione della cache aumenta sempre più. Sono ben consapevole che più RAM lo risolverebbe, ma l'idea di una "cache" non è quella di liberare memoria quando applicazioni o script sul server ne hanno davvero bisogno per evitare il paging? Perché questa determinata cache sia sempre contrassegnata come attiva mi confonde.
al2k4,

Ovviamente non hai mai riscontrato questo problema da solo. Molte persone con 32, 64 e 128 GB di RAM hanno questo problema in cui troppa RAM viene assorbita dai dati del metafile e Windows non lo rilascia poiché è contrassegnato come memoria attiva e non di standby (ovvero cache). L'uso dell'API SetSystemFileCacheSize come ho descritto nella mia risposta obbliga Windows a contrassegnare gran parte dei dati metafile come memoria di standby e il sistema di gestione della cache è quindi in grado di stabilire le priorità su cosa conservare nella RAM e cosa scartare.
BeowulfNode42

Troll tanto? Questa domanda ha più di due anni.
joeqwerty,

@joeqwerty Vedo sempre nuovi post su Internet su questo problema. Molte delle ricerche correlate arrivano a questa domanda. Dato che stavo aggiornando la mia risposta e credo che la tua risposta non sia "utile", l'ho contrassegnata come tale e ho commentato il perché. Se questo mi rende un troll, così sia.
BeowulfNode42

3

Alle persone che hanno fornito la soluzione ovvia ma inefficace di aggiungere solo più RAM, chiaramente non hai affrontato questo problema in prima persona.

Come affermato da un precedente poster, non importa quanta RAM si lancia al problema ... si riempirà tutto. Sto eseguendo un set di strumenti Atlassian sul nostro server di app che è stato migrato da 32 bit (2003) a 64 bit (2008). È stato immediatamente evidente che si è verificata una perdita di prestazioni.

Quando si guardava il task manager, quasi tutta la memoria era esaurita; anche se i processi in esecuzione non riflettono questo. Quando abbiamo aumentato la memoria da 8 GB a 16 GB, il problema ha consumato anche la memoria aggiuntiva.

L'unico modo per trattare il problema era riavviare il server, il che riduceva l'utilizzo della memoria pari ai processi (circa 3,5 GB). Questo ha ricominciato a salire dopo circa un giorno.

Sapevo che si trattava di un nuovo bug / funzionalità di Microsoft ed ero felice di trovare questo articolo. Adoro il modo in cui Microsoft lascia questo dettaglio così importante che gli utenti possono capire. Ho scaricato RamMap, che potresti pensare fosse un'utilità nativa, e ora posso vedere l'utilizzo del Metafile. Imposteremo la cache per essere cancellata ogni pochi giorni e speriamo che questo risolva il problema.

È interessante notare che ho riscontrato questo problema solo su uno dei nostri server migrati, quindi mi chiedo se il metafile sia alimentato solo da determinati tipi di applicazioni.


1
Nella mia esperienza, l'utilizzo della memoria del metafile non crescerà molto oltre la dimensione dei metadati del filesystem (questo è ciò che sta memorizzando nella cache, dopo tutto), quindi l'aggiornamento della RAM per consentire ai metadati del filesystem di adattarsi alla memoria è una soluzione praticabile in almeno alcuni casi. Ho anche raccomandato ai clienti di ridurre le dimensioni dei metadati del filesystem rimuovendo la cruft come milioni di file temporanei che non sono stati toccati da mesi. È piuttosto imbarazzante che Windows preferisca effettivamente i metadati NTFS in memoria rispetto alla memoria dell'applicazione, ma cercare cluster per un file può essere terribilmente lento senza la MFT in memoria.
James L

2
Concordo: l'aggiunta di più RAM non risolve il problema, consumerà solo di più e tutti gli altri processi finiranno per arrestarsi. Di recente ho eseguito l'upgrade a 24 GB, solo per far sì che SQL occupasse 8 (bene) e ne avessi 12 nel metafile .. James N - quale strumento stai usando per cancellarlo periodicamente?
sirthomas,

2

Questo problema può essere risolto rapidamente e gratuitamente utilizzando lo strumento CacheSet di SysInternals. Basta impostare il set di lavoro massimo su un valore adatto inferiore alla quantità di RAM di sistema e applicare.


1

Mi dispiace essere così diretto, ma che ne dici di aggiornare il server a una quantità di RAM che è un po 'più alta di quella che hanno le workstation in questi giorni? I memroy da 16 GB sono estremamente economici. Meno costoso anche di mezza giornata del tuo tempo.


2
Ciò lo risolverebbe per sempre, ma i nostri server sono ospitati in remoto da una terza parte. I nostri host addebiteranno una grande somma solo per aumentare la RAM su base mensile. Quindi vorremmo evitarlo, se possibile.
al2k4,

2
Si. Indovina cosa;) Ecco perché compro il mio hardware. Gli host sono pazzi: puoi acquistare la RAM in 3 mesi. Bene, lezioni da imparare: una configurazione non professionale torna a morderti.
TomTom,

Tutti i sistemi Windows a 64 bit hanno un'impostazione di 1 TB per la massima quantità di dati metafile da avere nella memoria attiva (non trattati come memoria di standby memorizzata nella cache pronta per essere utilizzata quando altre cose richiedono più memoria). Non ti conosco ma non ho ancora visto nessuna finestra con così tanta memoria. Non è necessario installare più RAM per utilizzare più file memorizzati su un HDD. NTFS dovrebbe supportare fino a 4.294.967.295 file per volume. Una singola unità NTFS da 4 TB dovrebbe quindi essere in grado di supportare oltre 900 milioni di file. Prova a eseguire la deframmentazione o il backup su di esso e fallirà o eseguirà la scansione.
BeowulfNode42

1
Sì, dovresti avere se il tuo "Server" ha meno RAM di un laptop potente. Non si tratta di "diventare ridicolmente alti". Si tratta di "ottenere abbastanza che il server meriti quel nome".
TomTom,

1

Ecco un link per scaricare lo strumento Microsoft DynCache: non è necessario creare un biglietto o pagare. http://www.microsoft.com/en-us/download/details.aspx?displaylang=en&id=9258

(ci scusiamo - notando solo ora che questo non è per la versione R2)

Il problema noto per la crescita continua della cache è descritto qui sul blog di Microsoft: http://blogs.msdn.com/b/ntdebugging/archive/2007/11/27/too-much-cache.aspx

[aggiornamento] correzione funzionante per Windows Server 2008 R2.

Ho trovato un codice C # di esempio su Codeplex, ho creato rapidamente un progetto C # di console con Visual Studio e compilato, funzionava.

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

Nota, dovrai aggiungere un riferimento a Microsoft.AnalysisServices.AdomdClient che puoi trovare qui:

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

e commentare il metodo ClearAllCaches () con (nel mio caso) riferimenti non necessari a XMLaDiscover. Buttalo in TaskScheduler.


Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.