bug#74537: [PATCH] An on-disk image modification does a cache miss

bug#74537: [PATCH] An on-disk image modification does a cache miss

[Manuel Giraud via Bug reports for GNU Emacs, the Swiss army knife of text editors]

[-- Attachment #1: Type: text/plain, Size: 739 bytes --]

Tags: patch

Hi,

With this patch, when an image file is modified on disk, the associated
cache image is invalidated and re-read from disk.

In GNU Emacs 31.0.50 (build 4, x86_64-unknown-openbsd7.6, X toolkit) of
 2024-11-23 built on computer
Repository revision: 5072b6110b69a8ba0d42772b26533dcdc39ffdfc
Repository branch: mgi/jpeg
Windowing system distributor 'The X.Org Foundation', version 11.0.12101014
System Description: OpenBSD computer 7.6 GENERIC.MP#437 amd64

Configured using:
 'configure CC=egcc CPPFLAGS=-I/usr/local/include
 LDFLAGS=-L/usr/local/lib MAKEINFO=gmakeinfo --prefix=/home/manuel/emacs
 --bindir=/home/manuel/bin --with-x-toolkit=lucid
 --with-toolkit-scroll-bars=no --without-cairo
 --without-compress-install'


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: 0001-An-on-disk-image-modification-does-a-cache-miss.patch --]
[-- Type: text/patch, Size: 3296 bytes --]

From 0b0e0cbc947e357c8053c2837622094b00a422d5 Mon Sep 17 00:00:00 2001
From: Manuel Giraud <manuel@ledu-giraud.fr>
Date: Mon, 25 Nov 2024 17:04:03 +0100
Subject: [PATCH] An on-disk image modification does a cache miss

* src/dispextern.h: Add modification time to an image.
* src/image.c (make_image): Get the modification time from the
image file.
(lookup_image): Make a modified image on disk results in a cache
miss.
* lisp/startup.el (fancy-splash-head): Remove a non full-path
image file spec (XXX is there more?).
---
 lisp/startup.el  |  2 +-
 src/dispextern.h |  4 ++++
 src/image.c      | 26 ++++++++++++++++++++++++++
 3 files changed, 31 insertions(+), 1 deletion(-)

