Performance Fixes

src/Microsoft.DotNet.Cli.Utils/Tracing/PerfTraceOutput.cs

@@ -50,7 +50,8 @@ private static void FormatEventTimeStat(StringBuilder builder, PerfTraceEvent e,
  AppendTime(builder, e.Duration.TotalSeconds / root.Duration.TotalSeconds, 0.2);
  }
  AppendTime(builder, e.Duration.TotalSeconds / parent?.Duration.TotalSeconds, 0.5);
- builder.Append($"{e.Duration.ToString("ss\\.fff\\s").Blue()}]");
+ builder.Append($"{(int)e.Duration.TotalSeconds}.{e.Duration.Milliseconds:000}s".Blue());
+ builder.Append("]");
  }
 
  private static void AppendTime(StringBuilder builder, double? percent, double treshold)

src/Microsoft.DotNet.ProjectModel/Compilation/LibraryExporter.cs

@@ -25,6 +25,8 @@ public class LibraryExporter
  private readonly string _buildBasePath;
  private readonly string _solutionRootPath;
 
+ private List<LibraryExport> _cachedExports;
+
  public LibraryExporter(ProjectDescription rootProject,
  LibraryManager manager,
  string configuration,
@@ -84,62 +86,112 @@ public IEnumerable<LibraryExport> GetDependencies(LibraryType type)
  /// </summary>
  private IEnumerable<LibraryExport> ExportLibraries(Func<LibraryDescription, bool> condition)
  {
- var seenMetadataReferences = new HashSet<string>();
+ // Project Exports cannot be cached because the binding redirect file
+ // for desktop apps is not added to runtimeassets of the project
+ // until after the project is built.
+ var cache = GetCacheWithRefreshedProjectExports();
 
- // Iterate over libraries in the library manager
- foreach (var library in LibraryManager.GetLibraries())
+ foreach (var export in cache)
  {
- if (!condition(library))
+ if (!condition(export.Library))
  {
  continue;
  }
+ yield return export;
+ }
+ }
 
- var compilationAssemblies = new List<LibraryAsset>();
- var sourceReferences = new List<LibraryAsset>();
- var analyzerReferences = new List<AnalyzerReference>();
- var libraryExport = GetExport(library);
+ private IEnumerable<LibraryExport> GetCacheWithRefreshedProjectExports()
+ {
+ if (_cachedExports == null)
+ {
+ _cachedExports = CalculateAllExports().ToList();
+ }
+
+ var seenMetadataReferences = new HashSet<string>();
+ var refreshedCache = new LibraryExport[_cachedExports.Count()];
 
- // We need to filter out source references from non-root libraries,
- // so we rebuild the library export
- foreach (var reference in libraryExport.CompilationAssemblies)
+ int index = 0;
+ foreach (var export in _cachedExports)
+ {
+ if (Equals(export.Library.Identity.Type, LibraryType.Project))
  {
- if (seenMetadataReferences.Add(reference.Name))
- {
- compilationAssemblies.Add(reference);
- }
+ refreshedCache[index++] = GenerateExportFromLibrary(seenMetadataReferences, export.Library);
  }
-
- // Source and analyzer references are not transitive
- if (library.Parents.Contains(_rootProject))
+ else
  {
- sourceReferences.AddRange(libraryExport.SourceReferences);
- analyzerReferences.AddRange(libraryExport.AnalyzerReferences);
+ refreshedCache[index++] = export;
  }
 
- var builder = LibraryExportBuilder.Create(library);
- if (_runtime != null && _runtimeFallbacks != null)
+ foreach (var reference in export.CompilationAssemblies)
  {
- // For portable apps that are built with runtime trimming we replace RuntimeAssemblyGroups and NativeLibraryGroups
- // with single default group that contains asset specific to runtime we are trimming for
- // based on runtime fallback list
- builder.WithRuntimeAssemblyGroups(TrimAssetGroups(libraryExport.RuntimeAssemblyGroups, _runtimeFallbacks));
- builder.WithNativeLibraryGroups(TrimAssetGroups(libraryExport.NativeLibraryGroups, _runtimeFallbacks));
+ seenMetadataReferences.Add(reference.Name);
  }
- else
+ }
+
+ return refreshedCache;
+ }
+
+ private IEnumerable<LibraryExport> CalculateAllExports()
+ {
+ var seenMetadataReferences = new HashSet<string>();
+
+ // Iterate over libraries in the library manager
+ foreach (var library in LibraryManager.GetLibraries())
+ {
+ yield return GenerateExportFromLibrary(seenMetadataReferences, library);
+ }
+ }
+
+ private LibraryExport GenerateExportFromLibrary(
+ HashSet<string> seenMetadataReferences, 
+ LibraryDescription library)
+ {
+ var compilationAssemblies = new List<LibraryAsset>();
+ var sourceReferences = new List<LibraryAsset>();
+ var analyzerReferences = new List<AnalyzerReference>();
+ var libraryExport = GetExport(library);
+
+ // We need to filter out source references from non-root libraries,
+ // so we rebuild the library export
+ foreach (var reference in libraryExport.CompilationAssemblies)
+ {
+ if (seenMetadataReferences.Add(reference.Name))
  {
- builder.WithRuntimeAssemblyGroups(libraryExport.RuntimeAssemblyGroups);
- builder.WithNativeLibraryGroups(libraryExport.NativeLibraryGroups);
+ compilationAssemblies.Add(reference);
  }
+ }
 
- yield return builder
- .WithCompilationAssemblies(compilationAssemblies)
- .WithSourceReferences(sourceReferences)
- .WithRuntimeAssets(libraryExport.RuntimeAssets)
- .WithEmbedddedResources(libraryExport.EmbeddedResources)
- .WithAnalyzerReference(analyzerReferences)
- .WithResourceAssemblies(libraryExport.ResourceAssemblies)
- .Build();
+ // Source and analyzer references are not transitive
+ if (library.Parents.Contains(_rootProject))
+ {
+ sourceReferences.AddRange(libraryExport.SourceReferences);
+ analyzerReferences.AddRange(libraryExport.AnalyzerReferences);
+ }
+
+ var builder = LibraryExportBuilder.Create(library);
+ if (_runtime != null && _runtimeFallbacks != null)
+ {
+ // For portable apps that are built with runtime trimming we replace RuntimeAssemblyGroups and NativeLibraryGroups
+ // with single default group that contains asset specific to runtime we are trimming for
+ // based on runtime fallback list
+ builder.WithRuntimeAssemblyGroups(TrimAssetGroups(libraryExport.RuntimeAssemblyGroups, _runtimeFallbacks));
+ builder.WithNativeLibraryGroups(TrimAssetGroups(libraryExport.NativeLibraryGroups, _runtimeFallbacks));
  }
+ else
+ {
+ builder.WithRuntimeAssemblyGroups(libraryExport.RuntimeAssemblyGroups);
+ builder.WithNativeLibraryGroups(libraryExport.NativeLibraryGroups);
+ }
+
+ return builder
+ .WithCompilationAssemblies(compilationAssemblies)
+ .WithSourceReferences(sourceReferences)
+ .WithRuntimeAssets(libraryExport.RuntimeAssets)
+ .WithEmbedddedResources(libraryExport.EmbeddedResources)
+ .WithAnalyzerReference(analyzerReferences)
+ .WithResourceAssemblies(libraryExport.ResourceAssemblies)
+ .Build();
  }
 
  private IEnumerable<LibraryAssetGroup> TrimAssetGroups(IEnumerable<LibraryAssetGroup> runtimeAssemblyGroups,

src/Microsoft.DotNet.ProjectModel/Files/PatternGroup.cs

@@ -8,10 +8,15 @@
 using Microsoft.DotNet.ProjectModel.FileSystemGlobbing;
 using Newtonsoft.Json.Linq;
 
+using FourStringTuple = System.Tuple<string, string, string, string>;
+
 namespace Microsoft.DotNet.ProjectModel.Files
 {
  public class PatternGroup
  {
+ private static readonly Dictionary<FourStringTuple, IEnumerable<string>> s_resolvedFilesCache = 
+ new Dictionary<FourStringTuple, IEnumerable<string>>();
+
  private readonly List<PatternGroup> _excludeGroups = new List<PatternGroup>();
  private readonly Matcher _matcher = new Matcher();
 
@@ -80,15 +85,47 @@ public PatternGroup ExcludeGroup(PatternGroup group)
  return this;
  }
 
- public IEnumerable<string> SearchFiles(string rootPath)
+ public IEnumerable<string> SearchFiles(string rootDirectory)
+ {
+ var patternUnionKey = new FourStringTuple(rootDirectory, 
+ (IncludePatterns.Any() ? string.Join(", ", IncludePatterns): ""),
+ (IncludeLiterals.Any() ? string.Join(", ", IncludeLiterals) : ""),
+ (ExcludePatterns.Any() ? string.Join(", ", ExcludePatterns) : ""));
+
+ IEnumerable<string> resolvedFiles;
+ lock (s_resolvedFilesCache)
+ {
+ if (s_resolvedFilesCache.TryGetValue(patternUnionKey, out resolvedFiles))
+ {
+ return resolvedFiles;
+ }
+ }
+
+ resolvedFiles = ResolveFilesFromPatterns(rootDirectory, IncludePatterns, IncludeLiterals, ExcludePatterns);
+
+ lock (s_resolvedFilesCache)
+ {
+ s_resolvedFilesCache.Add(patternUnionKey, resolvedFiles);
+ }
+
+ return resolvedFiles;
+ }
+
+ private IEnumerable<string> ResolveFilesFromPatterns(
+ string rootDirectory, 
+ IEnumerable<string> includePatterns,
+ IEnumerable<string> includeLiterals,
+ IEnumerable<string> excludePatterns)
  {
+ IEnumerable<string> resolvedFiles;
+
  // literal included files are added at the last, but the search happens early
  // so as to make the process fail early in case there is missing file. fail early
  // helps to avoid unnecessary globing for performance optimization
  var literalIncludedFiles = new List<string>();
  foreach (var literalRelativePath in IncludeLiterals)
  {
- var fullPath = Path.GetFullPath(Path.Combine(rootPath, literalRelativePath));
+ var fullPath = Path.GetFullPath(Path.Combine(rootDirectory, literalRelativePath));
 
  if (!File.Exists(fullPath))
  {
@@ -100,24 +137,33 @@ public IEnumerable<string> SearchFiles(string rootPath)
  }
 
  // globing files
- var globbingResults = _matcher.GetResultsInFullPath(rootPath);
+ var globbingResults = _matcher.GetResultsInFullPath(rootDirectory);
 
  // if there is no results generated in globing, skip excluding other groups 
  // for performance optimization.
  if (globbingResults.Any())
  {
  foreach (var group in _excludeGroups)
  {
- globbingResults = globbingResults.Except(group.SearchFiles(rootPath));
+ globbingResults = globbingResults.Except(group.SearchFiles(rootDirectory));
  }
  }
 
- return globbingResults.Concat(literalIncludedFiles).Distinct();
+ resolvedFiles = globbingResults.Concat(literalIncludedFiles).Distinct();
+ return resolvedFiles;
  }
 
  public override string ToString()
  {
  return string.Format("Pattern group: Literals [{0}] Includes [{1}] Excludes [{2}]", string.Join(", ", IncludeLiterals), string.Join(", ", IncludePatterns), string.Join(", ", ExcludePatterns));
  }
+
+ public static void ClearCache()
+ {
+ if (s_resolvedFilesCache != null)
+ {
+ s_resolvedFilesCache.Clear();
+ }
+ }
  }
 }

src/Microsoft.DotNet.ProjectModel/ProjectContext.cs

@@ -14,6 +14,9 @@ namespace Microsoft.DotNet.ProjectModel
 {
  public class ProjectContext
  {
+ private readonly Dictionary<Tuple<string, string, string>, LibraryExporter> _cachedExporters = 
+ new Dictionary<Tuple<string, string, string>, LibraryExporter>();
+
  private string[] _runtimeFallbacks;
 
  public ProjectContextIdentity Identity { get; }
@@ -71,18 +74,34 @@ internal ProjectContext(
 
  public LibraryExporter CreateExporter(string configuration, string buildBasePath = null)
  {
+ LibraryExporter exporter;
+ var libraryExporterCacheKey = Tuple.Create(
+ configuration ?? "", 
+ buildBasePath ?? "",
+ RootDirectory);
+
+ if (_cachedExporters.TryGetValue(libraryExporterCacheKey, out exporter))
+ {
+ return exporter;
+ }
+
  if (IsPortable && RuntimeIdentifier != null && _runtimeFallbacks == null)
  {
  var graph = RuntimeGraphCollector.Collect(LibraryManager.GetLibraries());
  _runtimeFallbacks = graph.ExpandRuntime(RuntimeIdentifier).ToArray();
  }
- return new LibraryExporter(RootProject,
+
+ exporter = new LibraryExporter(RootProject,
  LibraryManager,
  configuration,
  RuntimeIdentifier,
  _runtimeFallbacks,
  buildBasePath,
  RootDirectory);
+
+ _cachedExporters[libraryExporterCacheKey] = exporter;
+
+ return exporter;
  }
 
  /// <summary>

src/Microsoft.DotNet.Cli.Utils/Tracing/PerfTraceOutput.cs

@@ -50,7 +50,8 @@ private static void FormatEventTimeStat(StringBuilder builder, PerfTraceEvent e,
  AppendTime(builder, e.Duration.TotalSeconds / root.Duration.TotalSeconds, 0.2);
  }
  AppendTime(builder, e.Duration.TotalSeconds / parent?.Duration.TotalSeconds, 0.5);
- builder.Append($"{e.Duration.ToString("ss\\.fff\\s").Blue()}]");
+ builder.Append($"{(int)e.Duration.TotalSeconds}.{e.Duration.Milliseconds:000}s".Blue());
+ builder.Append("]");
  }
 
  private static void AppendTime(StringBuilder builder, double? percent, double treshold)

src/Microsoft.DotNet.ProjectModel/Compilation/LibraryExporter.cs

@@ -25,6 +25,8 @@ public class LibraryExporter
  private readonly string _buildBasePath;
  private readonly string _solutionRootPath;
 
+ private List<LibraryExport> _cachedExports;
+
  public LibraryExporter(ProjectDescription rootProject,
  LibraryManager manager,
  string configuration,
@@ -84,62 +86,112 @@ public IEnumerable<LibraryExport> GetDependencies(LibraryType type)
  /// </summary>
  private IEnumerable<LibraryExport> ExportLibraries(Func<LibraryDescription, bool> condition)
  {
- var seenMetadataReferences = new HashSet<string>();
+ // Project Exports cannot be cached because the binding redirect file
+ // for desktop apps is not added to runtimeassets of the project
+ // until after the project is built.
+ var cache = GetCacheWithRefreshedProjectExports();
 
- // Iterate over libraries in the library manager
- foreach (var library in LibraryManager.GetLibraries())
+ foreach (var export in cache)
  {
- if (!condition(library))
+ if (!condition(export.Library))
  {
  continue;
  }
+ yield return export;
+ }
+ }
 
- var compilationAssemblies = new List<LibraryAsset>();
- var sourceReferences = new List<LibraryAsset>();
- var analyzerReferences = new List<AnalyzerReference>();
- var libraryExport = GetExport(library);
+ private IEnumerable<LibraryExport> GetCacheWithRefreshedProjectExports()
+ {
+ if (_cachedExports == null)
+ {
+ _cachedExports = CalculateAllExports().ToList();
+ }
+
+ var seenMetadataReferences = new HashSet<string>();
+ var refreshedCache = new LibraryExport[_cachedExports.Count()];
 
- // We need to filter out source references from non-root libraries,
- // so we rebuild the library export
- foreach (var reference in libraryExport.CompilationAssemblies)
+ int index = 0;
+ foreach (var export in _cachedExports)
+ {
+ if (Equals(export.Library.Identity.Type, LibraryType.Project))
  {
- if (seenMetadataReferences.Add(reference.Name))
- {
- compilationAssemblies.Add(reference);
- }
+ refreshedCache[index++] = GenerateExportFromLibrary(seenMetadataReferences, export.Library);
  }
-
- // Source and analyzer references are not transitive
- if (library.Parents.Contains(_rootProject))
+ else
  {
- sourceReferences.AddRange(libraryExport.SourceReferences);
- analyzerReferences.AddRange(libraryExport.AnalyzerReferences);
+ refreshedCache[index++] = export;
  }
 
- var builder = LibraryExportBuilder.Create(library);
- if (_runtime != null && _runtimeFallbacks != null)
+ foreach (var reference in export.CompilationAssemblies)
  {
- // For portable apps that are built with runtime trimming we replace RuntimeAssemblyGroups and NativeLibraryGroups
- // with single default group that contains asset specific to runtime we are trimming for
- // based on runtime fallback list
- builder.WithRuntimeAssemblyGroups(TrimAssetGroups(libraryExport.RuntimeAssemblyGroups, _runtimeFallbacks));
- builder.WithNativeLibraryGroups(TrimAssetGroups(libraryExport.NativeLibraryGroups, _runtimeFallbacks));
+ seenMetadataReferences.Add(reference.Name);
  }
- else
+ }
+
+ return refreshedCache;
+ }
+
+ private IEnumerable<LibraryExport> CalculateAllExports()
+ {
+ var seenMetadataReferences = new HashSet<string>();
+
+ // Iterate over libraries in the library manager
+ foreach (var library in LibraryManager.GetLibraries())
+ {
+ yield return GenerateExportFromLibrary(seenMetadataReferences, library);
+ }
+ }
+
+ private LibraryExport GenerateExportFromLibrary(
+ HashSet<string> seenMetadataReferences, 
+ LibraryDescription library)
+ {
+ var compilationAssemblies = new List<LibraryAsset>();
+ var sourceReferences = new List<LibraryAsset>();
+ var analyzerReferences = new List<AnalyzerReference>();
+ var libraryExport = GetExport(library);
+
+ // We need to filter out source references from non-root libraries,
+ // so we rebuild the library export
+ foreach (var reference in libraryExport.CompilationAssemblies)
+ {
+ if (seenMetadataReferences.Add(reference.Name))
  {
- builder.WithRuntimeAssemblyGroups(libraryExport.RuntimeAssemblyGroups);
- builder.WithNativeLibraryGroups(libraryExport.NativeLibraryGroups);
+ compilationAssemblies.Add(reference);
  }
+ }
 
- yield return builder
- .WithCompilationAssemblies(compilationAssemblies)
- .WithSourceReferences(sourceReferences)
- .WithRuntimeAssets(libraryExport.RuntimeAssets)
- .WithEmbedddedResources(libraryExport.EmbeddedResources)
- .WithAnalyzerReference(analyzerReferences)
- .WithResourceAssemblies(libraryExport.ResourceAssemblies)
- .Build();
+ // Source and analyzer references are not transitive
+ if (library.Parents.Contains(_rootProject))
+ {
+ sourceReferences.AddRange(libraryExport.SourceReferences);
+ analyzerReferences.AddRange(libraryExport.AnalyzerReferences);
+ }
+
+ var builder = LibraryExportBuilder.Create(library);
+ if (_runtime != null && _runtimeFallbacks != null)
+ {
+ // For portable apps that are built with runtime trimming we replace RuntimeAssemblyGroups and NativeLibraryGroups
+ // with single default group that contains asset specific to runtime we are trimming for
+ // based on runtime fallback list
+ builder.WithRuntimeAssemblyGroups(TrimAssetGroups(libraryExport.RuntimeAssemblyGroups, _runtimeFallbacks));
+ builder.WithNativeLibraryGroups(TrimAssetGroups(libraryExport.NativeLibraryGroups, _runtimeFallbacks));
  }
+ else
+ {
+ builder.WithRuntimeAssemblyGroups(libraryExport.RuntimeAssemblyGroups);
+ builder.WithNativeLibraryGroups(libraryExport.NativeLibraryGroups);
+ }
+
+ return builder
+ .WithCompilationAssemblies(compilationAssemblies)
+ .WithSourceReferences(sourceReferences)
+ .WithRuntimeAssets(libraryExport.RuntimeAssets)
+ .WithEmbedddedResources(libraryExport.EmbeddedResources)
+ .WithAnalyzerReference(analyzerReferences)
+ .WithResourceAssemblies(libraryExport.ResourceAssemblies)
+ .Build();
  }
 
  private IEnumerable<LibraryAssetGroup> TrimAssetGroups(IEnumerable<LibraryAssetGroup> runtimeAssemblyGroups,

src/Microsoft.DotNet.ProjectModel/Files/PatternGroup.cs

@@ -8,10 +8,15 @@
 using Microsoft.DotNet.ProjectModel.FileSystemGlobbing;
 using Newtonsoft.Json.Linq;
 
+using FourStringTuple = System.Tuple<string, string, string, string>;
+
 namespace Microsoft.DotNet.ProjectModel.Files
 {
  public class PatternGroup
  {
+ private static readonly Dictionary<FourStringTuple, IEnumerable<string>> s_resolvedFilesCache = 
+ new Dictionary<FourStringTuple, IEnumerable<string>>();
+
  private readonly List<PatternGroup> _excludeGroups = new List<PatternGroup>();
  private readonly Matcher _matcher = new Matcher();
 
@@ -80,15 +85,47 @@ public PatternGroup ExcludeGroup(PatternGroup group)
  return this;
  }
 
- public IEnumerable<string> SearchFiles(string rootPath)
+ public IEnumerable<string> SearchFiles(string rootDirectory)
+ {
+ var patternUnionKey = new FourStringTuple(rootDirectory, 
+ (IncludePatterns.Any() ? string.Join(", ", IncludePatterns): ""),
+ (IncludeLiterals.Any() ? string.Join(", ", IncludeLiterals) : ""),
+ (ExcludePatterns.Any() ? string.Join(", ", ExcludePatterns) : ""));
+
+ IEnumerable<string> resolvedFiles;
+ lock (s_resolvedFilesCache)
+ {
+ if (s_resolvedFilesCache.TryGetValue(patternUnionKey, out resolvedFiles))
+ {
+ return resolvedFiles;
+ }
+ }
+
+ resolvedFiles = ResolveFilesFromPatterns(rootDirectory, IncludePatterns, IncludeLiterals, ExcludePatterns);
+
+ lock (s_resolvedFilesCache)
+ {
+ s_resolvedFilesCache.Add(patternUnionKey, resolvedFiles);
+ }
+
+ return resolvedFiles;
+ }
+
+ private IEnumerable<string> ResolveFilesFromPatterns(
+ string rootDirectory, 
+ IEnumerable<string> includePatterns,
+ IEnumerable<string> includeLiterals,
+ IEnumerable<string> excludePatterns)
  {
+ IEnumerable<string> resolvedFiles;
+
  // literal included files are added at the last, but the search happens early
  // so as to make the process fail early in case there is missing file. fail early
  // helps to avoid unnecessary globing for performance optimization
  var literalIncludedFiles = new List<string>();
  foreach (var literalRelativePath in IncludeLiterals)
  {
- var fullPath = Path.GetFullPath(Path.Combine(rootPath, literalRelativePath));
+ var fullPath = Path.GetFullPath(Path.Combine(rootDirectory, literalRelativePath));
 
  if (!File.Exists(fullPath))
  {
@@ -100,24 +137,33 @@ public IEnumerable<string> SearchFiles(string rootPath)
  }
 
  // globing files
- var globbingResults = _matcher.GetResultsInFullPath(rootPath);
+ var globbingResults = _matcher.GetResultsInFullPath(rootDirectory);
 
  // if there is no results generated in globing, skip excluding other groups 
  // for performance optimization.
  if (globbingResults.Any())
  {
  foreach (var group in _excludeGroups)
  {
- globbingResults = globbingResults.Except(group.SearchFiles(rootPath));
+ globbingResults = globbingResults.Except(group.SearchFiles(rootDirectory));
  }
  }
 
- return globbingResults.Concat(literalIncludedFiles).Distinct();
+ resolvedFiles = globbingResults.Concat(literalIncludedFiles).Distinct();
+ return resolvedFiles;
  }
 
  public override string ToString()
  {
  return string.Format("Pattern group: Literals [{0}] Includes [{1}] Excludes [{2}]", string.Join(", ", IncludeLiterals), string.Join(", ", IncludePatterns), string.Join(", ", ExcludePatterns));
  }
+
+ public static void ClearCache()
+ {
+ if (s_resolvedFilesCache != null)
+ {
+ s_resolvedFilesCache.Clear();
+ }
+ }
  }
 }

src/Microsoft.DotNet.ProjectModel/ProjectContext.cs

@@ -14,6 +14,9 @@ namespace Microsoft.DotNet.ProjectModel
 {
  public class ProjectContext
  {
+ private readonly Dictionary<Tuple<string, string, string>, LibraryExporter> _cachedExporters = 
+ new Dictionary<Tuple<string, string, string>, LibraryExporter>();
+
  private string[] _runtimeFallbacks;
 
  public ProjectContextIdentity Identity { get; }
@@ -71,18 +74,34 @@ internal ProjectContext(
 
  public LibraryExporter CreateExporter(string configuration, string buildBasePath = null)
  {
+ LibraryExporter exporter;
+ var libraryExporterCacheKey = Tuple.Create(
+ configuration ?? "", 
+ buildBasePath ?? "",
+ RootDirectory);
+
+ if (_cachedExporters.TryGetValue(libraryExporterCacheKey, out exporter))
+ {
+ return exporter;
+ }
+
  if (IsPortable && RuntimeIdentifier != null && _runtimeFallbacks == null)
  {
  var graph = RuntimeGraphCollector.Collect(LibraryManager.GetLibraries());
  _runtimeFallbacks = graph.ExpandRuntime(RuntimeIdentifier).ToArray();
  }
- return new LibraryExporter(RootProject,
+
+ exporter = new LibraryExporter(RootProject,
  LibraryManager,
  configuration,
  RuntimeIdentifier,
  _runtimeFallbacks,
  buildBasePath,
  RootDirectory);
+
+ _cachedExporters[libraryExporterCacheKey] = exporter;
+
+ return exporter;
  }
 
  /// <summary>

src/Microsoft.DotNet.Cli.Utils/Tracing/PerfTraceOutput.cs

@@ -50,7 +50,8 @@ private static void FormatEventTimeStat(StringBuilder builder, PerfTraceEvent e,
  AppendTime(builder, e.Duration.TotalSeconds / root.Duration.TotalSeconds, 0.2);
  }
  AppendTime(builder, e.Duration.TotalSeconds / parent?.Duration.TotalSeconds, 0.5);
- builder.Append($"{e.Duration.ToString("ss\\.fff\\s").Blue()}]");
+ builder.Append($"{(int)e.Duration.TotalSeconds}.{e.Duration.Milliseconds:000}s".Blue());
+ builder.Append("]");
  }
 
  private static void AppendTime(StringBuilder builder, double? percent, double treshold)

src/Microsoft.DotNet.ProjectModel/Compilation/LibraryExporter.cs

@@ -25,6 +25,8 @@ public class LibraryExporter
  private readonly string _buildBasePath;
  private readonly string _solutionRootPath;
 
+ private List<LibraryExport> _cachedExports;
+
  public LibraryExporter(ProjectDescription rootProject,
  LibraryManager manager,
  string configuration,
@@ -84,62 +86,112 @@ public IEnumerable<LibraryExport> GetDependencies(LibraryType type)
  /// </summary>
  private IEnumerable<LibraryExport> ExportLibraries(Func<LibraryDescription, bool> condition)
  {
- var seenMetadataReferences = new HashSet<string>();
+ // Project Exports cannot be cached because the binding redirect file
+ // for desktop apps is not added to runtimeassets of the project
+ // until after the project is built.
+ var cache = GetCacheWithRefreshedProjectExports();
 
- // Iterate over libraries in the library manager
- foreach (var library in LibraryManager.GetLibraries())
+ foreach (var export in cache)
  {
- if (!condition(library))
+ if (!condition(export.Library))
  {
  continue;
  }
+ yield return export;
+ }
+ }
 
- var compilationAssemblies = new List<LibraryAsset>();
- var sourceReferences = new List<LibraryAsset>();
- var analyzerReferences = new List<AnalyzerReference>();
- var libraryExport = GetExport(library);
+ private IEnumerable<LibraryExport> GetCacheWithRefreshedProjectExports()
+ {
+ if (_cachedExports == null)
+ {
+ _cachedExports = CalculateAllExports().ToList();
+ }
+
+ var seenMetadataReferences = new HashSet<string>();
+ var refreshedCache = new LibraryExport[_cachedExports.Count()];
 
- // We need to filter out source references from non-root libraries,
- // so we rebuild the library export
- foreach (var reference in libraryExport.CompilationAssemblies)
+ int index = 0;
+ foreach (var export in _cachedExports)
+ {
+ if (Equals(export.Library.Identity.Type, LibraryType.Project))
  {
- if (seenMetadataReferences.Add(reference.Name))
- {
- compilationAssemblies.Add(reference);
- }
+ refreshedCache[index++] = GenerateExportFromLibrary(seenMetadataReferences, export.Library);
  }
-
- // Source and analyzer references are not transitive
- if (library.Parents.Contains(_rootProject))
+ else
  {
- sourceReferences.AddRange(libraryExport.SourceReferences);
- analyzerReferences.AddRange(libraryExport.AnalyzerReferences);
+ refreshedCache[index++] = export;
  }
 
- var builder = LibraryExportBuilder.Create(library);
- if (_runtime != null && _runtimeFallbacks != null)
+ foreach (var reference in export.CompilationAssemblies)
  {
- // For portable apps that are built with runtime trimming we replace RuntimeAssemblyGroups and NativeLibraryGroups
- // with single default group that contains asset specific to runtime we are trimming for
- // based on runtime fallback list
- builder.WithRuntimeAssemblyGroups(TrimAssetGroups(libraryExport.RuntimeAssemblyGroups, _runtimeFallbacks));
- builder.WithNativeLibraryGroups(TrimAssetGroups(libraryExport.NativeLibraryGroups, _runtimeFallbacks));
+ seenMetadataReferences.Add(reference.Name);
  }
- else
+ }
+
+ return refreshedCache;
+ }
+
+ private IEnumerable<LibraryExport> CalculateAllExports()
+ {
+ var seenMetadataReferences = new HashSet<string>();
+
+ // Iterate over libraries in the library manager
+ foreach (var library in LibraryManager.GetLibraries())
+ {
+ yield return GenerateExportFromLibrary(seenMetadataReferences, library);
+ }
+ }
+
+ private LibraryExport GenerateExportFromLibrary(
+ HashSet<string> seenMetadataReferences, 
+ LibraryDescription library)
+ {
+ var compilationAssemblies = new List<LibraryAsset>();
+ var sourceReferences = new List<LibraryAsset>();
+ var analyzerReferences = new List<AnalyzerReference>();
+ var libraryExport = GetExport(library);
+
+ // We need to filter out source references from non-root libraries,
+ // so we rebuild the library export
+ foreach (var reference in libraryExport.CompilationAssemblies)
+ {
+ if (seenMetadataReferences.Add(reference.Name))
  {
- builder.WithRuntimeAssemblyGroups(libraryExport.RuntimeAssemblyGroups);
- builder.WithNativeLibraryGroups(libraryExport.NativeLibraryGroups);
+ compilationAssemblies.Add(reference);
  }
+ }
 
- yield return builder
- .WithCompilationAssemblies(compilationAssemblies)
- .WithSourceReferences(sourceReferences)
- .WithRuntimeAssets(libraryExport.RuntimeAssets)
- .WithEmbedddedResources(libraryExport.EmbeddedResources)
- .WithAnalyzerReference(analyzerReferences)
- .WithResourceAssemblies(libraryExport.ResourceAssemblies)
- .Build();
+ // Source and analyzer references are not transitive
+ if (library.Parents.Contains(_rootProject))
+ {
+ sourceReferences.AddRange(libraryExport.SourceReferences);
+ analyzerReferences.AddRange(libraryExport.AnalyzerReferences);
+ }
+
+ var builder = LibraryExportBuilder.Create(library);
+ if (_runtime != null && _runtimeFallbacks != null)
+ {
+ // For portable apps that are built with runtime trimming we replace RuntimeAssemblyGroups and NativeLibraryGroups
+ // with single default group that contains asset specific to runtime we are trimming for
+ // based on runtime fallback list
+ builder.WithRuntimeAssemblyGroups(TrimAssetGroups(libraryExport.RuntimeAssemblyGroups, _runtimeFallbacks));
+ builder.WithNativeLibraryGroups(TrimAssetGroups(libraryExport.NativeLibraryGroups, _runtimeFallbacks));
  }
+ else
+ {
+ builder.WithRuntimeAssemblyGroups(libraryExport.RuntimeAssemblyGroups);
+ builder.WithNativeLibraryGroups(libraryExport.NativeLibraryGroups);
+ }
+
+ return builder
+ .WithCompilationAssemblies(compilationAssemblies)
+ .WithSourceReferences(sourceReferences)
+ .WithRuntimeAssets(libraryExport.RuntimeAssets)
+ .WithEmbedddedResources(libraryExport.EmbeddedResources)
+ .WithAnalyzerReference(analyzerReferences)
+ .WithResourceAssemblies(libraryExport.ResourceAssemblies)
+ .Build();
  }
 
  private IEnumerable<LibraryAssetGroup> TrimAssetGroups(IEnumerable<LibraryAssetGroup> runtimeAssemblyGroups,

src/Microsoft.DotNet.ProjectModel/Files/PatternGroup.cs

@@ -8,10 +8,15 @@
 using Microsoft.DotNet.ProjectModel.FileSystemGlobbing;
 using Newtonsoft.Json.Linq;
 
+using FourStringTuple = System.Tuple<string, string, string, string>;
+
 namespace Microsoft.DotNet.ProjectModel.Files
 {
  public class PatternGroup
  {
+ private static readonly Dictionary<FourStringTuple, IEnumerable<string>> s_resolvedFilesCache = 
+ new Dictionary<FourStringTuple, IEnumerable<string>>();
+
  private readonly List<PatternGroup> _excludeGroups = new List<PatternGroup>();
  private readonly Matcher _matcher = new Matcher();
 
@@ -80,15 +85,47 @@ public PatternGroup ExcludeGroup(PatternGroup group)
  return this;
  }
 
- public IEnumerable<string> SearchFiles(string rootPath)
+ public IEnumerable<string> SearchFiles(string rootDirectory)
+ {
+ var patternUnionKey = new FourStringTuple(rootDirectory, 
+ (IncludePatterns.Any() ? string.Join(", ", IncludePatterns): ""),
+ (IncludeLiterals.Any() ? string.Join(", ", IncludeLiterals) : ""),
+ (ExcludePatterns.Any() ? string.Join(", ", ExcludePatterns) : ""));
+
+ IEnumerable<string> resolvedFiles;
+ lock (s_resolvedFilesCache)
+ {
+ if (s_resolvedFilesCache.TryGetValue(patternUnionKey, out resolvedFiles))
+ {
+ return resolvedFiles;
+ }
+ }
+
+ resolvedFiles = ResolveFilesFromPatterns(rootDirectory, IncludePatterns, IncludeLiterals, ExcludePatterns);
+
+ lock (s_resolvedFilesCache)
+ {
+ s_resolvedFilesCache.Add(patternUnionKey, resolvedFiles);
+ }
+
+ return resolvedFiles;
+ }
+
+ private IEnumerable<string> ResolveFilesFromPatterns(
+ string rootDirectory, 
+ IEnumerable<string> includePatterns,
+ IEnumerable<string> includeLiterals,
+ IEnumerable<string> excludePatterns)
  {
+ IEnumerable<string> resolvedFiles;
+
  // literal included files are added at the last, but the search happens early
  // so as to make the process fail early in case there is missing file. fail early
  // helps to avoid unnecessary globing for performance optimization
  var literalIncludedFiles = new List<string>();
  foreach (var literalRelativePath in IncludeLiterals)
  {
- var fullPath = Path.GetFullPath(Path.Combine(rootPath, literalRelativePath));
+ var fullPath = Path.GetFullPath(Path.Combine(rootDirectory, literalRelativePath));
 
  if (!File.Exists(fullPath))
  {
@@ -100,24 +137,33 @@ public IEnumerable<string> SearchFiles(string rootPath)
  }
 
  // globing files
- var globbingResults = _matcher.GetResultsInFullPath(rootPath);
+ var globbingResults = _matcher.GetResultsInFullPath(rootDirectory);
 
  // if there is no results generated in globing, skip excluding other groups 
  // for performance optimization.
  if (globbingResults.Any())
  {
  foreach (var group in _excludeGroups)
  {
- globbingResults = globbingResults.Except(group.SearchFiles(rootPath));
+ globbingResults = globbingResults.Except(group.SearchFiles(rootDirectory));
  }
  }
 
- return globbingResults.Concat(literalIncludedFiles).Distinct();
+ resolvedFiles = globbingResults.Concat(literalIncludedFiles).Distinct();
+ return resolvedFiles;
  }
 
  public override string ToString()
  {
  return string.Format("Pattern group: Literals [{0}] Includes [{1}] Excludes [{2}]", string.Join(", ", IncludeLiterals), string.Join(", ", IncludePatterns), string.Join(", ", ExcludePatterns));
  }
+
+ public static void ClearCache()
+ {
+ if (s_resolvedFilesCache != null)
+ {
+ s_resolvedFilesCache.Clear();
+ }
+ }
  }
 }

src/Microsoft.DotNet.ProjectModel/ProjectContext.cs

@@ -14,6 +14,9 @@ namespace Microsoft.DotNet.ProjectModel
 {
  public class ProjectContext
  {
+ private readonly Dictionary<Tuple<string, string, string>, LibraryExporter> _cachedExporters = 
+ new Dictionary<Tuple<string, string, string>, LibraryExporter>();
+
  private string[] _runtimeFallbacks;
 
  public ProjectContextIdentity Identity { get; }
@@ -71,18 +74,34 @@ internal ProjectContext(
 
  public LibraryExporter CreateExporter(string configuration, string buildBasePath = null)
  {
+ LibraryExporter exporter;
+ var libraryExporterCacheKey = Tuple.Create(
+ configuration ?? "", 
+ buildBasePath ?? "",
+ RootDirectory);
+
+ if (_cachedExporters.TryGetValue(libraryExporterCacheKey, out exporter))
+ {
+ return exporter;
+ }
+
  if (IsPortable && RuntimeIdentifier != null && _runtimeFallbacks == null)
  {
  var graph = RuntimeGraphCollector.Collect(LibraryManager.GetLibraries());
  _runtimeFallbacks = graph.ExpandRuntime(RuntimeIdentifier).ToArray();
  }
- return new LibraryExporter(RootProject,
+
+ exporter = new LibraryExporter(RootProject,
  LibraryManager,
  configuration,
  RuntimeIdentifier,
  _runtimeFallbacks,
  buildBasePath,
  RootDirectory);
+
+ _cachedExporters[libraryExporterCacheKey] = exporter;
+
+ return exporter;
  }
 
  /// <summary>

src/Microsoft.DotNet.Cli.Utils/Tracing/PerfTraceOutput.cs

@@ -50,7 +50,8 @@ private static void FormatEventTimeStat(StringBuilder builder, PerfTraceEvent e,
  AppendTime(builder, e.Duration.TotalSeconds / root.Duration.TotalSeconds, 0.2);
  }
  AppendTime(builder, e.Duration.TotalSeconds / parent?.Duration.TotalSeconds, 0.5);
- builder.Append($"{e.Duration.ToString("ss\\.fff\\s").Blue()}]");
+ builder.Append($"{(int)e.Duration.TotalSeconds}.{e.Duration.Milliseconds:000}s".Blue());
+ builder.Append("]");
  }
 
  private static void AppendTime(StringBuilder builder, double? percent, double treshold)

src/Microsoft.DotNet.ProjectModel/Compilation/LibraryExporter.cs

@@ -25,6 +25,8 @@ public class LibraryExporter
  private readonly string _buildBasePath;
  private readonly string _solutionRootPath;
 
+ private List<LibraryExport> _cachedExports;
+
  public LibraryExporter(ProjectDescription rootProject,
  LibraryManager manager,
  string configuration,
@@ -84,62 +86,112 @@ public IEnumerable<LibraryExport> GetDependencies(LibraryType type)
  /// </summary>
  private IEnumerable<LibraryExport> ExportLibraries(Func<LibraryDescription, bool> condition)
  {
- var seenMetadataReferences = new HashSet<string>();
+ // Project Exports cannot be cached because the binding redirect file
+ // for desktop apps is not added to runtimeassets of the project
+ // until after the project is built.
+ var cache = GetCacheWithRefreshedProjectExports();
 
- // Iterate over libraries in the library manager
- foreach (var library in LibraryManager.GetLibraries())
+ foreach (var export in cache)
  {
- if (!condition(library))
+ if (!condition(export.Library))
  {
  continue;
  }
+ yield return export;
+ }
+ }
 
- var compilationAssemblies = new List<LibraryAsset>();
- var sourceReferences = new List<LibraryAsset>();
- var analyzerReferences = new List<AnalyzerReference>();
- var libraryExport = GetExport(library);
+ private IEnumerable<LibraryExport> GetCacheWithRefreshedProjectExports()
+ {
+ if (_cachedExports == null)
+ {
+ _cachedExports = CalculateAllExports().ToList();
+ }
+
+ var seenMetadataReferences = new HashSet<string>();
+ var refreshedCache = new LibraryExport[_cachedExports.Count()];
 
- // We need to filter out source references from non-root libraries,
- // so we rebuild the library export
- foreach (var reference in libraryExport.CompilationAssemblies)
+ int index = 0;
+ foreach (var export in _cachedExports)
+ {
+ if (Equals(export.Library.Identity.Type, LibraryType.Project))
  {
- if (seenMetadataReferences.Add(reference.Name))
- {
- compilationAssemblies.Add(reference);
- }
+ refreshedCache[index++] = GenerateExportFromLibrary(seenMetadataReferences, export.Library);
  }
-
- // Source and analyzer references are not transitive
- if (library.Parents.Contains(_rootProject))
+ else
  {
- sourceReferences.AddRange(libraryExport.SourceReferences);
- analyzerReferences.AddRange(libraryExport.AnalyzerReferences);
+ refreshedCache[index++] = export;
  }
 
- var builder = LibraryExportBuilder.Create(library);
- if (_runtime != null && _runtimeFallbacks != null)
+ foreach (var reference in export.CompilationAssemblies)
  {
- // For portable apps that are built with runtime trimming we replace RuntimeAssemblyGroups and NativeLibraryGroups
- // with single default group that contains asset specific to runtime we are trimming for
- // based on runtime fallback list
- builder.WithRuntimeAssemblyGroups(TrimAssetGroups(libraryExport.RuntimeAssemblyGroups, _runtimeFallbacks));
- builder.WithNativeLibraryGroups(TrimAssetGroups(libraryExport.NativeLibraryGroups, _runtimeFallbacks));
+ seenMetadataReferences.Add(reference.Name);
  }
- else
+ }
+
+ return refreshedCache;
+ }
+
+ private IEnumerable<LibraryExport> CalculateAllExports()
+ {
+ var seenMetadataReferences = new HashSet<string>();
+
+ // Iterate over libraries in the library manager
+ foreach (var library in LibraryManager.GetLibraries())
+ {
+ yield return GenerateExportFromLibrary(seenMetadataReferences, library);
+ }
+ }
+
+ private LibraryExport GenerateExportFromLibrary(
+ HashSet<string> seenMetadataReferences, 
+ LibraryDescription library)
+ {
+ var compilationAssemblies = new List<LibraryAsset>();
+ var sourceReferences = new List<LibraryAsset>();
+ var analyzerReferences = new List<AnalyzerReference>();
+ var libraryExport = GetExport(library);
+
+ // We need to filter out source references from non-root libraries,
+ // so we rebuild the library export
+ foreach (var reference in libraryExport.CompilationAssemblies)
+ {
+ if (seenMetadataReferences.Add(reference.Name))
  {
- builder.WithRuntimeAssemblyGroups(libraryExport.RuntimeAssemblyGroups);
- builder.WithNativeLibraryGroups(libraryExport.NativeLibraryGroups);
+ compilationAssemblies.Add(reference);
  }
+ }
 
- yield return builder
- .WithCompilationAssemblies(compilationAssemblies)
- .WithSourceReferences(sourceReferences)
- .WithRuntimeAssets(libraryExport.RuntimeAssets)
- .WithEmbedddedResources(libraryExport.EmbeddedResources)
- .WithAnalyzerReference(analyzerReferences)
- .WithResourceAssemblies(libraryExport.ResourceAssemblies)
- .Build();
+ // Source and analyzer references are not transitive
+ if (library.Parents.Contains(_rootProject))
+ {
+ sourceReferences.AddRange(libraryExport.SourceReferences);
+ analyzerReferences.AddRange(libraryExport.AnalyzerReferences);
+ }
+
+ var builder = LibraryExportBuilder.Create(library);
+ if (_runtime != null && _runtimeFallbacks != null)
+ {
+ // For portable apps that are built with runtime trimming we replace RuntimeAssemblyGroups and NativeLibraryGroups
+ // with single default group that contains asset specific to runtime we are trimming for
+ // based on runtime fallback list
+ builder.WithRuntimeAssemblyGroups(TrimAssetGroups(libraryExport.RuntimeAssemblyGroups, _runtimeFallbacks));
+ builder.WithNativeLibraryGroups(TrimAssetGroups(libraryExport.NativeLibraryGroups, _runtimeFallbacks));
  }
+ else
+ {
+ builder.WithRuntimeAssemblyGroups(libraryExport.RuntimeAssemblyGroups);
+ builder.WithNativeLibraryGroups(libraryExport.NativeLibraryGroups);
+ }
+
+ return builder
+ .WithCompilationAssemblies(compilationAssemblies)
+ .WithSourceReferences(sourceReferences)
+ .WithRuntimeAssets(libraryExport.RuntimeAssets)
+ .WithEmbedddedResources(libraryExport.EmbeddedResources)
+ .WithAnalyzerReference(analyzerReferences)
+ .WithResourceAssemblies(libraryExport.ResourceAssemblies)
+ .Build();
  }
 
  private IEnumerable<LibraryAssetGroup> TrimAssetGroups(IEnumerable<LibraryAssetGroup> runtimeAssemblyGroups,

src/Microsoft.DotNet.ProjectModel/Files/PatternGroup.cs

@@ -8,10 +8,15 @@
 using Microsoft.DotNet.ProjectModel.FileSystemGlobbing;
 using Newtonsoft.Json.Linq;
 
+using FourStringTuple = System.Tuple<string, string, string, string>;
+
 namespace Microsoft.DotNet.ProjectModel.Files
 {
  public class PatternGroup
  {
+ private static readonly Dictionary<FourStringTuple, IEnumerable<string>> s_resolvedFilesCache = 
+ new Dictionary<FourStringTuple, IEnumerable<string>>();
+
  private readonly List<PatternGroup> _excludeGroups = new List<PatternGroup>();
  private readonly Matcher _matcher = new Matcher();
 
@@ -80,15 +85,47 @@ public PatternGroup ExcludeGroup(PatternGroup group)
  return this;
  }
 
- public IEnumerable<string> SearchFiles(string rootPath)
+ public IEnumerable<string> SearchFiles(string rootDirectory)
+ {
+ var patternUnionKey = new FourStringTuple(rootDirectory, 
+ (IncludePatterns.Any() ? string.Join(", ", IncludePatterns): ""),
+ (IncludeLiterals.Any() ? string.Join(", ", IncludeLiterals) : ""),
+ (ExcludePatterns.Any() ? string.Join(", ", ExcludePatterns) : ""));
+
+ IEnumerable<string> resolvedFiles;
+ lock (s_resolvedFilesCache)
+ {
+ if (s_resolvedFilesCache.TryGetValue(patternUnionKey, out resolvedFiles))
+ {
+ return resolvedFiles;
+ }
+ }
+
+ resolvedFiles = ResolveFilesFromPatterns(rootDirectory, IncludePatterns, IncludeLiterals, ExcludePatterns);
+
+ lock (s_resolvedFilesCache)
+ {
+ s_resolvedFilesCache.Add(patternUnionKey, resolvedFiles);
+ }
+
+ return resolvedFiles;
+ }
+
+ private IEnumerable<string> ResolveFilesFromPatterns(
+ string rootDirectory, 
+ IEnumerable<string> includePatterns,
+ IEnumerable<string> includeLiterals,
+ IEnumerable<string> excludePatterns)
  {
+ IEnumerable<string> resolvedFiles;
+
  // literal included files are added at the last, but the search happens early
  // so as to make the process fail early in case there is missing file. fail early
  // helps to avoid unnecessary globing for performance optimization
  var literalIncludedFiles = new List<string>();
  foreach (var literalRelativePath in IncludeLiterals)
  {
- var fullPath = Path.GetFullPath(Path.Combine(rootPath, literalRelativePath));
+ var fullPath = Path.GetFullPath(Path.Combine(rootDirectory, literalRelativePath));
 
  if (!File.Exists(fullPath))
  {
@@ -100,24 +137,33 @@ public IEnumerable<string> SearchFiles(string rootPath)
  }
 
  // globing files
- var globbingResults = _matcher.GetResultsInFullPath(rootPath);
+ var globbingResults = _matcher.GetResultsInFullPath(rootDirectory);
 
  // if there is no results generated in globing, skip excluding other groups 
  // for performance optimization.
  if (globbingResults.Any())
  {
  foreach (var group in _excludeGroups)
  {
- globbingResults = globbingResults.Except(group.SearchFiles(rootPath));
+ globbingResults = globbingResults.Except(group.SearchFiles(rootDirectory));
  }
  }
 
- return globbingResults.Concat(literalIncludedFiles).Distinct();
+ resolvedFiles = globbingResults.Concat(literalIncludedFiles).Distinct();
+ return resolvedFiles;
  }
 
  public override string ToString()
  {
  return string.Format("Pattern group: Literals [{0}] Includes [{1}] Excludes [{2}]", string.Join(", ", IncludeLiterals), string.Join(", ", IncludePatterns), string.Join(", ", ExcludePatterns));
  }
+
+ public static void ClearCache()
+ {
+ if (s_resolvedFilesCache != null)
+ {
+ s_resolvedFilesCache.Clear();
+ }
+ }
  }
 }

src/Microsoft.DotNet.ProjectModel/ProjectContext.cs

@@ -14,6 +14,9 @@ namespace Microsoft.DotNet.ProjectModel
 {
  public class ProjectContext
  {
+ private readonly Dictionary<Tuple<string, string, string>, LibraryExporter> _cachedExporters = 
+ new Dictionary<Tuple<string, string, string>, LibraryExporter>();
+
  private string[] _runtimeFallbacks;
 
  public ProjectContextIdentity Identity { get; }
@@ -71,18 +74,34 @@ internal ProjectContext(
 
  public LibraryExporter CreateExporter(string configuration, string buildBasePath = null)
  {
+ LibraryExporter exporter;
+ var libraryExporterCacheKey = Tuple.Create(
+ configuration ?? "", 
+ buildBasePath ?? "",
+ RootDirectory);
+
+ if (_cachedExporters.TryGetValue(libraryExporterCacheKey, out exporter))
+ {
+ return exporter;
+ }
+
  if (IsPortable && RuntimeIdentifier != null && _runtimeFallbacks == null)
  {
  var graph = RuntimeGraphCollector.Collect(LibraryManager.GetLibraries());
  _runtimeFallbacks = graph.ExpandRuntime(RuntimeIdentifier).ToArray();
  }
- return new LibraryExporter(RootProject,
+
+ exporter = new LibraryExporter(RootProject,
  LibraryManager,
  configuration,
  RuntimeIdentifier,
  _runtimeFallbacks,
  buildBasePath,
  RootDirectory);
+
+ _cachedExporters[libraryExporterCacheKey] = exporter;
+
+ return exporter;
  }
 
  /// <summary>

src/Microsoft.DotNet.Cli.Utils/Tracing/PerfTraceOutput.cs

@@ -50,7 +50,8 @@ private static void FormatEventTimeStat(StringBuilder builder, PerfTraceEvent e,
  AppendTime(builder, e.Duration.TotalSeconds / root.Duration.TotalSeconds, 0.2);
  }
  AppendTime(builder, e.Duration.TotalSeconds / parent?.Duration.TotalSeconds, 0.5);
- builder.Append($"{e.Duration.ToString("ss\\.fff\\s").Blue()}]");
+ builder.Append($"{(int)e.Duration.TotalSeconds}.{e.Duration.Milliseconds:000}s".Blue());
+ builder.Append("]");
  }
 
  private static void AppendTime(StringBuilder builder, double? percent, double treshold)

src/Microsoft.DotNet.ProjectModel/Compilation/LibraryExporter.cs

@@ -25,6 +25,8 @@ public class LibraryExporter
  private readonly string _buildBasePath;
  private readonly string _solutionRootPath;
 
+ private List<LibraryExport> _cachedExports;
+
  public LibraryExporter(ProjectDescription rootProject,
  LibraryManager manager,
  string configuration,
@@ -84,62 +86,112 @@ public IEnumerable<LibraryExport> GetDependencies(LibraryType type)
  /// </summary>
  private IEnumerable<LibraryExport> ExportLibraries(Func<LibraryDescription, bool> condition)
  {
- var seenMetadataReferences = new HashSet<string>();
+ // Project Exports cannot be cached because the binding redirect file
+ // for desktop apps is not added to runtimeassets of the project
+ // until after the project is built.
+ var cache = GetCacheWithRefreshedProjectExports();
 
- // Iterate over libraries in the library manager
- foreach (var library in LibraryManager.GetLibraries())
+ foreach (var export in cache)
  {
- if (!condition(library))
+ if (!condition(export.Library))
  {
  continue;
  }
+ yield return export;
+ }
+ }
 
- var compilationAssemblies = new List<LibraryAsset>();
- var sourceReferences = new List<LibraryAsset>();
- var analyzerReferences = new List<AnalyzerReference>();
- var libraryExport = GetExport(library);
+ private IEnumerable<LibraryExport> GetCacheWithRefreshedProjectExports()
+ {
+ if (_cachedExports == null)
+ {
+ _cachedExports = CalculateAllExports().ToList();
+ }
+
+ var seenMetadataReferences = new HashSet<string>();
+ var refreshedCache = new LibraryExport[_cachedExports.Count()];
 
- // We need to filter out source references from non-root libraries,
- // so we rebuild the library export
- foreach (var reference in libraryExport.CompilationAssemblies)
+ int index = 0;
+ foreach (var export in _cachedExports)
+ {
+ if (Equals(export.Library.Identity.Type, LibraryType.Project))
  {
- if (seenMetadataReferences.Add(reference.Name))
- {
- compilationAssemblies.Add(reference);
- }
+ refreshedCache[index++] = GenerateExportFromLibrary(seenMetadataReferences, export.Library);
  }
-
- // Source and analyzer references are not transitive
- if (library.Parents.Contains(_rootProject))
+ else
  {
- sourceReferences.AddRange(libraryExport.SourceReferences);
- analyzerReferences.AddRange(libraryExport.AnalyzerReferences);
+ refreshedCache[index++] = export;
  }
 
- var builder = LibraryExportBuilder.Create(library);
- if (_runtime != null && _runtimeFallbacks != null)
+ foreach (var reference in export.CompilationAssemblies)
  {
- // For portable apps that are built with runtime trimming we replace RuntimeAssemblyGroups and NativeLibraryGroups
- // with single default group that contains asset specific to runtime we are trimming for
- // based on runtime fallback list
- builder.WithRuntimeAssemblyGroups(TrimAssetGroups(libraryExport.RuntimeAssemblyGroups, _runtimeFallbacks));
- builder.WithNativeLibraryGroups(TrimAssetGroups(libraryExport.NativeLibraryGroups, _runtimeFallbacks));
+ seenMetadataReferences.Add(reference.Name);
  }
- else
+ }
+
+ return refreshedCache;
+ }
+
+ private IEnumerable<LibraryExport> CalculateAllExports()
+ {
+ var seenMetadataReferences = new HashSet<string>();
+
+ // Iterate over libraries in the library manager
+ foreach (var library in LibraryManager.GetLibraries())
+ {
+ yield return GenerateExportFromLibrary(seenMetadataReferences, library);
+ }
+ }
+
+ private LibraryExport GenerateExportFromLibrary(
+ HashSet<string> seenMetadataReferences, 
+ LibraryDescription library)
+ {
+ var compilationAssemblies = new List<LibraryAsset>();
+ var sourceReferences = new List<LibraryAsset>();
+ var analyzerReferences = new List<AnalyzerReference>();
+ var libraryExport = GetExport(library);
+
+ // We need to filter out source references from non-root libraries,
+ // so we rebuild the library export
+ foreach (var reference in libraryExport.CompilationAssemblies)
+ {
+ if (seenMetadataReferences.Add(reference.Name))
  {
- builder.WithRuntimeAssemblyGroups(libraryExport.RuntimeAssemblyGroups);
- builder.WithNativeLibraryGroups(libraryExport.NativeLibraryGroups);
+ compilationAssemblies.Add(reference);
  }
+ }
 
- yield return builder
- .WithCompilationAssemblies(compilationAssemblies)
- .WithSourceReferences(sourceReferences)
- .WithRuntimeAssets(libraryExport.RuntimeAssets)
- .WithEmbedddedResources(libraryExport.EmbeddedResources)
- .WithAnalyzerReference(analyzerReferences)
- .WithResourceAssemblies(libraryExport.ResourceAssemblies)
- .Build();
+ // Source and analyzer references are not transitive
+ if (library.Parents.Contains(_rootProject))
+ {
+ sourceReferences.AddRange(libraryExport.SourceReferences);
+ analyzerReferences.AddRange(libraryExport.AnalyzerReferences);
+ }
+
+ var builder = LibraryExportBuilder.Create(library);
+ if (_runtime != null && _runtimeFallbacks != null)
+ {
+ // For portable apps that are built with runtime trimming we replace RuntimeAssemblyGroups and NativeLibraryGroups
+ // with single default group that contains asset specific to runtime we are trimming for
+ // based on runtime fallback list
+ builder.WithRuntimeAssemblyGroups(TrimAssetGroups(libraryExport.RuntimeAssemblyGroups, _runtimeFallbacks));
+ builder.WithNativeLibraryGroups(TrimAssetGroups(libraryExport.NativeLibraryGroups, _runtimeFallbacks));
  }
+ else
+ {
+ builder.WithRuntimeAssemblyGroups(libraryExport.RuntimeAssemblyGroups);
+ builder.WithNativeLibraryGroups(libraryExport.NativeLibraryGroups);
+ }
+
+ return builder
+ .WithCompilationAssemblies(compilationAssemblies)
+ .WithSourceReferences(sourceReferences)
+ .WithRuntimeAssets(libraryExport.RuntimeAssets)
+ .WithEmbedddedResources(libraryExport.EmbeddedResources)
+ .WithAnalyzerReference(analyzerReferences)
+ .WithResourceAssemblies(libraryExport.ResourceAssemblies)
+ .Build();
  }
 
  private IEnumerable<LibraryAssetGroup> TrimAssetGroups(IEnumerable<LibraryAssetGroup> runtimeAssemblyGroups,

src/Microsoft.DotNet.ProjectModel/Files/PatternGroup.cs

@@ -8,10 +8,15 @@
 using Microsoft.DotNet.ProjectModel.FileSystemGlobbing;
 using Newtonsoft.Json.Linq;
 
+using FourStringTuple = System.Tuple<string, string, string, string>;
+
 namespace Microsoft.DotNet.ProjectModel.Files
 {
  public class PatternGroup
  {
+ private static readonly Dictionary<FourStringTuple, IEnumerable<string>> s_resolvedFilesCache = 
+ new Dictionary<FourStringTuple, IEnumerable<string>>();
+
  private readonly List<PatternGroup> _excludeGroups = new List<PatternGroup>();
  private readonly Matcher _matcher = new Matcher();
 
@@ -80,15 +85,47 @@ public PatternGroup ExcludeGroup(PatternGroup group)
  return this;
  }
 
- public IEnumerable<string> SearchFiles(string rootPath)
+ public IEnumerable<string> SearchFiles(string rootDirectory)
+ {
+ var patternUnionKey = new FourStringTuple(rootDirectory, 
+ (IncludePatterns.Any() ? string.Join(", ", IncludePatterns): ""),
+ (IncludeLiterals.Any() ? string.Join(", ", IncludeLiterals) : ""),
+ (ExcludePatterns.Any() ? string.Join(", ", ExcludePatterns) : ""));
+
+ IEnumerable<string> resolvedFiles;
+ lock (s_resolvedFilesCache)
+ {
+ if (s_resolvedFilesCache.TryGetValue(patternUnionKey, out resolvedFiles))
+ {
+ return resolvedFiles;
+ }
+ }
+
+ resolvedFiles = ResolveFilesFromPatterns(rootDirectory, IncludePatterns, IncludeLiterals, ExcludePatterns);
+
+ lock (s_resolvedFilesCache)
+ {
+ s_resolvedFilesCache.Add(patternUnionKey, resolvedFiles);
+ }
+
+ return resolvedFiles;
+ }
+
+ private IEnumerable<string> ResolveFilesFromPatterns(
+ string rootDirectory, 
+ IEnumerable<string> includePatterns,
+ IEnumerable<string> includeLiterals,
+ IEnumerable<string> excludePatterns)
  {
+ IEnumerable<string> resolvedFiles;
+
  // literal included files are added at the last, but the search happens early
  // so as to make the process fail early in case there is missing file. fail early
  // helps to avoid unnecessary globing for performance optimization
  var literalIncludedFiles = new List<string>();
  foreach (var literalRelativePath in IncludeLiterals)
  {
- var fullPath = Path.GetFullPath(Path.Combine(rootPath, literalRelativePath));
+ var fullPath = Path.GetFullPath(Path.Combine(rootDirectory, literalRelativePath));
 
  if (!File.Exists(fullPath))
  {
@@ -100,24 +137,33 @@ public IEnumerable<string> SearchFiles(string rootPath)
  }
 
  // globing files
- var globbingResults = _matcher.GetResultsInFullPath(rootPath);
+ var globbingResults = _matcher.GetResultsInFullPath(rootDirectory);
 
  // if there is no results generated in globing, skip excluding other groups 
  // for performance optimization.
  if (globbingResults.Any())
  {
  foreach (var group in _excludeGroups)
  {
- globbingResults = globbingResults.Except(group.SearchFiles(rootPath));
+ globbingResults = globbingResults.Except(group.SearchFiles(rootDirectory));
  }
  }
 
- return globbingResults.Concat(literalIncludedFiles).Distinct();
+ resolvedFiles = globbingResults.Concat(literalIncludedFiles).Distinct();
+ return resolvedFiles;
  }
 
  public override string ToString()
  {
  return string.Format("Pattern group: Literals [{0}] Includes [{1}] Excludes [{2}]", string.Join(", ", IncludeLiterals), string.Join(", ", IncludePatterns), string.Join(", ", ExcludePatterns));
  }
+
+ public static void ClearCache()
+ {
+ if (s_resolvedFilesCache != null)
+ {
+ s_resolvedFilesCache.Clear();
+ }
+ }
  }
 }

src/Microsoft.DotNet.ProjectModel/ProjectContext.cs

@@ -14,6 +14,9 @@ namespace Microsoft.DotNet.ProjectModel
 {
  public class ProjectContext
  {
+ private readonly Dictionary<Tuple<string, string, string>, LibraryExporter> _cachedExporters = 
+ new Dictionary<Tuple<string, string, string>, LibraryExporter>();
+
  private string[] _runtimeFallbacks;
 
  public ProjectContextIdentity Identity { get; }
@@ -71,18 +74,34 @@ internal ProjectContext(
 
  public LibraryExporter CreateExporter(string configuration, string buildBasePath = null)
  {
+ LibraryExporter exporter;
+ var libraryExporterCacheKey = Tuple.Create(
+ configuration ?? "", 
+ buildBasePath ?? "",
+ RootDirectory);
+
+ if (_cachedExporters.TryGetValue(libraryExporterCacheKey, out exporter))
+ {
+ return exporter;
+ }
+
  if (IsPortable && RuntimeIdentifier != null && _runtimeFallbacks == null)
  {
  var graph = RuntimeGraphCollector.Collect(LibraryManager.GetLibraries());
  _runtimeFallbacks = graph.ExpandRuntime(RuntimeIdentifier).ToArray();
  }
- return new LibraryExporter(RootProject,
+
+ exporter = new LibraryExporter(RootProject,
  LibraryManager,
  configuration,
  RuntimeIdentifier,
  _runtimeFallbacks,
  buildBasePath,
  RootDirectory);
+
+ _cachedExporters[libraryExporterCacheKey] = exporter;
+
+ return exporter;
  }
 
  /// <summary>

src/Microsoft.DotNet.Cli.Utils/Tracing/PerfTraceOutput.cs

@@ -50,7 +50,8 @@ private static void FormatEventTimeStat(StringBuilder builder, PerfTraceEvent e,
  AppendTime(builder, e.Duration.TotalSeconds / root.Duration.TotalSeconds, 0.2);
  }
  AppendTime(builder, e.Duration.TotalSeconds / parent?.Duration.TotalSeconds, 0.5);
- builder.Append($"{e.Duration.ToString("ss\\.fff\\s").Blue()}]");
+ builder.Append($"{(int)e.Duration.TotalSeconds}.{e.Duration.Milliseconds:000}s".Blue());
+ builder.Append("]");
  }
 
  private static void AppendTime(StringBuilder builder, double? percent, double treshold)

src/Microsoft.DotNet.ProjectModel/Compilation/LibraryExporter.cs

@@ -25,6 +25,8 @@ public class LibraryExporter
  private readonly string _buildBasePath;
  private readonly string _solutionRootPath;
 
+ private List<LibraryExport> _cachedExports;
+
  public LibraryExporter(ProjectDescription rootProject,
  LibraryManager manager,
  string configuration,
@@ -84,62 +86,112 @@ public IEnumerable<LibraryExport> GetDependencies(LibraryType type)
  /// </summary>
  private IEnumerable<LibraryExport> ExportLibraries(Func<LibraryDescription, bool> condition)
  {
- var seenMetadataReferences = new HashSet<string>();
+ // Project Exports cannot be cached because the binding redirect file
+ // for desktop apps is not added to runtimeassets of the project
+ // until after the project is built.
+ var cache = GetCacheWithRefreshedProjectExports();
 
- // Iterate over libraries in the library manager
- foreach (var library in LibraryManager.GetLibraries())
+ foreach (var export in cache)
  {
- if (!condition(library))
+ if (!condition(export.Library))
  {
  continue;
  }
+ yield return export;
+ }
+ }
 
- var compilationAssemblies = new List<LibraryAsset>();
- var sourceReferences = new List<LibraryAsset>();
- var analyzerReferences = new List<AnalyzerReference>();
- var libraryExport = GetExport(library);
+ private IEnumerable<LibraryExport> GetCacheWithRefreshedProjectExports()
+ {
+ if (_cachedExports == null)
+ {
+ _cachedExports = CalculateAllExports().ToList();
+ }
+
+ var seenMetadataReferences = new HashSet<string>();
+ var refreshedCache = new LibraryExport[_cachedExports.Count()];
 
- // We need to filter out source references from non-root libraries,
- // so we rebuild the library export
- foreach (var reference in libraryExport.CompilationAssemblies)
+ int index = 0;
+ foreach (var export in _cachedExports)
+ {
+ if (Equals(export.Library.Identity.Type, LibraryType.Project))
  {
- if (seenMetadataReferences.Add(reference.Name))
- {
- compilationAssemblies.Add(reference);
- }
+ refreshedCache[index++] = GenerateExportFromLibrary(seenMetadataReferences, export.Library);
  }
-
- // Source and analyzer references are not transitive
- if (library.Parents.Contains(_rootProject))
+ else
  {
- sourceReferences.AddRange(libraryExport.SourceReferences);
- analyzerReferences.AddRange(libraryExport.AnalyzerReferences);
+ refreshedCache[index++] = export;
  }
 
- var builder = LibraryExportBuilder.Create(library);
- if (_runtime != null && _runtimeFallbacks != null)
+ foreach (var reference in export.CompilationAssemblies)
  {
- // For portable apps that are built with runtime trimming we replace RuntimeAssemblyGroups and NativeLibraryGroups
- // with single default group that contains asset specific to runtime we are trimming for
- // based on runtime fallback list
- builder.WithRuntimeAssemblyGroups(TrimAssetGroups(libraryExport.RuntimeAssemblyGroups, _runtimeFallbacks));
- builder.WithNativeLibraryGroups(TrimAssetGroups(libraryExport.NativeLibraryGroups, _runtimeFallbacks));
+ seenMetadataReferences.Add(reference.Name);
  }
- else
+ }
+
+ return refreshedCache;
+ }
+
+ private IEnumerable<LibraryExport> CalculateAllExports()
+ {
+ var seenMetadataReferences = new HashSet<string>();
+
+ // Iterate over libraries in the library manager
+ foreach (var library in LibraryManager.GetLibraries())
+ {
+ yield return GenerateExportFromLibrary(seenMetadataReferences, library);
+ }
+ }
+
+ private LibraryExport GenerateExportFromLibrary(
+ HashSet<string> seenMetadataReferences, 
+ LibraryDescription library)
+ {
+ var compilationAssemblies = new List<LibraryAsset>();
+ var sourceReferences = new List<LibraryAsset>();
+ var analyzerReferences = new List<AnalyzerReference>();
+ var libraryExport = GetExport(library);
+
+ // We need to filter out source references from non-root libraries,
+ // so we rebuild the library export
+ foreach (var reference in libraryExport.CompilationAssemblies)
+ {
+ if (seenMetadataReferences.Add(reference.Name))
  {
- builder.WithRuntimeAssemblyGroups(libraryExport.RuntimeAssemblyGroups);
- builder.WithNativeLibraryGroups(libraryExport.NativeLibraryGroups);
+ compilationAssemblies.Add(reference);
  }
+ }
 
- yield return builder
- .WithCompilationAssemblies(compilationAssemblies)
- .WithSourceReferences(sourceReferences)
- .WithRuntimeAssets(libraryExport.RuntimeAssets)
- .WithEmbedddedResources(libraryExport.EmbeddedResources)
- .WithAnalyzerReference(analyzerReferences)
- .WithResourceAssemblies(libraryExport.ResourceAssemblies)
- .Build();
+ // Source and analyzer references are not transitive
+ if (library.Parents.Contains(_rootProject))
+ {
+ sourceReferences.AddRange(libraryExport.SourceReferences);
+ analyzerReferences.AddRange(libraryExport.AnalyzerReferences);
+ }
+
+ var builder = LibraryExportBuilder.Create(library);
+ if (_runtime != null && _runtimeFallbacks != null)
+ {
+ // For portable apps that are built with runtime trimming we replace RuntimeAssemblyGroups and NativeLibraryGroups
+ // with single default group that contains asset specific to runtime we are trimming for
+ // based on runtime fallback list
+ builder.WithRuntimeAssemblyGroups(TrimAssetGroups(libraryExport.RuntimeAssemblyGroups, _runtimeFallbacks));
+ builder.WithNativeLibraryGroups(TrimAssetGroups(libraryExport.NativeLibraryGroups, _runtimeFallbacks));
  }
+ else
+ {
+ builder.WithRuntimeAssemblyGroups(libraryExport.RuntimeAssemblyGroups);
+ builder.WithNativeLibraryGroups(libraryExport.NativeLibraryGroups);
+ }
+
+ return builder
+ .WithCompilationAssemblies(compilationAssemblies)
+ .WithSourceReferences(sourceReferences)
+ .WithRuntimeAssets(libraryExport.RuntimeAssets)
+ .WithEmbedddedResources(libraryExport.EmbeddedResources)
+ .WithAnalyzerReference(analyzerReferences)
+ .WithResourceAssemblies(libraryExport.ResourceAssemblies)
+ .Build();
  }
 
  private IEnumerable<LibraryAssetGroup> TrimAssetGroups(IEnumerable<LibraryAssetGroup> runtimeAssemblyGroups,

src/Microsoft.DotNet.ProjectModel/Files/PatternGroup.cs

@@ -8,10 +8,15 @@
 using Microsoft.DotNet.ProjectModel.FileSystemGlobbing;
 using Newtonsoft.Json.Linq;
 
+using FourStringTuple = System.Tuple<string, string, string, string>;
+
 namespace Microsoft.DotNet.ProjectModel.Files
 {
  public class PatternGroup
  {
+ private static readonly Dictionary<FourStringTuple, IEnumerable<string>> s_resolvedFilesCache = 
+ new Dictionary<FourStringTuple, IEnumerable<string>>();
+
  private readonly List<PatternGroup> _excludeGroups = new List<PatternGroup>();
  private readonly Matcher _matcher = new Matcher();
 
@@ -80,15 +85,47 @@ public PatternGroup ExcludeGroup(PatternGroup group)
  return this;
  }
 
- public IEnumerable<string> SearchFiles(string rootPath)
+ public IEnumerable<string> SearchFiles(string rootDirectory)
+ {
+ var patternUnionKey = new FourStringTuple(rootDirectory, 
+ (IncludePatterns.Any() ? string.Join(", ", IncludePatterns): ""),
+ (IncludeLiterals.Any() ? string.Join(", ", IncludeLiterals) : ""),
+ (ExcludePatterns.Any() ? string.Join(", ", ExcludePatterns) : ""));
+
+ IEnumerable<string> resolvedFiles;
+ lock (s_resolvedFilesCache)
+ {
+ if (s_resolvedFilesCache.TryGetValue(patternUnionKey, out resolvedFiles))
+ {
+ return resolvedFiles;
+ }
+ }
+
+ resolvedFiles = ResolveFilesFromPatterns(rootDirectory, IncludePatterns, IncludeLiterals, ExcludePatterns);
+
+ lock (s_resolvedFilesCache)
+ {
+ s_resolvedFilesCache.Add(patternUnionKey, resolvedFiles);
+ }
+
+ return resolvedFiles;
+ }
+
+ private IEnumerable<string> ResolveFilesFromPatterns(
+ string rootDirectory, 
+ IEnumerable<string> includePatterns,
+ IEnumerable<string> includeLiterals,
+ IEnumerable<string> excludePatterns)
  {
+ IEnumerable<string> resolvedFiles;
+
  // literal included files are added at the last, but the search happens early
  // so as to make the process fail early in case there is missing file. fail early
  // helps to avoid unnecessary globing for performance optimization
  var literalIncludedFiles = new List<string>();
  foreach (var literalRelativePath in IncludeLiterals)
  {
- var fullPath = Path.GetFullPath(Path.Combine(rootPath, literalRelativePath));
+ var fullPath = Path.GetFullPath(Path.Combine(rootDirectory, literalRelativePath));
 
  if (!File.Exists(fullPath))
  {
@@ -100,24 +137,33 @@ public IEnumerable<string> SearchFiles(string rootPath)
  }
 
  // globing files
- var globbingResults = _matcher.GetResultsInFullPath(rootPath);
+ var globbingResults = _matcher.GetResultsInFullPath(rootDirectory);
 
  // if there is no results generated in globing, skip excluding other groups 
  // for performance optimization.
  if (globbingResults.Any())
  {
  foreach (var group in _excludeGroups)
  {
- globbingResults = globbingResults.Except(group.SearchFiles(rootPath));
+ globbingResults = globbingResults.Except(group.SearchFiles(rootDirectory));
  }
  }
 
- return globbingResults.Concat(literalIncludedFiles).Distinct();
+ resolvedFiles = globbingResults.Concat(literalIncludedFiles).Distinct();
+ return resolvedFiles;
  }
 
  public override string ToString()
  {
  return string.Format("Pattern group: Literals [{0}] Includes [{1}] Excludes [{2}]", string.Join(", ", IncludeLiterals), string.Join(", ", IncludePatterns), string.Join(", ", ExcludePatterns));
  }
+
+ public static void ClearCache()
+ {
+ if (s_resolvedFilesCache != null)
+ {
+ s_resolvedFilesCache.Clear();
+ }
+ }
  }
 }

src/Microsoft.DotNet.ProjectModel/ProjectContext.cs

@@ -14,6 +14,9 @@ namespace Microsoft.DotNet.ProjectModel
 {
  public class ProjectContext
  {
+ private readonly Dictionary<Tuple<string, string, string>, LibraryExporter> _cachedExporters = 
+ new Dictionary<Tuple<string, string, string>, LibraryExporter>();
+
  private string[] _runtimeFallbacks;
 
  public ProjectContextIdentity Identity { get; }
@@ -71,18 +74,34 @@ internal ProjectContext(
 
  public LibraryExporter CreateExporter(string configuration, string buildBasePath = null)
  {
+ LibraryExporter exporter;
+ var libraryExporterCacheKey = Tuple.Create(
+ configuration ?? "", 
+ buildBasePath ?? "",
+ RootDirectory);
+
+ if (_cachedExporters.TryGetValue(libraryExporterCacheKey, out exporter))
+ {
+ return exporter;
+ }
+
  if (IsPortable && RuntimeIdentifier != null && _runtimeFallbacks == null)
  {
  var graph = RuntimeGraphCollector.Collect(LibraryManager.GetLibraries());
  _runtimeFallbacks = graph.ExpandRuntime(RuntimeIdentifier).ToArray();
  }
- return new LibraryExporter(RootProject,
+
+ exporter = new LibraryExporter(RootProject,
  LibraryManager,
  configuration,
  RuntimeIdentifier,
  _runtimeFallbacks,
  buildBasePath,
  RootDirectory);
+
+ _cachedExporters[libraryExporterCacheKey] = exporter;
+
+ return exporter;
  }
 
  /// <summary>

src/Microsoft.DotNet.Cli.Utils/Tracing/PerfTraceOutput.cs

@@ -50,7 +50,8 @@ private static void FormatEventTimeStat(StringBuilder builder, PerfTraceEvent e,
  AppendTime(builder, e.Duration.TotalSeconds / root.Duration.TotalSeconds, 0.2);
  }
  AppendTime(builder, e.Duration.TotalSeconds / parent?.Duration.TotalSeconds, 0.5);
- builder.Append($"{e.Duration.ToString("ss\\.fff\\s").Blue()}]");
+ builder.Append($"{(int)e.Duration.TotalSeconds}.{e.Duration.Milliseconds:000}s".Blue());
+ builder.Append("]");
  }
 
  private static void AppendTime(StringBuilder builder, double? percent, double treshold)

src/Microsoft.DotNet.ProjectModel/Compilation/LibraryExporter.cs

@@ -25,6 +25,8 @@ public class LibraryExporter
  private readonly string _buildBasePath;
  private readonly string _solutionRootPath;
 
+ private List<LibraryExport> _cachedExports;
+
  public LibraryExporter(ProjectDescription rootProject,
  LibraryManager manager,
  string configuration,
@@ -84,62 +86,112 @@ public IEnumerable<LibraryExport> GetDependencies(LibraryType type)
  /// </summary>
  private IEnumerable<LibraryExport> ExportLibraries(Func<LibraryDescription, bool> condition)
  {
- var seenMetadataReferences = new HashSet<string>();
+ // Project Exports cannot be cached because the binding redirect file
+ // for desktop apps is not added to runtimeassets of the project
+ // until after the project is built.
+ var cache = GetCacheWithRefreshedProjectExports();
 
- // Iterate over libraries in the library manager
- foreach (var library in LibraryManager.GetLibraries())
+ foreach (var export in cache)
  {
- if (!condition(library))
+ if (!condition(export.Library))
  {
  continue;
  }
+ yield return export;
+ }
+ }
 
- var compilationAssemblies = new List<LibraryAsset>();
- var sourceReferences = new List<LibraryAsset>();
- var analyzerReferences = new List<AnalyzerReference>();
- var libraryExport = GetExport(library);
+ private IEnumerable<LibraryExport> GetCacheWithRefreshedProjectExports()
+ {
+ if (_cachedExports == null)
+ {
+ _cachedExports = CalculateAllExports().ToList();
+ }
+
+ var seenMetadataReferences = new HashSet<string>();
+ var refreshedCache = new LibraryExport[_cachedExports.Count()];
 
- // We need to filter out source references from non-root libraries,
- // so we rebuild the library export
- foreach (var reference in libraryExport.CompilationAssemblies)
+ int index = 0;
+ foreach (var export in _cachedExports)
+ {
+ if (Equals(export.Library.Identity.Type, LibraryType.Project))
  {
- if (seenMetadataReferences.Add(reference.Name))
- {
- compilationAssemblies.Add(reference);
- }
+ refreshedCache[index++] = GenerateExportFromLibrary(seenMetadataReferences, export.Library);
  }
-
- // Source and analyzer references are not transitive
- if (library.Parents.Contains(_rootProject))
+ else
  {
- sourceReferences.AddRange(libraryExport.SourceReferences);
- analyzerReferences.AddRange(libraryExport.AnalyzerReferences);
+ refreshedCache[index++] = export;
  }
 
- var builder = LibraryExportBuilder.Create(library);
- if (_runtime != null && _runtimeFallbacks != null)
+ foreach (var reference in export.CompilationAssemblies)
  {
- // For portable apps that are built with runtime trimming we replace RuntimeAssemblyGroups and NativeLibraryGroups
- // with single default group that contains asset specific to runtime we are trimming for
- // based on runtime fallback list
- builder.WithRuntimeAssemblyGroups(TrimAssetGroups(libraryExport.RuntimeAssemblyGroups, _runtimeFallbacks));
- builder.WithNativeLibraryGroups(TrimAssetGroups(libraryExport.NativeLibraryGroups, _runtimeFallbacks));
+ seenMetadataReferences.Add(reference.Name);
  }
- else
+ }
+
+ return refreshedCache;
+ }
+
+ private IEnumerable<LibraryExport> CalculateAllExports()
+ {
+ var seenMetadataReferences = new HashSet<string>();
+
+ // Iterate over libraries in the library manager
+ foreach (var library in LibraryManager.GetLibraries())
+ {
+ yield return GenerateExportFromLibrary(seenMetadataReferences, library);
+ }
+ }
+
+ private LibraryExport GenerateExportFromLibrary(
+ HashSet<string> seenMetadataReferences, 
+ LibraryDescription library)
+ {
+ var compilationAssemblies = new List<LibraryAsset>();
+ var sourceReferences = new List<LibraryAsset>();
+ var analyzerReferences = new List<AnalyzerReference>();
+ var libraryExport = GetExport(library);
+
+ // We need to filter out source references from non-root libraries,
+ // so we rebuild the library export
+ foreach (var reference in libraryExport.CompilationAssemblies)
+ {
+ if (seenMetadataReferences.Add(reference.Name))
  {
- builder.WithRuntimeAssemblyGroups(libraryExport.RuntimeAssemblyGroups);
- builder.WithNativeLibraryGroups(libraryExport.NativeLibraryGroups);
+ compilationAssemblies.Add(reference);
  }
+ }
 
- yield return builder
- .WithCompilationAssemblies(compilationAssemblies)
- .WithSourceReferences(sourceReferences)
- .WithRuntimeAssets(libraryExport.RuntimeAssets)
- .WithEmbedddedResources(libraryExport.EmbeddedResources)
- .WithAnalyzerReference(analyzerReferences)
- .WithResourceAssemblies(libraryExport.ResourceAssemblies)
- .Build();
+ // Source and analyzer references are not transitive
+ if (library.Parents.Contains(_rootProject))
+ {
+ sourceReferences.AddRange(libraryExport.SourceReferences);
+ analyzerReferences.AddRange(libraryExport.AnalyzerReferences);
+ }
+
+ var builder = LibraryExportBuilder.Create(library);
+ if (_runtime != null && _runtimeFallbacks != null)
+ {
+ // For portable apps that are built with runtime trimming we replace RuntimeAssemblyGroups and NativeLibraryGroups
+ // with single default group that contains asset specific to runtime we are trimming for
+ // based on runtime fallback list
+ builder.WithRuntimeAssemblyGroups(TrimAssetGroups(libraryExport.RuntimeAssemblyGroups, _runtimeFallbacks));
+ builder.WithNativeLibraryGroups(TrimAssetGroups(libraryExport.NativeLibraryGroups, _runtimeFallbacks));
  }
+ else
+ {
+ builder.WithRuntimeAssemblyGroups(libraryExport.RuntimeAssemblyGroups);
+ builder.WithNativeLibraryGroups(libraryExport.NativeLibraryGroups);
+ }
+
+ return builder
+ .WithCompilationAssemblies(compilationAssemblies)
+ .WithSourceReferences(sourceReferences)
+ .WithRuntimeAssets(libraryExport.RuntimeAssets)
+ .WithEmbedddedResources(libraryExport.EmbeddedResources)
+ .WithAnalyzerReference(analyzerReferences)
+ .WithResourceAssemblies(libraryExport.ResourceAssemblies)
+ .Build();
  }
 
  private IEnumerable<LibraryAssetGroup> TrimAssetGroups(IEnumerable<LibraryAssetGroup> runtimeAssemblyGroups,

src/Microsoft.DotNet.ProjectModel/Files/PatternGroup.cs

@@ -8,10 +8,15 @@
 using Microsoft.DotNet.ProjectModel.FileSystemGlobbing;
 using Newtonsoft.Json.Linq;
 
+using FourStringTuple = System.Tuple<string, string, string, string>;
+
 namespace Microsoft.DotNet.ProjectModel.Files
 {
  public class PatternGroup
  {
+ private static readonly Dictionary<FourStringTuple, IEnumerable<string>> s_resolvedFilesCache = 
+ new Dictionary<FourStringTuple, IEnumerable<string>>();
+
  private readonly List<PatternGroup> _excludeGroups = new List<PatternGroup>();
  private readonly Matcher _matcher = new Matcher();
 
@@ -80,15 +85,47 @@ public PatternGroup ExcludeGroup(PatternGroup group)
  return this;
  }
 
- public IEnumerable<string> SearchFiles(string rootPath)
+ public IEnumerable<string> SearchFiles(string rootDirectory)
+ {
+ var patternUnionKey = new FourStringTuple(rootDirectory, 
+ (IncludePatterns.Any() ? string.Join(", ", IncludePatterns): ""),
+ (IncludeLiterals.Any() ? string.Join(", ", IncludeLiterals) : ""),
+ (ExcludePatterns.Any() ? string.Join(", ", ExcludePatterns) : ""));
+
+ IEnumerable<string> resolvedFiles;
+ lock (s_resolvedFilesCache)
+ {
+ if (s_resolvedFilesCache.TryGetValue(patternUnionKey, out resolvedFiles))
+ {
+ return resolvedFiles;
+ }
+ }
+
+ resolvedFiles = ResolveFilesFromPatterns(rootDirectory, IncludePatterns, IncludeLiterals, ExcludePatterns);
+
+ lock (s_resolvedFilesCache)
+ {
+ s_resolvedFilesCache.Add(patternUnionKey, resolvedFiles);
+ }
+
+ return resolvedFiles;
+ }
+
+ private IEnumerable<string> ResolveFilesFromPatterns(
+ string rootDirectory, 
+ IEnumerable<string> includePatterns,
+ IEnumerable<string> includeLiterals,
+ IEnumerable<string> excludePatterns)
  {
+ IEnumerable<string> resolvedFiles;
+
  // literal included files are added at the last, but the search happens early
  // so as to make the process fail early in case there is missing file. fail early
  // helps to avoid unnecessary globing for performance optimization
  var literalIncludedFiles = new List<string>();
  foreach (var literalRelativePath in IncludeLiterals)
  {
- var fullPath = Path.GetFullPath(Path.Combine(rootPath, literalRelativePath));
+ var fullPath = Path.GetFullPath(Path.Combine(rootDirectory, literalRelativePath));
 
  if (!File.Exists(fullPath))
  {
@@ -100,24 +137,33 @@ public IEnumerable<string> SearchFiles(string rootPath)
  }
 
  // globing files
- var globbingResults = _matcher.GetResultsInFullPath(rootPath);
+ var globbingResults = _matcher.GetResultsInFullPath(rootDirectory);
 
  // if there is no results generated in globing, skip excluding other groups 
  // for performance optimization.
  if (globbingResults.Any())
  {
  foreach (var group in _excludeGroups)
  {
- globbingResults = globbingResults.Except(group.SearchFiles(rootPath));
+ globbingResults = globbingResults.Except(group.SearchFiles(rootDirectory));
  }
  }
 
- return globbingResults.Concat(literalIncludedFiles).Distinct();
+ resolvedFiles = globbingResults.Concat(literalIncludedFiles).Distinct();
+ return resolvedFiles;
  }
 
  public override string ToString()
  {
  return string.Format("Pattern group: Literals [{0}] Includes [{1}] Excludes [{2}]", string.Join(", ", IncludeLiterals), string.Join(", ", IncludePatterns), string.Join(", ", ExcludePatterns));
  }
+
+ public static void ClearCache()
+ {
+ if (s_resolvedFilesCache != null)
+ {
+ s_resolvedFilesCache.Clear();
+ }
+ }
  }
 }

src/Microsoft.DotNet.ProjectModel/ProjectContext.cs

@@ -14,6 +14,9 @@ namespace Microsoft.DotNet.ProjectModel
 {
  public class ProjectContext
  {
+ private readonly Dictionary<Tuple<string, string, string>, LibraryExporter> _cachedExporters = 
+ new Dictionary<Tuple<string, string, string>, LibraryExporter>();
+
  private string[] _runtimeFallbacks;
 
  public ProjectContextIdentity Identity { get; }
@@ -71,18 +74,34 @@ internal ProjectContext(
 
  public LibraryExporter CreateExporter(string configuration, string buildBasePath = null)
  {
+ LibraryExporter exporter;
+ var libraryExporterCacheKey = Tuple.Create(
+ configuration ?? "", 
+ buildBasePath ?? "",
+ RootDirectory);
+
+ if (_cachedExporters.TryGetValue(libraryExporterCacheKey, out exporter))
+ {
+ return exporter;
+ }
+
  if (IsPortable && RuntimeIdentifier != null && _runtimeFallbacks == null)
  {
  var graph = RuntimeGraphCollector.Collect(LibraryManager.GetLibraries());
  _runtimeFallbacks = graph.ExpandRuntime(RuntimeIdentifier).ToArray();
  }
- return new LibraryExporter(RootProject,
+
+ exporter = new LibraryExporter(RootProject,
  LibraryManager,
  configuration,
  RuntimeIdentifier,
  _runtimeFallbacks,
  buildBasePath,
  RootDirectory);
+
+ _cachedExporters[libraryExporterCacheKey] = exporter;
+
+ return exporter;
  }
 
  /// <summary>

src/Microsoft.DotNet.Cli.Utils/Tracing/PerfTraceOutput.cs

@@ -50,7 +50,8 @@ private static void FormatEventTimeStat(StringBuilder builder, PerfTraceEvent e,
  AppendTime(builder, e.Duration.TotalSeconds / root.Duration.TotalSeconds, 0.2);
  }
  AppendTime(builder, e.Duration.TotalSeconds / parent?.Duration.TotalSeconds, 0.5);
- builder.Append($"{e.Duration.ToString("ss\\.fff\\s").Blue()}]");
+ builder.Append($"{(int)e.Duration.TotalSeconds}.{e.Duration.Milliseconds:000}s".Blue());
+ builder.Append("]");
  }
 
  private static void AppendTime(StringBuilder builder, double? percent, double treshold)

src/Microsoft.DotNet.ProjectModel/Compilation/LibraryExporter.cs

@@ -25,6 +25,8 @@ public class LibraryExporter
  private readonly string _buildBasePath;
  private readonly string _solutionRootPath;
 
+ private List<LibraryExport> _cachedExports;
+
  public LibraryExporter(ProjectDescription rootProject,
  LibraryManager manager,
  string configuration,
@@ -84,62 +86,112 @@ public IEnumerable<LibraryExport> GetDependencies(LibraryType type)
  /// </summary>
  private IEnumerable<LibraryExport> ExportLibraries(Func<LibraryDescription, bool> condition)
  {
- var seenMetadataReferences = new HashSet<string>();
+ // Project Exports cannot be cached because the binding redirect file
+ // for desktop apps is not added to runtimeassets of the project
+ // until after the project is built.
+ var cache = GetCacheWithRefreshedProjectExports();
 
- // Iterate over libraries in the library manager
- foreach (var library in LibraryManager.GetLibraries())
+ foreach (var export in cache)
  {
- if (!condition(library))
+ if (!condition(export.Library))
  {
  continue;
  }
+ yield return export;
+ }
+ }
 
- var compilationAssemblies = new List<LibraryAsset>();
- var sourceReferences = new List<LibraryAsset>();
- var analyzerReferences = new List<AnalyzerReference>();
- var libraryExport = GetExport(library);
+ private IEnumerable<LibraryExport> GetCacheWithRefreshedProjectExports()
+ {
+ if (_cachedExports == null)
+ {
+ _cachedExports = CalculateAllExports().ToList();
+ }
+
+ var seenMetadataReferences = new HashSet<string>();
+ var refreshedCache = new LibraryExport[_cachedExports.Count()];
 
- // We need to filter out source references from non-root libraries,
- // so we rebuild the library export
- foreach (var reference in libraryExport.CompilationAssemblies)
+ int index = 0;
+ foreach (var export in _cachedExports)
+ {
+ if (Equals(export.Library.Identity.Type, LibraryType.Project))
  {
- if (seenMetadataReferences.Add(reference.Name))
- {
- compilationAssemblies.Add(reference);
- }
+ refreshedCache[index++] = GenerateExportFromLibrary(seenMetadataReferences, export.Library);
  }
-
- // Source and analyzer references are not transitive
- if (library.Parents.Contains(_rootProject))
+ else
  {
- sourceReferences.AddRange(libraryExport.SourceReferences);
- analyzerReferences.AddRange(libraryExport.AnalyzerReferences);
+ refreshedCache[index++] = export;
  }
 
- var builder = LibraryExportBuilder.Create(library);
- if (_runtime != null && _runtimeFallbacks != null)
+ foreach (var reference in export.CompilationAssemblies)
  {
- // For portable apps that are built with runtime trimming we replace RuntimeAssemblyGroups and NativeLibraryGroups
- // with single default group that contains asset specific to runtime we are trimming for
- // based on runtime fallback list
- builder.WithRuntimeAssemblyGroups(TrimAssetGroups(libraryExport.RuntimeAssemblyGroups, _runtimeFallbacks));
- builder.WithNativeLibraryGroups(TrimAssetGroups(libraryExport.NativeLibraryGroups, _runtimeFallbacks));
+ seenMetadataReferences.Add(reference.Name);
  }
- else
+ }
+
+ return refreshedCache;
+ }
+
+ private IEnumerable<LibraryExport> CalculateAllExports()
+ {
+ var seenMetadataReferences = new HashSet<string>();
+
+ // Iterate over libraries in the library manager
+ foreach (var library in LibraryManager.GetLibraries())
+ {
+ yield return GenerateExportFromLibrary(seenMetadataReferences, library);
+ }
+ }
+
+ private LibraryExport GenerateExportFromLibrary(
+ HashSet<string> seenMetadataReferences, 
+ LibraryDescription library)
+ {
+ var compilationAssemblies = new List<LibraryAsset>();
+ var sourceReferences = new List<LibraryAsset>();
+ var analyzerReferences = new List<AnalyzerReference>();
+ var libraryExport = GetExport(library);
+
+ // We need to filter out source references from non-root libraries,
+ // so we rebuild the library export
+ foreach (var reference in libraryExport.CompilationAssemblies)
+ {
+ if (seenMetadataReferences.Add(reference.Name))
  {
- builder.WithRuntimeAssemblyGroups(libraryExport.RuntimeAssemblyGroups);
- builder.WithNativeLibraryGroups(libraryExport.NativeLibraryGroups);
+ compilationAssemblies.Add(reference);
  }
+ }
 
- yield return builder
- .WithCompilationAssemblies(compilationAssemblies)
- .WithSourceReferences(sourceReferences)
- .WithRuntimeAssets(libraryExport.RuntimeAssets)
- .WithEmbedddedResources(libraryExport.EmbeddedResources)
- .WithAnalyzerReference(analyzerReferences)
- .WithResourceAssemblies(libraryExport.ResourceAssemblies)
- .Build();
+ // Source and analyzer references are not transitive
+ if (library.Parents.Contains(_rootProject))
+ {
+ sourceReferences.AddRange(libraryExport.SourceReferences);
+ analyzerReferences.AddRange(libraryExport.AnalyzerReferences);
+ }
+
+ var builder = LibraryExportBuilder.Create(library);
+ if (_runtime != null && _runtimeFallbacks != null)
+ {
+ // For portable apps that are built with runtime trimming we replace RuntimeAssemblyGroups and NativeLibraryGroups
+ // with single default group that contains asset specific to runtime we are trimming for
+ // based on runtime fallback list
+ builder.WithRuntimeAssemblyGroups(TrimAssetGroups(libraryExport.RuntimeAssemblyGroups, _runtimeFallbacks));
+ builder.WithNativeLibraryGroups(TrimAssetGroups(libraryExport.NativeLibraryGroups, _runtimeFallbacks));
  }
+ else
+ {
+ builder.WithRuntimeAssemblyGroups(libraryExport.RuntimeAssemblyGroups);
+ builder.WithNativeLibraryGroups(libraryExport.NativeLibraryGroups);
+ }
+
+ return builder
+ .WithCompilationAssemblies(compilationAssemblies)
+ .WithSourceReferences(sourceReferences)
+ .WithRuntimeAssets(libraryExport.RuntimeAssets)
+ .WithEmbedddedResources(libraryExport.EmbeddedResources)
+ .WithAnalyzerReference(analyzerReferences)
+ .WithResourceAssemblies(libraryExport.ResourceAssemblies)
+ .Build();
  }
 
  private IEnumerable<LibraryAssetGroup> TrimAssetGroups(IEnumerable<LibraryAssetGroup> runtimeAssemblyGroups,

src/Microsoft.DotNet.ProjectModel/Files/PatternGroup.cs

@@ -8,10 +8,15 @@
 using Microsoft.DotNet.ProjectModel.FileSystemGlobbing;
 using Newtonsoft.Json.Linq;
 
+using FourStringTuple = System.Tuple<string, string, string, string>;
+
 namespace Microsoft.DotNet.ProjectModel.Files
 {
  public class PatternGroup
  {
+ private static readonly Dictionary<FourStringTuple, IEnumerable<string>> s_resolvedFilesCache = 
+ new Dictionary<FourStringTuple, IEnumerable<string>>();
+
  private readonly List<PatternGroup> _excludeGroups = new List<PatternGroup>();
  private readonly Matcher _matcher = new Matcher();
 
@@ -80,15 +85,47 @@ public PatternGroup ExcludeGroup(PatternGroup group)
  return this;
  }
 
- public IEnumerable<string> SearchFiles(string rootPath)
+ public IEnumerable<string> SearchFiles(string rootDirectory)
+ {
+ var patternUnionKey = new FourStringTuple(rootDirectory, 
+ (IncludePatterns.Any() ? string.Join(", ", IncludePatterns): ""),
+ (IncludeLiterals.Any() ? string.Join(", ", IncludeLiterals) : ""),
+ (ExcludePatterns.Any() ? string.Join(", ", ExcludePatterns) : ""));
+
+ IEnumerable<string> resolvedFiles;
+ lock (s_resolvedFilesCache)
+ {
+ if (s_resolvedFilesCache.TryGetValue(patternUnionKey, out resolvedFiles))
+ {
+ return resolvedFiles;
+ }
+ }
+
+ resolvedFiles = ResolveFilesFromPatterns(rootDirectory, IncludePatterns, IncludeLiterals, ExcludePatterns);
+
+ lock (s_resolvedFilesCache)
+ {
+ s_resolvedFilesCache.Add(patternUnionKey, resolvedFiles);
+ }
+
+ return resolvedFiles;
+ }
+
+ private IEnumerable<string> ResolveFilesFromPatterns(
+ string rootDirectory, 
+ IEnumerable<string> includePatterns,
+ IEnumerable<string> includeLiterals,
+ IEnumerable<string> excludePatterns)
  {
+ IEnumerable<string> resolvedFiles;
+
  // literal included files are added at the last, but the search happens early
  // so as to make the process fail early in case there is missing file. fail early
  // helps to avoid unnecessary globing for performance optimization
  var literalIncludedFiles = new List<string>();
  foreach (var literalRelativePath in IncludeLiterals)
  {
- var fullPath = Path.GetFullPath(Path.Combine(rootPath, literalRelativePath));
+ var fullPath = Path.GetFullPath(Path.Combine(rootDirectory, literalRelativePath));
 
  if (!File.Exists(fullPath))
  {
@@ -100,24 +137,33 @@ public IEnumerable<string> SearchFiles(string rootPath)
  }
 
  // globing files
- var globbingResults = _matcher.GetResultsInFullPath(rootPath);
+ var globbingResults = _matcher.GetResultsInFullPath(rootDirectory);
 
  // if there is no results generated in globing, skip excluding other groups 
  // for performance optimization.
  if (globbingResults.Any())
  {
  foreach (var group in _excludeGroups)
  {
- globbingResults = globbingResults.Except(group.SearchFiles(rootPath));
+ globbingResults = globbingResults.Except(group.SearchFiles(rootDirectory));
  }
  }
 
- return globbingResults.Concat(literalIncludedFiles).Distinct();
+ resolvedFiles = globbingResults.Concat(literalIncludedFiles).Distinct();
+ return resolvedFiles;
  }
 
  public override string ToString()
  {
  return string.Format("Pattern group: Literals [{0}] Includes [{1}] Excludes [{2}]", string.Join(", ", IncludeLiterals), string.Join(", ", IncludePatterns), string.Join(", ", ExcludePatterns));
  }
+
+ public static void ClearCache()
+ {
+ if (s_resolvedFilesCache != null)
+ {
+ s_resolvedFilesCache.Clear();
+ }
+ }
  }
 }

src/Microsoft.DotNet.ProjectModel/ProjectContext.cs

@@ -14,6 +14,9 @@ namespace Microsoft.DotNet.ProjectModel
 {
  public class ProjectContext
  {
+ private readonly Dictionary<Tuple<string, string, string>, LibraryExporter> _cachedExporters = 
+ new Dictionary<Tuple<string, string, string>, LibraryExporter>();
+
  private string[] _runtimeFallbacks;
 
  public ProjectContextIdentity Identity { get; }
@@ -71,18 +74,34 @@ internal ProjectContext(
 
  public LibraryExporter CreateExporter(string configuration, string buildBasePath = null)
  {
+ LibraryExporter exporter;
+ var libraryExporterCacheKey = Tuple.Create(
+ configuration ?? "", 
+ buildBasePath ?? "",
+ RootDirectory);
+
+ if (_cachedExporters.TryGetValue(libraryExporterCacheKey, out exporter))
+ {
+ return exporter;
+ }
+
  if (IsPortable && RuntimeIdentifier != null && _runtimeFallbacks == null)
  {
  var graph = RuntimeGraphCollector.Collect(LibraryManager.GetLibraries());
  _runtimeFallbacks = graph.ExpandRuntime(RuntimeIdentifier).ToArray();
  }
- return new LibraryExporter(RootProject,
+
+ exporter = new LibraryExporter(RootProject,
  LibraryManager,
  configuration,
  RuntimeIdentifier,
  _runtimeFallbacks,
  buildBasePath,
  RootDirectory);
+
+ _cachedExporters[libraryExporterCacheKey] = exporter;
+
+ return exporter;
  }
 
  /// <summary>