[LyX/master] Parallelize GUI load of images.

commit e0dd8db6ade8472fe3017a0b573617fd24d6d781
Author: Pavel Sanda <[email protected]>
Date:   Sat Jul 11 02:20:55 2026 +0200

    Parallelize GUI load of images.
    
    Load takes quite long on figure-heavy reports, underutilizes usual multicore
    CPUs and its more of us, who scroll through the document just to load all
    images; that's absurd.
    
    Two improvements:
    - default parallelize up to 4 threads if available on the machine
    - new LFUN buffer-load-graphics [all] [<THREADS>|max] which triggers
      load machinery for the whole document ("all" = including childern);
      optionally you can explicitely setup number of <THREADS> or give it
      max, so it uses all cores on the current machine.
    
    https://www.mail-archive.com/[email protected]/msg218082.html
    https://www.mail-archive.com/[email protected]/msg226451.html
    
    Draft by Claude, review by me. As he concludes:
    "Nice bit of archaeology as a bookend: lazy image loading itself - the behavior
    buffer-load-graphics now works around - was introduced on 2002-02-27 (commit
    607ad8d3a7, "lazy loading (don't try and load the image until a request to draw
    it is received)"), fixing ticket #37 "InsetGraphics previews render
    synchronously". Twenty-four years from "make it lazy" to "let me force it
    eager, in parallel".
    
    Assisted-by: Claude Opus 4.8
---
 lib/RELEASE-NOTES            |  8 ++++++
 src/Buffer.cpp               | 33 ++++++++++++++++++++++++
 src/FuncCode.h               |  1 +
 src/LyXAction.cpp            | 15 +++++++++++
 src/insets/InsetGraphics.cpp |  7 ++++++
 src/insets/InsetGraphics.h   |  2 ++
 src/insets/RenderGraphic.cpp | 12 +++++++++
 src/insets/RenderGraphic.h   |  2 ++
 src/support/ForkedCalls.cpp  | 60 ++++++++++++++++++++++++++------------------
 src/support/ForkedCalls.h    |  3 +++
 10 files changed, 119 insertions(+), 24 deletions(-)

diff --git a/lib/RELEASE-NOTES b/lib/RELEASE-NOTES
index f8a223afab..b6fe35c956 100644
--- a/lib/RELEASE-NOTES
+++ b/lib/RELEASE-NOTES
@@ -5,6 +5,10 @@
 
 !!Documents compilation process and images conversion
 
+- Conversion of images for on-screen display now runs up to 4 conversion
+  processes in parallel. The limit can be changed via the optional
+  argument of the buffer-load-graphics lfun.
+
 
 !!!The following pref variables were added in 2.:
 
@@ -22,6 +26,10 @@
 
 !!!The following new LyX functions have been introduced in 2.6:
 
+- buffer-load-graphics: triggers preview conversion for every image in
+  the current buffer at once, instead of waiting for each image to be
+  scrolled into view.
+
 !!!The following LyX functions have been changed in 2.6:
 
 - The function newpage-insert has been renamed to textbreak-insert
diff --git a/src/Buffer.cpp b/src/Buffer.cpp
index 8122a05843..9c301c36d9 100644
--- a/src/Buffer.cpp
+++ b/src/Buffer.cpp
@@ -70,6 +70,7 @@
 #include "xml.h"
 
 #include "insets/InsetBranch.h"
+#include "insets/InsetGraphics.h"
 #include "insets/InsetInclude.h"
 #include "insets/InsetText.h"
 
@@ -94,6 +95,7 @@
 #include "support/FileName.h"
 #include "support/FileNameList.h"
 #include "support/filetools.h"
+#include "support/ForkedCalls.h"
 #include "support/gettext.h"
 #include "support/gzstream.h"
 #include "support/Lexer.h"
@@ -2888,6 +2890,10 @@ bool Buffer::getStatus(FuncRequest const & cmd, FuncStatus & flag) const
 		enable = (d->preview_file_).exists() && !(d->preview_file_).isFileEmpty();
 		break;
 
+	case LFUN_BUFFER_LOAD_GRAPHICS:
+		enable = true;
+		break;
+
 	case LFUN_CHANGES_TRACK:
 		flag.setEnabled(true);
 		flag.setOnOff(params().track_changes);
@@ -3163,6 +3169,33 @@ void Buffer::dispatch(FuncRequest const & func, DispatchResult & dr)
 			dr.setMessage(_("Error viewing the output file."));
 		break;
 
+	case LFUN_BUFFER_LOAD_GRAPHICS: {
+		ListOfBuffers bufs;
+		for (string const & arg :
+		     getVectorFromString(to_utf8(func.argument()), " ")) {
+			if (arg == "all")	//include all childern
+				bufs = getDescendants();
+			else if (arg == "max")	//use all available cores
+				ForkedCallQueue::setMaxRunning(0);
+			else
+				ForkedCallQueue::setMaxRunning(convert<int>(arg));
+		}
+		bufs.push_front(this);
+		int counted = 0;
+		for (Buffer * b : bufs) {
+			InsetIterator it = begin(b->inset());
+			InsetIterator const itend = end(b->inset());
+			for (; it != itend; ++it) {
+				if (it->lyxCode() == GRAPHICS_CODE) {
+					static_cast<InsetGraphics const &>(*it).preload();
+					++counted;
+				}
+			}
+		}
+		//dr.setMessage(bformat(_("Queued %1$d image(s) for preview."), counted));
+		break;
+	}
+
 	case LFUN_CHANGES_TRACK:
 		if (params().save_transient_properties)
 			undo().recordUndoBufferParams();