diff --git a/lisp/startup.el b/lisp/startup.el
index 3436409a35e..42f6e70f05d 100644
--- a/lisp/startup.el
+++ b/lisp/startup.el
@@ -1957,7 +1957,7 @@ fancy-splash-image-file
 (defun fancy-splash-head ()
   "Insert the head part of the splash screen into the current buffer."
   (let* ((image-file (fancy-splash-image-file))
-	 (img (create-image image-file))
+         (img (create-image (image-search-load-path image-file)))
 	 (image-width (and img (car (image-size img))))
 	 (window-width (window-width)))
     (when img
diff --git a/src/dispextern.h b/src/dispextern.h
index 9df6eaf623a..0f91568db99 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -3170,6 +3170,10 @@ reset_mouse_highlight (Mouse_HLInfo *hlinfo)
      in prepare_image_for_display.  */
   struct timespec timestamp;
 
+  /* The modification time of the file of this image.  Set in
+     make_image.  */
+  struct timespec mtime;
+
   /* Pixmaps of the image.  */
   Emacs_Pixmap pixmap, mask;
 
diff --git a/src/image.c b/src/image.c
index db7f6acd171..c5bddaf5985 100644
--- a/src/image.c
+++ b/src/image.c
@@ -37,6 +37,7 @@ Copyright (C) 1989-2024 Free Software Foundation, Inc.
 #include <stdint.h>
 #include <c-ctype.h>
 #include <flexmember.h>
+#include <stat-time.h>
 
 #include "lisp.h"
 #include "frame.h"
@@ -1744,6 +1745,7 @@ make_image (Lisp_Object spec, EMACS_UINT hash)
 {
   struct image *img = xzalloc (sizeof *img);
   Lisp_Object file = image_spec_value (spec, QCfile, NULL);
+  struct stat st;
 
   eassert (valid_image_p (spec));
   img->dependencies = NILP (file) ? Qnil : list1 (file);
@@ -1754,6 +1756,9 @@ make_image (Lisp_Object spec, EMACS_UINT hash)
   img->ascent = DEFAULT_IMAGE_ASCENT;
   img->hash = hash;
   img->corners[BOT_CORNER] = -1;  /* Full image */
+  /* Retrieve file mtime.  */
+  if (! NILP (file) && (emacs_fstatat (AT_FDCWD, SSDATA (file), &st, 0) == 0))
+    img->mtime = get_stat_mtime (&st);
   return img;
 }
 
@@ -3513,6 +3518,27 @@ lookup_image (struct frame *f, Lisp_Object spec, int face_id)
       img = NULL;
     }
 
+  /* If the on-disk image file has changed, this is also a cache
+     miss.  */
+  if (img)
+    {
+      Lisp_Object file;
+      bool found;
+
+      file = image_spec_value (spec, QCfile, &found);
+      if (found && STRINGP (file))
+	{
+	  struct stat st;
+
+	  if (emacs_fstatat (AT_FDCWD, SSDATA (file), &st, 0) != 0
+	      || timespec_cmp (get_stat_mtime (&st), img->mtime) != 0)
+	    {
+	      free_image (f, img);
+	      img = NULL;
+	    }
+	}
+    }
+
   /* If not found, create a new image and cache it.  */
   if (img == NULL)
     {
-- 
2.47.0


[-- Attachment #3: Type: text/plain, Size: 18 bytes --]

-- 
Manuel Giraud

bug#74537: [PATCH] An on-disk image modification does a cache miss

[Eli Zaretskii]

> Date: Mon, 25 Nov 2024 22:24:25 +0100
> From:  Manuel Giraud via "Bug reports for GNU Emacs,
>  the Swiss army knife of text editors" <bug-gnu-emacs@gnu.org>
> 
> With this patch, when an image file is modified on disk, the associated
> cache image is invalidated and re-read from disk.

Thanks, but I'm not sure it's a good idea to do that automatically
whenever lookup_image is called.

First, lookup_image is called only when we need to create or access an
image with only its Lisp descriptor in hand; once the image has been
displayed, that should happen relatively rarely.  For example, the
glyph matrices used to manipulate the display record only the image's
cached ID, and the code accesses the cached image without calling
lookup_image.  So this change could have weird confusing effects,
whereby the fact that the image was modified on disk becomes apparent
only after some display-related actions, but not after others.  For
example, scrolling a window by a small amount will not notice the
change on disk, whereas significant changes, especially when the image
goes off the window and back into it, will show the change.  Don't you
see such issues if you install the change?

Second, if the image is already on display, and the file changes on
disk, some layout calculations could see different dimensions than
what is actually on display, which will cause subtle bugs.  For
example, what if there's a 'display' property such as this:

  '(space :width (0.5 (image PROPS)))

and an image with those same PROPS is already shown on display?  The
code which implements the above calls lookup_image, which will
simulate a cache miss if the file has changed, and will then load the
new file, which could return dimensions different from the image
already on display.  So the width of the space glyph produced by the
above will be different from that of the displayed image, and we could
have misalignment until the next redisplay which redraws the image.

So I think this should probably be controlled by a variable visible
from Lisp, by default off, and we might also have a function to
invalidate all the cached images whose files have changed (which will
then need to trigger a thorough redisplay, I think).

bug#74537: [PATCH] An on-disk image modification does a cache miss

[Manuel Giraud via Bug reports for GNU Emacs, the Swiss army knife of text editors]

Eli Zaretskii <eliz@gnu.org> writes:

>> Date: Mon, 25 Nov 2024 22:24:25 +0100
>> From:  Manuel Giraud via "Bug reports for GNU Emacs,
>>  the Swiss army knife of text editors" <bug-gnu-emacs@gnu.org>
>> 
>> With this patch, when an image file is modified on disk, the associated
>> cache image is invalidated and re-read from disk.
>
> Thanks, but I'm not sure it's a good idea to do that automatically
> whenever lookup_image is called.
>
> First, lookup_image is called only when we need to create or access an
> image with only its Lisp descriptor in hand; once the image has been
> displayed, that should happen relatively rarely.  For example, the
> glyph matrices used to manipulate the display record only the image's
> cached ID, and the code accesses the cached image without calling
> lookup_image.

Ok.

> So this change could have weird confusing effects, whereby the fact
> that the image was modified on disk becomes apparent only after some
> display-related actions, but not after others.  For example, scrolling
> a window by a small amount will not notice the change on disk, whereas
> significant changes, especially when the image goes off the window and
> back into it, will show the change.  Don't you see such issues if you
> install the change?

I've tried a bit with image-mode and also with something like:

(insert (propertize "f" 'display '(image :file "/tmp/foo.jpg" :type jpeg :width 100)))

and, yes, I can see the behavior you describe.  But I also can't really
see why it is a problem: the image has changed!  At one point it should
be reflected in Emacs, no?

> Second, if the image is already on display, and the file changes on
> disk, some layout calculations could see different dimensions than
> what is actually on display, which will cause subtle bugs.  For
> example, what if there's a 'display' property such as this:
>
>   '(space :width (0.5 (image PROPS)))
>
> and an image with those same PROPS is already shown on display?  The
> code which implements the above calls lookup_image, which will
> simulate a cache miss if the file has changed, and will then load the
> new file, which could return dimensions different from the image
> already on display.  So the width of the space glyph produced by the
> above will be different from that of the displayed image, and we could
> have misalignment until the next redisplay which redraws the image.

This I've tried with:

(insert (propertize "foo" 'display '(space :width (0.1 . (image :file "/tmp/foo.jpg" :type jpeg)))))

and also the re-alignment occurs at /some/ point.  But likewise, I fail
to see why this is a problem.

After all, maybe I'm a bit partial to image-mode with this patch.  I
think my idea was to eventually get rid of the systematic `image-flush'
call in "image-mode.el" to make it beneficiate from the image cache more
and still be able to display the correct image.

It seems I also lack some imagination about how users could use images
in Emacs.  For instance, with your example about alignment, I imagined
that it could be something that a user would do in its modeline (for
example) but with images that would never ever change.
-- 
Manuel Giraud

bug#74537: [PATCH] An on-disk image modification does a cache miss

[Eli Zaretskii]

> From: Manuel Giraud <manuel@ledu-giraud.fr>
> Cc: 74537@debbugs.gnu.org
> Date: Tue, 26 Nov 2024 19:38:35 +0100
> 
> Eli Zaretskii <eliz@gnu.org> writes:
> 
> > So this change could have weird confusing effects, whereby the fact
> > that the image was modified on disk becomes apparent only after some
> > display-related actions, but not after others.  For example, scrolling
> > a window by a small amount will not notice the change on disk, whereas
> > significant changes, especially when the image goes off the window and
> > back into it, will show the change.  Don't you see such issues if you
> > install the change?
> 
> I've tried a bit with image-mode and also with something like:
> 
> (insert (propertize "f" 'display '(image :file "/tmp/foo.jpg" :type jpeg :width 100)))
> 
> and, yes, I can see the behavior you describe.  But I also can't really
> see why it is a problem: the image has changed!  At one point it should
> be reflected in Emacs, no?

First, that isn't always true.  Consider a file visited in some Emacs
buffer -- we don't revert it automatically when the visited file on
disk changes, do we?  We have commands and minor modes to do that, but
they are optional.  Why should images be different?

But yes, it would be good to have a mode and command(s) to update the
images when/if they were modified.  We just must be sure we update
_all_ of them, so if an image is displayed in several buffers/windows,
the update affects all of them.  Otherwise we will have weird bugs
like the one above.  And since the display engine has its own ideas
for when to perform a thorough redisplay and when flush the image
cache, these bugs will be hard to reproduce and debug.

My point is that, since the display engine goes out of its way to try
not to do stuff that isn't necessary, it will not "re-lookup_image" if
it has no reason to believe what's on display is outdated.  The image
cache is there to make redisplay of windows showing images faster.
What you want here is to disable some of these optimizations under
certain circumstances, but that must be done correctly, to avoid
incorrect/inaccurate/confusing display.

> This I've tried with:
> 
> (insert (propertize "foo" 'display '(space :width (0.1 . (image :file "/tmp/foo.jpg" :type jpeg)))))
> 
> and also the re-alignment occurs at /some/ point.  But likewise, I fail
> to see why this is a problem.

It is a problem because what the Lisp program which used such a
property wanted (alignment on display) will not happen, since the
image on display and the one you generate by calling lookup_image in
the above scenario might have different metrics.  What we must somehow
do in this case (assuming the user indeed wants the images to
immediately reflect their disk file changes) is to update the image on
display as well.  One way of doing that is to perform a complete
redisplay of each window which shows the image.  I'm not sure, but it
could be the only way, which means such updates will be somewhat
expensive if one has many windows with the image.  (One trivial case
where an image is displayed many times is the tool bar, when you have
many frames.  Another case could be the mode line.)

> After all, maybe I'm a bit partial to image-mode with this patch.  I
> think my idea was to eventually get rid of the systematic `image-flush'
> call in "image-mode.el" to make it beneficiate from the image cache more
> and still be able to display the correct image.

Sorry, I don't understand: the patch you posted effectively flushes
the cache more often, so how is it more beneficial to users of the
cache?

> It seems I also lack some imagination about how users could use images
> in Emacs.  For instance, with your example about alignment, I imagined
> that it could be something that a user would do in its modeline (for
> example) but with images that would never ever change.

It will change if we completely redisplay the window (after removing
the image from the cache, or otherwise rejecting the cached image).