leonarski_fandClaude Fable 5
dc8a80f3e0
The viewer could grow to ~100 GB RAM when live-following an HTTP broker. The rc.153 images_in_flight backpressure only throttled imageLoaded; the heavy per-frame payload rides datasetLoaded, fanned out over ~10 queued cross-thread connections with no cap. In HTTPSyncDataset follow mode (entered when an operator clicks an image while following live) RefreshDatasetOnly_i emits a fresh full dataset every autoload tick with no imageLoaded, so the gate never engaged and the queued events - each pinning a full JFJochReaderDataset (full-detector PixelMask + per-image plots) - accumulated without bound. Backpressure datasetLoaded the same way as imageLoaded: a datasets_in_flight counter (cap 2), all emits routed through EmitDatasetLoaded_i, and AutoLoadTimerExpired gated on it (covers HTTPSyncDataset). The window routes the worker's datasetLoaded through a single OnDatasetReady sink that fans out synchronously via datasetReady and acks with datasetConsumed. Under load stale datasets are dropped; the next tick sends the latest. Share the pixel mask instead of deep-copying it: JFJochReaderDataset::pixel_mask is now shared_ptr<const PixelMask>, so per-frame dataset copies share the ~72 MB mask. UpdateUserMask does copy-on-write; JFJochHttpReader caches the mask by arm_date so a live refresh reuses one shared mask per acquisition. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
93 lines
4.3 KiB
C++
93 lines
4.3 KiB
C++
// SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
|
|
// SPDX-License-Identifier: GPL-3.0-only
|
|
|
|
#pragma once
|
|
|
|
#include <QMainWindow>
|
|
#include <QProgressDialog>
|
|
|
|
#include "JFJochViewerMenu.h"
|
|
#include "../reader/JFJochHDF5Reader.h"
|
|
#include "JFJochImageReadingWorker.h"
|
|
#include "JFJochViewerDatasetInfo.h"
|
|
#include "JFJochViewerStatusBar.h"
|
|
#include "toolbar/JFJochViewerToolbarDisplay.h"
|
|
|
|
class JFJochProcessingJobsWindow;
|
|
class QDockWidget;
|
|
|
|
class JFJochViewerWindow : public QMainWindow {
|
|
Q_OBJECT
|
|
// Theming is done via the application palette in main() (salmon panels, white entry fields,
|
|
// navy accent) so it applies consistently to every widget, including dialogs.
|
|
public:
|
|
explicit JFJochViewerWindow(QWidget *parent = nullptr, bool dbus = true, const QString &file = "");
|
|
~JFJochViewerWindow() override;
|
|
|
|
private:
|
|
JFJochViewerMenu *menuBar;
|
|
JFJochImageReadingWorker *reading_worker;
|
|
JFJochViewerToolbarDisplay *toolBarDisplay;
|
|
JFJochViewerStatusBar *statusbar;
|
|
JFJochProcessingJobsWindow *processingJobsWindow;
|
|
|
|
std::shared_ptr<const JFJochReaderDataset> lastDataset; // added
|
|
std::shared_ptr<const JFJochReaderImage> lastImage; // added
|
|
QVector<RunData> lastRuns; // for dataset-info docks opened later
|
|
QString lastActiveRunId;
|
|
|
|
QProgressDialog *retryDialog = nullptr;
|
|
|
|
QDockWidget *lastDatasetInfoDock = nullptr; // most recent dataset-info dock, for docking layout
|
|
QDockWidget *inspectorDock = nullptr; // image inspector (former right-hand side panel)
|
|
QDockWidget *settingsDock = nullptr; // inline MX/AzInt settings panel
|
|
QDockWidget *processingDock = nullptr; // processing jobs panel
|
|
QDockWidget *imageStripDock = nullptr; // thumbnail strip / hit feed
|
|
QByteArray defaultLayoutState; // captured after construction, for "Reset layout"
|
|
int datasetInfoCounter = 0; // gives each dataset-info dock a unique objectName
|
|
|
|
QThread *reading_thread;
|
|
|
|
// Named layouts. Image = just the image + inspector; Processing = also the plots + jobs panel.
|
|
enum class Perspective { Image, Processing };
|
|
void ApplyPerspective(Perspective p);
|
|
|
|
void keyPressEvent(QKeyEvent *event) override;
|
|
void keyReleaseEvent(QKeyEvent *event) override;
|
|
void closeEvent(QCloseEvent *event) override;
|
|
|
|
private slots:
|
|
// Single cross-thread sink for the worker's imageLoaded: fans out to every GUI consumer
|
|
// (synchronously, same thread) via imageReady, then acks the worker so it may produce the next.
|
|
void OnImageReady(std::shared_ptr<const JFJochReaderImage> image);
|
|
|
|
// Single cross-thread sink for the worker's datasetLoaded, mirroring OnImageReady: fans out to
|
|
// every GUI consumer synchronously via datasetReady, then acks the worker (datasetConsumed) so the
|
|
// worker can cap how many datasets are in flight - without this the queued datasetLoaded backlog
|
|
// (each event pinning a full dataset) grew without bound in live follow (100 GB OOM).
|
|
void OnDatasetReady(std::shared_ptr<const JFJochReaderDataset> dataset);
|
|
|
|
public slots:
|
|
void LoadFile(const QString &filename, qint64 image_number, qint64 summation, bool retry);
|
|
void LoadImage(qint64 image_number, qint64 summation);
|
|
void NewDatasetInfo();
|
|
void OnFileLoadError(QString title, QString message);
|
|
void OnFileLoadRetryStatus(bool active, QString message);
|
|
|
|
signals:
|
|
// Internal GUI-thread fan-out of the newest frame: OnImageReady re-emits this to every GUI
|
|
// consumer synchronously, then acks via imageConsumed (see OnImageReady).
|
|
void imageReady(std::shared_ptr<const JFJochReaderImage> image);
|
|
void imageConsumed(); // ack to the worker that one frame has been consumed (backpressure)
|
|
|
|
// Same GUI-thread fan-out + ack for the dataset stream (see OnDatasetReady).
|
|
void datasetReady(std::shared_ptr<const JFJochReaderDataset> dataset);
|
|
void datasetConsumed(); // ack to the worker that one dataset has been consumed (backpressure)
|
|
|
|
void LoadFileRequest(const QString &filename, qint64 image_number, qint64 summation, bool retry);
|
|
void LoadImageRequest(int64_t image_number, int64_t summation);
|
|
void adjustForegroundButton(bool input);
|
|
void setAutoForeground(bool val);
|
|
};
|
|
|