diff --git a/src/FuncCode.h b/src/FuncCode.h
index 0a56683779..5c3259dd68 100644
--- a/src/FuncCode.h
+++ b/src/FuncCode.h
@@ -461,6 +461,7 @@ enum FuncCode
 	LFUN_SEPARATOR_INSERT,          // ef 20140502
 	LFUN_SERVER_GET_STATISTICS,     // brokenclock 20141010
 	LFUN_BUFFER_VIEW_CACHE,         // skostysh 20150401
+	LFUN_BUFFER_LOAD_GRAPHICS,      // ps 20260623
 	// 360
 	LFUN_BUFFER_MOVE_NEXT,          // skostysh 20150408
 	LFUN_BUFFER_MOVE_PREVIOUS,      // skostysh 20150408
diff --git a/src/LyXAction.cpp b/src/LyXAction.cpp
index 0e0826ead4..390312bfa8 100644
--- a/src/LyXAction.cpp
+++ b/src/LyXAction.cpp
@@ -904,6 +904,21 @@ void LyXAction::init()
  */
 		{ LFUN_BUFFER_VIEW_CACHE, "buffer-view-cache", ReadOnly, Buffer },
 
+/*!
+ * \var lyx::FuncCode lyx::LFUN_BUFFER_LOAD_GRAPHICS
+ * \li Action: Triggers image preview for every image in the current buffer,
+               instead of waiting for each image to be scrolled into view.
+ * \li Syntax: buffer-load-graphics [all] [<THREADS>|max]
+ * \li Params: all: also process all child documents; by default only the
+               current buffer is processed.
+               <THREADS>: fix number os threads for conversion, or 'max' to use 
+	       all cores available on the system.\n
+	       The setting persists until changed again.
+ * \li Origin: ps, 23 Jun 2026
+ * \endvar
+ */
+		{ LFUN_BUFFER_LOAD_GRAPHICS, "buffer-load-graphics", ReadOnly, Buffer },
+
 /*!
  * \var lyx::FuncCode lyx::LFUN_BUFFER_WRITE
  * \li Action: Saves the current buffer.
diff --git a/src/insets/InsetGraphics.cpp b/src/insets/InsetGraphics.cpp
index 0ca24e0488..c087533905 100644
--- a/src/insets/InsetGraphics.cpp
+++ b/src/insets/InsetGraphics.cpp
@@ -1157,6 +1157,13 @@ InsetGraphicsParams const & InsetGraphics::params() const
 }
 
 
+void InsetGraphics::preload() const
+{
+	if (graphic_)
+		graphic_->preload();
+}
+
+
 void InsetGraphics::editGraphics(InsetGraphicsParams const & p) const
 {
 	theFormats().edit(buffer(), p.filename,
diff --git a/src/insets/InsetGraphics.h b/src/insets/InsetGraphics.h
index 95289832cb..7f7cb2e81d 100644
--- a/src/insets/InsetGraphics.h
+++ b/src/insets/InsetGraphics.h
@@ -91,6 +91,8 @@ public:
 	docstring layoutName() const override { return from_ascii("Graphics"); }
 	/// Get the inset parameters, used by the GUIndependent dialog.
 	InsetGraphicsParams const & params() const;
+	/// Force preview generation now (skip the wait-for-paint).
+	void preload() const;
 
 	///
 	int topOffset(BufferView const *) const override { return 0; }
diff --git a/src/insets/RenderGraphic.cpp b/src/insets/RenderGraphic.cpp
index 67d44e1bb4..5f88372953 100644
--- a/src/insets/RenderGraphic.cpp
+++ b/src/insets/RenderGraphic.cpp
@@ -51,6 +51,7 @@ RenderBase * RenderGraphic::clone(Inset const * inset) const
 	return new RenderGraphic(*this, inset);
 }
 
+
 void RenderGraphic::reload() const
 {
 	loader_.reload();
@@ -132,6 +133,17 @@ bool readyToDisplay(graphics::Loader const & loader)
 } // namespace
 
 
+void RenderGraphic::preload() const
+{
+	if (!displayGraphic(params_))
+		return;
+	// ErrorConverting is included so we retry failed conversions.
+	if (loader_.status() == graphics::WaitingToLoad
+	    || loader_.status() == graphics::ErrorConverting)
+		loader_.startLoading();
+}
+
+
 void RenderGraphic::metrics(MetricsInfo & mi, Dimension & dim) const
 {
 	if (displayGraphic(params_)) {
diff --git a/src/insets/RenderGraphic.h b/src/insets/RenderGraphic.h
index fc631a0c7a..2b175008a3 100644
--- a/src/insets/RenderGraphic.h
+++ b/src/insets/RenderGraphic.h
@@ -35,6 +35,8 @@ public:
 
 	/// Refresh the info about which file to display and how to display it.
 	void update(graphics::Params const & params);
+	/// Trigger conversion, no-op if the image is already loading, loaded.
+	void preload() const;
 	/// Reloads the image if necessary
 	void reload() const;
 
diff --git a/src/support/ForkedCalls.cpp b/src/support/ForkedCalls.cpp
index 054290d0dd..c81c8af868 100644
--- a/src/support/ForkedCalls.cpp
+++ b/src/support/ForkedCalls.cpp
@@ -20,11 +20,13 @@
 #include "support/lyxlib.h"
 #include "support/Timeout.h"
 
+#include <algorithm>
 #include <cerrno>
 #include <cstring>
 #include <list>
 #include <queue>
 #include <sstream>
+#include <thread>
 #include <utility>
 #include <vector>
 
@@ -443,18 +445,23 @@ typedef pair<string, ForkedCall::sigPtr> Process;
 /// in-progress queue
 static queue<Process> callQueue_;
 
-/// flag whether queue is running
-static bool running_ = false;
+/// Maximum number of forked children allowed to run concurrently.
+/// Graphics conversion is the only client of this queue.
+/// Default: min(4, #cores), serial if the hardware cannot be queried.
+/// Adjustable at runtime via setMaxRunning().
+static int max_running_ =
+	max(1, min(4, int(std::thread::hardware_concurrency())));
+
+/// Number of children currently running.
+static int running_count_ = 0;
 
 ///
-void startCaller();
-///
-void stopCaller();
+void callNext();
 ///
 void callback(pid_t, int);
 
-/** Add a process to the queue. Processes are forked sequentially
- *  only one is running at a time.
+/** Add a process to the queue. Up to max_running_ processes are
+ *  forked in parallel; the remainder wait for a slot to free up.
  *  Connect to the returned signal and you'll be informed when
  *  the process has ended.
  */
