leonarski_fandClaude Opus 5
4bac6d3f21
GetRawImage() allocated a fresh JFJochReaderRawImage per frame, and on a miniCBF sweep its buffer holds the whole decoded image: 72.6 MB on a 4150 x 4371 detector. That is over glibc's 32 MB mmap ceiling, so the block is mmapped and munmapped every image and the decoder faults in 17 700 untouched pages as it writes them. Measured on one 18.1 Mpx frame, decoding into a fresh buffer takes 61 ms against 16 ms into one that has been written before - the allocation costs nearly three times what the decode does, and the per-image loop pays it twice per sweep. ReadRawImage() fills a raw image the caller owns, so a worker declares one outside its loop and keeps the pages. GetRawImage() stays as the allocating wrapper for the single-image callers. The two loops that hand the image to the process-file writer keep a shared_ptr and recycle it only while the writer thread is not still reading the previous frame's pixels. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
66 lines
2.5 KiB
C++
66 lines
2.5 KiB
C++
// SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
|
|
// SPDX-License-Identifier: GPL-3.0-only
|
|
|
|
#ifndef JFJOCHIMAGEREADER_H
|
|
#define JFJOCHIMAGEREADER_H
|
|
|
|
#include <unordered_set>
|
|
#include <map>
|
|
#include <mutex>
|
|
|
|
#include "../common/JFJochMessages.h"
|
|
#include "../common/Plot.h"
|
|
#include "../common/ROIBox.h"
|
|
#include "../common/DiffractionExperiment.h"
|
|
#include "JFJochReaderDataset.h"
|
|
#include "JFJochReaderImage.h"
|
|
#include "JFJochReaderSpots.h"
|
|
|
|
class JFJochReader {
|
|
mutable std::mutex m;
|
|
std::shared_ptr<JFJochReaderDataset> dataset;
|
|
|
|
virtual bool LoadImage_i(std::shared_ptr<JFJochReaderDataset> &dataset,
|
|
DataMessage& message,
|
|
std::vector<uint8_t> &buffer,
|
|
int64_t image_number,
|
|
bool update_dataset) = 0;
|
|
|
|
mutable std::mutex summation_mutex;
|
|
void SummationThread(int64_t image0,
|
|
int64_t n_image,
|
|
int64_t image_jump,
|
|
JFJochReaderImage &image);
|
|
protected:
|
|
void SetStartMessage(const std::shared_ptr<JFJochReaderDataset> &val);
|
|
DiffractionExperiment default_experiment;
|
|
public:
|
|
virtual ~JFJochReader() = default;
|
|
|
|
JFJochReader& Experiment(const DiffractionExperiment& experiment);
|
|
|
|
std::shared_ptr<const JFJochReaderDataset> GetDataset() const;
|
|
[[nodiscard]] virtual uint64_t GetNumberOfImages() const = 0;
|
|
|
|
virtual void Close() = 0;
|
|
|
|
std::shared_ptr<JFJochReaderImage> LoadImage(int64_t image_number, int64_t summation_factor = 1);
|
|
|
|
void UpdateGeomMetadata(const DiffractionExperiment& experiment);
|
|
void UpdateUserMask(const std::vector<uint32_t>& mask);
|
|
|
|
// Read one image into a raw image the caller owns, false where there is nothing to read. A
|
|
// worker that walks a whole sweep hands the same object back on every frame and so keeps its
|
|
// buffer: GetRawImage() allocates a fresh one per call, which on a 4-byte 16 Mpx frame is 72 MB
|
|
// of untouched pages the decoder then faults in one by one, measurably more than the decode.
|
|
virtual bool ReadRawImage(int64_t image_number, JFJochReaderRawImage &image) = 0;
|
|
|
|
// The same image in a freshly allocated raw image.
|
|
std::shared_ptr<JFJochReaderRawImage> GetRawImage(int64_t image_number);
|
|
|
|
virtual std::vector<SpotToSave> ReadSpots(int64_t image) const = 0;
|
|
std::shared_ptr<JFJochReaderSpots> ReadAllSpots(int64_t start_image, int64_t end_image, int64_t stride = 1) const;
|
|
};
|
|
|
|
#endif //JFJOCHIMAGEREADER_H
|