Merge pull request #443 from dsyme/fix-mem1

Add ability to downsize caches in response to a max-memory signal

Author: dsyme

RELEASE_NOTES.md

@@ -1,3 +1,8 @@
+#### 1.4.0.8 - 
+* FSharpType.Format now prettifies type variables.  If necessary, FSharpType.Prettify can also be called
+* Add maximum-memory trigger to downsize FCS caches. Defaults to 1.7GB of allocaed memory in the system 
+  process for a 32-bit process, and 2x this for a 64-bit process
+
 #### 1.4.0.7 - 
 * fix 427 - Make event information available for properties which represent first-class uses of F#-declared events
 * fix 410 - Symbols for C# fields (and especially enum fields)

docs/content/caches.fsx

@@ -6,7 +6,7 @@ Compiler Services: Notes on the FSharpChecker caches
 
 This is a design note on the FSharpChecker component and its caches.  See also the notes on the [FSharpChecker operations queue](queue.html)
 
-FSharpChecker maintains a set of caches. These are
+Each FSharpChecker object maintains a set of caches.  These are
 
 * ``scriptClosureCache`` - an MRU cache of default size ``projectCacheSize`` that caches the 
   computation of GetProjectOptionsFromScript. This computation can be lengthy as it can involve processing the transative closure
@@ -55,6 +55,25 @@ The sizes of some of these caches can be adjusted by giving parameters to FSharp
 the cache sizes above indicate the "strong" size of the cache, where memory is held regardless of the memory 
 pressure on the system. Some of the caches can also hold "weak" references which can be collected at will by the GC.
 
+> Note: Because of these caches, uou should generally use one global, shared FSharpChecker for everything in an IDE application.
+
+
+Low-Memory Condition
+-------
+
+Version 1.4.0.8 added a "maximum memory" limit specified by the `MaxMemory` property on FSharpChecker (in MB). If an FCS project operation
+is performed (see `CheckMaxMemoryReached` in `service.fs`) and `System.GC.GetTotalMemory(false)` reports a figure greater than this, then
+the strong sizes of all FCS caches are reduced to either 0 or 1.  This happens for the remainder of the lifetime of the FSharpChecker object. 
+In practice this will still make tools like the Visual Studio F# Power Tools usable, but some operations like renaming across multiple 
+projects may take substantially longer.
+
+For a 32-bit process the default threshold is 1.7GB of allocated managed memory in a process, see `maxMBDefault` in `service.fs`. For a 64-bit process 
+it is twice this.
+
+Reducing the FCS strong cache sizes does not guarantee there will be enough memory to continue operations - even holding one project 
+strongly may exceed a process memory budget. It just means FCS may hold less memory strongly.
+
+If you do not want the maximum memory limit to apply then set MaxMemory to System.Int32.MaxValue.
 
 Summary
 -------

src/fsharp/InternalCollections.fs

@@ -20,6 +20,7 @@ type internal AgedLookup<'TKey,'TValue when 'TValue : not struct>(keepStrongly:i
     /// The choice of order is somewhat arbitrary. If the other way then adding
     /// items would be O(1) and removing O(N).
     let mutable refs:('TKey*ValueStrength<'TValue>) list = [] 
+    let mutable keepStrongly = keepStrongly
 
     // Only set a strong discard function if keepMax is explicitly set to keepStrongly, i.e. there are no weak entries in this lookup.
     do assert (onStrongDiscard.IsNone || Some keepStrongly = keepMax)
@@ -30,7 +31,7 @@ type internal AgedLookup<'TKey,'TValue when 'TValue : not struct>(keepStrongly:i
     // references. Some operations are O(N) and we don't want to let things get out of
     // hand.
     let keepMax = defaultArg keepMax 75 
-    let keepMax = max keepStrongly keepMax 
+    let mutable keepMax = max keepStrongly keepMax 
 
     /// Look up a the given key, return None if not found.
     let TryPeekKeyValueImpl(data,key) = 
@@ -140,6 +141,14 @@ type internal AgedLookup<'TKey,'TValue when 'TValue : not struct>(keepStrongly:i
        let discards = FilterAndHold()
        AssignWithStrength([], discards)
 
+    member al.Resize(newKeepStrongly, ?newKeepMax) =
+       let newKeepMax = defaultArg newKeepMax 75 
+       keepStrongly <- newKeepStrongly
+       keepMax <- max newKeepStrongly newKeepMax
+       do assert (onStrongDiscard.IsNone || keepStrongly = keepMax)
+       let keep = FilterAndHold()
+       AssignWithStrength(keep, [])
+
 
 
 type internal MruCache<'TKey,'TValue when 'TValue : not struct>(keepStrongly, areSame, ?isStillValid : 'TKey*'TValue->bool, ?areSameForSubsumption, ?onStrongDiscard, ?keepMax) =