@@ -463,8 +470,10 @@ ForkedCall::sigPtr add(string const & process)
 	ForkedCall::sigPtr ptr;
 	ptr.reset(new ForkedCall::sig);
 	callQueue_.push(Process(process, ptr));
-	if (!running_)
-		startCaller();
+	if (running_count_ == 0)
+		LYXERR(Debug::GRAPHICS, "ForkedCallQueue: waking up");
+	while (running_count_ < max_running_ && !callQueue_.empty())
+		callNext();
 	return ptr;
 }
 
@@ -477,6 +486,7 @@ void callNext()
 	callQueue_.pop();
 	// Bind our chain caller
 	pro.second->connect(callback);
+	++running_count_;
 	ForkedCall call;
 	//If we fail to fork the process, then emit the signal
 	//to tell the outside world that it failed.
@@ -487,31 +497,33 @@ void callNext()
 
 void callback(pid_t, int)
 {
-	if (callQueue_.empty())
-		stopCaller();
-	else
+	--running_count_;
+	while (running_count_ < max_running_ && !callQueue_.empty())
 		callNext();
+	if (running_count_ == 0 && callQueue_.empty())
+		LYXERR(Debug::GRAPHICS, "ForkedCallQueue: I'm going to sleep");
 }
 
 
-void startCaller()
-{
-	LYXERR(Debug::GRAPHICS, "ForkedCallQueue: waking up");
-	running_ = true ;
-	callNext();
-}
-
-
-void stopCaller()
+void setMaxRunning(int n)
 {
-	running_ = false ;
-	LYXERR(Debug::GRAPHICS, "ForkedCallQueue: I'm going to sleep");
+	if (n < 1) {	//All cores available on the system.
+		int const hw = int(std::thread::hardware_concurrency());
+		if (hw < 1)	// Keep the current setting if the hardware cannot be queried.
+			return;
+		n = hw;
+	}
+	max_running_ = n;
+	LYXERR(Debug::GRAPHICS, "ForkedCallQueue: max parallel processes set to " << n);
+	// If the cap was raised while jobs were waiting, top up the pool.
+	while (running_count_ < max_running_ && !callQueue_.empty())
+		callNext();
 }
 
 
 bool running()
 {
-	return running_;
+	return running_count_ > 0;
 }
 
 } // namespace ForkedCallQueue
diff --git a/src/support/ForkedCalls.h b/src/support/ForkedCalls.h
index 84aeac9679..6c41ca9d9b 100644
--- a/src/support/ForkedCalls.h
+++ b/src/support/ForkedCalls.h
@@ -196,6 +196,9 @@ private:
 namespace ForkedCallQueue {
 
 ForkedCall::sigPtr add(std::string const & process);
+/// Set the maximum number of processes forked in parallel;
+/// n < 1 means all cores available on the system.
+void setMaxRunning(int n);
 /// Query whether the queue is running a forked process now.
 bool running();
 
-- 
lyx-cvs mailing list
[email protected]
https://lists.lyx.org/mailman/listinfo/lyx-cvs