restore: trying out mmap-based file extraction

src/NuGet.Core/NuGet.Packaging/PackageArchiveReader.cs

@@ -157,6 +157,72 @@ protected override void Dispose(bool disposing)
             }
         }
 
+        /// <summary>
+        /// This class literally just exists so CopyToFile gets a file size
+        /// </summary>
+        private sealed class SizedArchiveEntryStream : Stream
+        {
+            private readonly Stream _inner;
+
+            private readonly long _size;
+
+            public SizedArchiveEntryStream(Stream inner, long size)
+            {
+                _inner = inner;
+                _size = size;
+            }
+
+            public override long Length { get => _size; }
+
+            public override bool CanRead => _inner.CanRead;
+
+            public override bool CanSeek => _inner.CanSeek;
+
+            public override bool CanWrite => _inner.CanWrite;
+
+            public override long Position { get => _inner.Position; set => _inner.Position = value; }
+
+            public override void Flush()
+            {
+                _inner.Flush();
+            }
+
+            public override int Read(byte[] buffer, int offset, int count)
+            {
+                return _inner.Read(buffer, offset, count);
+            }
+
+            public override long Seek(long offset, SeekOrigin origin)
+            {
+                return _inner.Seek(offset, origin);
+            }
+
+            public override void SetLength(long value)
+            {
+                _inner.SetLength(value);
+            }
+
+            public override void Write(byte[] buffer, int offset, int count)
+            {
+                _inner.Write(buffer, offset, count);
+            }
+
+            private bool _isDisposed;
+
+            protected override void Dispose(bool disposing)
+            {
+                if (!_isDisposed)
+                {
+                    if (disposing)
+                    {
+                        _inner.Dispose();
+                    }
+
+                    _isDisposed = true;
+                }
+            }
+        }
+
         public override IEnumerable<string> CopyFiles(
             string destination,
             IEnumerable<string> packageFiles,
@@ -191,8 +257,9 @@ public override IEnumerable<string> CopyFiles(
                 var targetFilePath = Path.Combine(destination, normalizedPath);
 
                 using (var stream = entry.Open())
+                using (var sizedStream = new SizedArchiveEntryStream(stream, entry.Length))
                 {
-                    var copiedFile = extractFile(packageFileName, targetFilePath, stream);
+                    var copiedFile = extractFile(packageFileName, targetFilePath, sizedStream);
                     if (copiedFile != null)
                     {
                         entry.UpdateFileTimeFromEntry(copiedFile, logger);

src/NuGet.Core/NuGet.Packaging/PackageExtraction/StreamExtensions.cs

@@ -1,12 +1,19 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
+using System;
 using System.IO;
+using System.IO.MemoryMappedFiles;
 
 namespace NuGet.Packaging
 {
     public static class StreamExtensions
     {
+        /**
+        Only files smaller than this value will be mmap'ed
+        */
+        private const long MAX_MMAP_SIZE = 10 * 1024 * 1024;
+
         public static string CopyToFile(this Stream inputStream, string fileFullPath)
         {
             if (Path.GetFileName(fileFullPath).Length == 0)
@@ -27,11 +34,38 @@ public static string CopyToFile(this Stream inputStream, string fileFullPath)
                 return fileFullPath;
             }
 
+            // For files of a certain size, we can do some Cleverness and mmap
+            // them instead of writing directly to disk. This can improve
+            // performance by a lot on some operating systems and hardware,
+            // particularly Windows
+            long? size = null;
+            try
+            {
+                size = inputStream.Length;
+            }
+            catch (NotSupportedException)
+            {
+                // If we can't get Length, just move on.
+            }
             using (var outputStream = NuGetExtractionFileIO.CreateFile(fileFullPath))
             {
-                inputStream.CopyTo(outputStream);
+                if (size > 0 && size <= MAX_MMAP_SIZE)
+                {
+                    // NOTE: Linux can't create a mmf from outputStream, so we
+                    // need to close the file (which now has the desired
+                    // perms), and then re-open it as a memory-mapped file.
+                    outputStream.Dispose();
+                    using (MemoryMappedFile mmf = MemoryMappedFile.CreateFromFile(fileFullPath, FileMode.Open, mapName: null, (long)size))
+                    using (MemoryMappedViewStream mmstream = mmf.CreateViewStream())
+                    {
+                        inputStream.CopyTo(mmstream);
+                    }
+                }
+                else
+                {
+                    inputStream.CopyTo(outputStream);
+                }
             }
-
             return fileFullPath;
         }
     }