@@ -178,6 +187,9 @@ type internal MruCache<'TKey,'TValue when 'TValue : not struct>(keepStrongly, ar
     member bc.Clear() =
         cache.Clear()
 
+    member bc.Resize(newKeepStrongly, ?newKeepMax) =
+        cache.Resize(newKeepStrongly, ?newKeepMax=newKeepMax)
+        
 /// List helpers
 [<Sealed>]
 type internal List = 

src/fsharp/InternalCollections.fsi

@@ -27,6 +27,8 @@ namespace Internal.Utilities.Collections
     member Remove : key:'TKey -> unit
     /// Remove all elements.
     member Clear : unit -> unit
+    /// Resize
+    member Resize : keepStrongly: int * ?keepMax : int -> unit
     
   /// Simple priority caching for a small number of key\value associations.
   /// This cache may age-out results that have been Set by the caller.
@@ -50,6 +52,8 @@ namespace Internal.Utilities.Collections
     member Remove : key:'TKey -> unit
     /// Set the given key. 
     member Set : key:'TKey * value:'TValue -> unit
+    /// Resize
+    member Resize : keepStrongly: int * ?keepMax : int -> unit
 
   [<Sealed>]
   type internal List = 

src/fsharp/fsi/fsi.fs

@@ -2362,10 +2362,14 @@ type FsiEvaluationSession (fsi: FsiEvaluationSessionHostConfig, argv:string[], i
 
     let fsiConsoleInput = FsiConsoleInput(fsi, fsiOptions, inReader, outWriter)
 
+    /// The single, global interactive checker that can be safely used in conjunction with other operations
+    /// on the FsiEvaluationSession.  
+    let checker = FSharpChecker.Create()
+
     let (tcGlobals,frameworkTcImports,nonFrameworkResolutions,unresolvedReferences) = 
         try 
             let tcConfig = tcConfigP.Get()
-            IncrementalFSharpBuild.GetFrameworkTcImports tcConfig
+            checker.FrameworkImportsCache.Get tcConfig
         with e -> 
             stopProcessingRecovery e range0; failwithf "Error creating evaluation session: %A" e
 
@@ -2409,9 +2413,6 @@ type FsiEvaluationSession (fsi: FsiEvaluationSessionHostConfig, argv:string[], i
 
     let fsiInteractionProcessor = FsiInteractionProcessor(fsi, tcConfigB, errorLogger, fsiOptions, fsiDynamicCompiler, fsiConsolePrompt, fsiConsoleOutput, fsiInterruptController, fsiStdinLexerProvider, lexResourceManager, initialInteractiveState) 
 
-    /// The single, global interactive checker that can be safely used in conjunction with other operations
-    /// on the FsiEvaluationSession.  
-    let checker = InteractiveChecker.Create()
 
     interface IDisposable with 
         member x.Dispose() = 

src/fsharp/vs/IncrementalBuild.fs

@@ -1087,10 +1087,14 @@ module internal IncrementalFSharpBuild =
 
     /// Global service state
     type FrameworkImportsCacheKey = (*resolvedpath*)string list * string * (*ClrRoot*)string list* (*fsharpBinaries*)string
-    let private frameworkTcImportsCache = AgedLookup<FrameworkImportsCacheKey,(TcGlobals * TcImports)>(8, areSame=(fun (x,y) -> x = y)) 
-    let ClearFrameworkTcImportsCache() = frameworkTcImportsCache.Clear()
-    /// This function strips the "System" assemblies from the tcConfig and returns a age-cached TcImports for them.
-    let GetFrameworkTcImports(tcConfig:TcConfig) =
+
+    type FrameworkImportsCache(keepStrongly) = 
+      let frameworkTcImportsCache = AgedLookup<FrameworkImportsCacheKey,(TcGlobals * TcImports)>(keepStrongly, areSame=(fun (x,y) -> x = y)) 
+      member __.Downsize() = frameworkTcImportsCache.Resize(keepStrongly=0)
+      member __.Clear() = frameworkTcImportsCache.Clear()
+
+      /// This function strips the "System" assemblies from the tcConfig and returns a age-cached TcImports for them.
+      member __.Get(tcConfig:TcConfig) =
         // Split into installed and not installed.
         let frameworkDLLs,nonFrameworkResolutions,unresolved = TcAssemblyResolutions.SplitNonFoundationalResolutions(tcConfig)
         let frameworkDLLsKey = 
@@ -1188,7 +1192,7 @@ module internal IncrementalFSharpBuild =
         TimeStamp = timestamp }
 
 
-    type IncrementalBuilder(tcConfig : TcConfig, projectDirectory, outfile, assemblyName, niceNameGen : Ast.NiceNameGenerator, lexResourceManager,
+    type IncrementalBuilder(frameworkTcImportsCache: FrameworkImportsCache, tcConfig : TcConfig, projectDirectory, outfile, assemblyName, niceNameGen : Ast.NiceNameGenerator, lexResourceManager,
                             sourceFiles, projectReferences: IProjectReference list, ensureReactive, 
                             keepAssemblyContents, keepAllBackgroundResolutions) =
 
@@ -1202,7 +1206,7 @@ module internal IncrementalFSharpBuild =
         // Resolve assemblies and create the framework TcImports. This is done when constructing the
         // builder itself, rather than as an incremental task. This caches a level of "system" references. No type providers are 
         // included in these references. 
-        let (tcGlobals,frameworkTcImports,nonFrameworkResolutions,unresolvedReferences) = GetFrameworkTcImports tcConfig
+        let (tcGlobals,frameworkTcImports,nonFrameworkResolutions,unresolvedReferences) = frameworkTcImportsCache.Get tcConfig
 
         // Check for the existence of loaded sources and prepend them to the sources list if present.
         let sourceFiles = tcConfig.GetAvailableLoadedSources() @ (sourceFiles |>List.map(fun s -> rangeStartup,s))
@@ -1723,7 +1727,7 @@ module internal IncrementalFSharpBuild =
 
         /// CreateIncrementalBuilder (for background type checking). Note that fsc.fs also
         /// creates an incremental builder used by the command line compiler.
-        static member TryCreateBackgroundBuilderForProjectOptions (scriptClosureOptions:LoadClosure option, sourceFiles:string list, commandLineArgs:string list, projectReferences, projectDirectory, useScriptResolutionRules, isIncompleteTypeCheckEnvironment, keepAssemblyContents, keepAllBackgroundResolutions) =
+        static member TryCreateBackgroundBuilderForProjectOptions (frameworkTcImportsCache, scriptClosureOptions:LoadClosure option, sourceFiles:string list, commandLineArgs:string list, projectReferences, projectDirectory, useScriptResolutionRules, isIncompleteTypeCheckEnvironment, keepAssemblyContents, keepAllBackgroundResolutions) =
 
           // Trap and report warnings and errors from creation.
           use errorScope = new ErrorScope()
@@ -1800,7 +1804,8 @@ module internal IncrementalFSharpBuild =
                 let outfile, _, assemblyName = tcConfigB.DecideNames sourceFilesNew
 
                 let builder = 
-                    new IncrementalBuilder(tcConfig, projectDirectory, outfile, assemblyName, niceNameGen,
+                    new IncrementalBuilder(frameworkTcImportsCache,
+                                           tcConfig, projectDirectory, outfile, assemblyName, niceNameGen,
                                            resourceManager, sourceFilesNew, projectReferences, ensureReactive=true, 
                                            keepAssemblyContents=keepAssemblyContents, 
                                            keepAllBackgroundResolutions=keepAllBackgroundResolutions)

src/fsharp/vs/IncrementalBuild.fsi

@@ -49,8 +49,11 @@ type internal ErrorScope =
 module internal IncrementalFSharpBuild =
 
   /// Lookup the global static cache for building the FrameworkTcImports
-  val GetFrameworkTcImports : TcConfig -> TcGlobals * TcImports * AssemblyResolution list * UnresolvedAssemblyReference list
-  val ClearFrameworkTcImportsCache: unit -> unit
+  type FrameworkImportsCache = 
+      new : size: int -> FrameworkImportsCache
+      member Get : TcConfig -> TcGlobals * TcImports * AssemblyResolution list * UnresolvedAssemblyReference list
+      member Clear: unit -> unit
+      member Downsize: unit -> unit
   
   type PartialCheckResults = 
       { TcState : TcState 
@@ -149,7 +152,7 @@ module internal IncrementalFSharpBuild =
       /// This may be a marginally long-running operation (parses are relatively quick, only one file needs to be parsed)
       member GetParseResultsForFile : filename:string -> Ast.ParsedInput option * Range.range * string * (PhasedError * FSharpErrorSeverity) list
 
-      static member TryCreateBackgroundBuilderForProjectOptions : scriptClosureOptions:LoadClosure option * sourceFiles:string list * commandLineArgs:string list * projectReferences: IProjectReference list * projectDirectory:string * useScriptResolutionRules:bool * isIncompleteTypeCheckEnvironment : bool * keepAssemblyContents: bool * keepAllBackgroundResolutions: bool -> IncrementalBuilder option * FSharpErrorInfo list 
+      static member TryCreateBackgroundBuilderForProjectOptions : FrameworkImportsCache * scriptClosureOptions:LoadClosure option * sourceFiles:string list * commandLineArgs:string list * projectReferences: IProjectReference list * projectDirectory:string * useScriptResolutionRules:bool * isIncompleteTypeCheckEnvironment : bool * keepAssemblyContents: bool * keepAllBackgroundResolutions: bool -> IncrementalBuilder option * FSharpErrorInfo list 
 
 [<Obsolete("This type has been renamed to FSharpErrorInfo")>]
 /// Renamed to FSharpErrorInfo