Tweaks to caching/prefetching.

Author: adam-azarchs

PhotoCull/PhotoCullWindow.xaml.cs

@@ -231,6 +231,7 @@ private async Task reject(bool first) {
                 photos.Move(goodIndex, 0);
             }
             good.MarkedForDeletion = false;
+            reject.Uncache();
             this.deleteButton.IsEnabled = true;
             this.photoList.SelectedValue = null;
             this.prefetch();

PhotoTagger.Imaging/ImageLoadManager.cs

@@ -178,28 +178,29 @@ private async static Task setImage(Photo photo, Photo.Metadata metadata, bool mu
                 if (photo.Disposed) {
                     return;
                 }
-                var data = await photo.Dispatcher.InvokeAsync(
+                var (mmap, fullImageStream) = await photo.Dispatcher.InvokeAsync(
                     () => (photo.mmap, photo.fullImageStream));
-                if (data.mmap == null) {
+                if (mmap == null) {
                     // disposed
                     return;
                 }
-                if (data.fullImageStream == null) {
-                    data.fullImageStream = new UnsafeMemoryMapStream(
-                        data.mmap.CreateViewAccessor(0, 0, MemoryMappedFileAccess.Read),
+                if (fullImageStream == null) {
+                    fullImageStream = new UnsafeMemoryMapStream(
+                        mmap.CreateViewAccessor(0, 0, MemoryMappedFileAccess.Read),
                         FileAccess.Read);
                     await photo.Dispatcher.InvokeAsync(() => {
-                        var p = Interlocked.CompareExchange(ref photo.fullImageStream, data.fullImageStream, null);
+                        var p = Interlocked.CompareExchange(
+                            ref photo.fullImageStream, fullImageStream, null);
                         if (p != null) {
-                            data.fullImageStream.Dispose();
-                            data.fullImageStream = p;
+                            fullImageStream.Dispose();
+                            fullImageStream = p;
                         }
                     });
                 }
                 var img = new BitmapImage();
                 try {
                     img.BeginInit();
-                    img.StreamSource = data.fullImageStream.Stream;
+                    img.StreamSource = fullImageStream.Stream;
                     makeFullImage(metadata, img);
                 } catch (Exception ex) {
                     await photo.Dispatcher.InvokeAsync(() => {
@@ -219,6 +220,10 @@ await photo.Dispatcher.InvokeAsync(() => {
                     photo.loadLock.Release();
                 }
             }
+            // Now is a good time to do a gen-0 GC to make sure the image we
+            // just loaded gets promoted to at least gen1 before its caching
+            // expires.
+            GC.Collect(0);
         }
 
         /// <summary>
@@ -249,7 +254,6 @@ private static void makeFullImage(Photo.Metadata metadata, BitmapImage img) {
                 }
             }
             img.CacheOption = BitmapCacheOption.None;
-            img.CreateOptions = BitmapCreateOptions.DelayCreation;
             img.Rotation = Exif.OrienationToRotation(metadata.Orientation);
             img.EndInit();
             img.Freeze();

PhotoTagger.Imaging/Photo.cs

@@ -20,26 +20,39 @@ public Photo(string f) {
         private int fullIsLoading = 0;
 
         private static CacheItemPolicy cachePolicy = new CacheItemPolicy() {
-            SlidingExpiration = TimeSpan.FromSeconds(10),
+            SlidingExpiration = TimeSpan.FromSeconds(15),
         };
 
         /// <summary>
         /// Begin the process of loading the full size image.
         /// </summary>
         public void Prefetch() {
+            BitmapImage img = null;
             var imageRef = this.fullImageRef;
             if (this.setFrom == null ||
                 this.loader == null) {
                 // Queue this for prefetch as soon as the metadata is loaded.
                 Interlocked.CompareExchange(ref this.fullIsLoading, -1, 0);
             } else if (!this.Disposed && (
-                 imageRef == null ||
-                 !imageRef.TryGetTarget(out BitmapImage _)) &&
-                 Interlocked.Exchange(ref this.fullIsLoading, 1) <= 0) {
+                           imageRef == null ||
+                           !imageRef.TryGetTarget(out img)) &&
+                       Interlocked.Exchange(ref this.fullIsLoading, 1) <= 0) {
                 this.loader?.EnqueueFullSizeRead(this, this.setFrom);
+            } else if (img != null) {
+                MemoryCache.Default.Set(
+                        this.FileName,
+                        img,
+                        cachePolicy);
             }
         }
 
+        /// <summary>
+        /// Remove this image from the cache.
+        /// </summary>
+        public void Uncache() {
+            MemoryCache.Default.Remove(this.FileName);
+        }
+
         public BitmapImage FullImage {
             get {
                 var imageRef = this.fullImageRef;