jungfrauandClaude Opus 5
5ee0f22a61
The image loop gives every worker its own analysis engine, so a run builds ninety-six of them. Each one derived, from scratch, tables that are the same in all of them: the byte-per-pixel mask, the resolution mask, the radial kernel, and the checksum that names the shared device tables. The checksum was the worst of it, because it is part of the cache KEY and so is computed before the lookup - a hit still hashed the whole table. On a 16 Mpx detector that is the bin table, the corrections and the mask, 126 MB an engine, about twelve gigabytes over a run, to answer a question whose answer had not changed. The header said it cost nothing measurable; a profile says otherwise, and says it is worst exactly during the ramp when the machine has nothing else to do. It cannot simply be remembered against the address, which is what it exists to catch: a buffer can be freed and another allocated where it was, and the cache would then hand back a device copy of something else. So the owner of the bytes computes it instead. The azimuthal mapping writes its two tables in its constructor and never again. The pixel mask re-derives its binary form and its checksum on every path that changes the mask, and all of those paths are now private to the class. The key therefore still describes the bytes as they are at the moment of the lookup. The resolution mask was two passes over every pixel - a float comparison into a vector<bool>, then a bit-by-bit repack - in each of the ninety-six. It is one pass now, writing the packed form directly, built once for the limits asked for and handed out as a shared pointer so a worker keeps the mask it was given. The radial kernel is cached on the six numbers it is derived from. Nothing computes a different value; only who computes it changes. Byte-identical merged output on a 16 Mpx set and on a small one. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_011n8riB6X59oRjkrSHzNPAU
74 lines
4.2 KiB
C++
74 lines
4.2 KiB
C++
// SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
|
|
// SPDX-License-Identifier: GPL-3.0-only
|
|
|
|
#pragma once
|
|
|
|
#include <cstdint>
|
|
#include <vector>
|
|
|
|
#include "../../common/DiffractionSpot.h"
|
|
|
|
#include "../image_preprocessing/ImagePreprocessorBuffer.h"
|
|
|
|
class ImageSpotFinder {
|
|
// Flat index of every strong pixel of the current image that passed the resolution mask, and its
|
|
// value. Kept as members only to reuse the allocation from image to image.
|
|
std::vector<uint32_t> strong_pixel;
|
|
std::vector<int32_t> strong_pixel_value;
|
|
protected:
|
|
const int32_t width, height;
|
|
std::vector<uint32_t> output_buffer;
|
|
// Pixels excluded from spot finding, packed the same way as output_buffer (bit set = excluded).
|
|
// The bits past the last image pixel are set at construction, so the padding of the last word
|
|
// needs no separate guard. Default: nothing excluded.
|
|
std::vector<uint32_t> res_mask_bits;
|
|
// The connected components of the last extraction. A member so ExtractComponents can hand out a
|
|
// reference and reuse the allocation from image to image.
|
|
std::vector<DiffractionSpot> components;
|
|
|
|
// host_bit_buffer = false leaves output_buffer empty: the GPU finders extract on the device and
|
|
// never read the bit buffer on the host, so allocating and pinning 2.26 MB per engine (at 18 MP)
|
|
// would be pure waste for them.
|
|
ImageSpotFinder(int32_t width, int32_t height, bool host_bit_buffer = true);
|
|
size_t OutputSize() const;
|
|
size_t OutputByteSize() const;
|
|
// Host extraction: scan the bit buffer, gather the values, run the connected-component search.
|
|
void ExtractComponentsHost(const ImagePreprocessorBuffer &image, const SpotFindingSettings &settings);
|
|
public:
|
|
constexpr static int32_t MIN_VALID_PIXELS = 100;
|
|
constexpr static int NBX = 15;
|
|
|
|
virtual ~ImageSpotFinder() = default;
|
|
|
|
// Detect flags the image's strong pixels into the internal bit buffer - the expensive step (local
|
|
// box or per-ring background over every pixel). ExtractComponents then builds the connected
|
|
// components from those pixels.
|
|
virtual void Detect(const ImagePreprocessorBuffer &image, const SpotFindingSettings &settings) = 0;
|
|
|
|
// Peak-excluded per-ring background of the last Detect(), in the bins of the azimuthal-integration
|
|
// mapping and in raw photon counts. Only the adaptive finders build one (it is what sets their
|
|
// threshold); empty for everyone else, and for a frame with nothing valid to reduce.
|
|
[[nodiscard]] virtual const std::vector<float> &GetRingBackground() const;
|
|
|
|
// Pixels to ignore, one bool per pixel (true = ignore). Set when the resolution limits change,
|
|
// not per image: the GPU finders keep a bit-packed device copy of it, and re-uploading that for
|
|
// every image would cost more than the extraction it feeds.
|
|
void SetResolutionMask(const std::vector<bool> &mask);
|
|
// The same mask already packed 32 pixels to a word, which is how the finders keep it. Every
|
|
// worker's finder is given the identical mask, so the packing is done once by whoever owns the
|
|
// resolution map rather than by each of them (AzimuthalIntegrationMapping::ResolutionMaskBits).
|
|
virtual void SetResolutionMaskBits(const std::vector<uint32_t> &packed_mask);
|
|
|
|
// Every connected component of the last Detect() with at most max-pix pixels. min-pix is NOT
|
|
// applied here on purpose - it is the only spot setting that changes between the passes of the
|
|
// per-image min-pix search, so ONE extraction serves all three of them.
|
|
virtual const std::vector<DiffractionSpot> &ExtractComponents(const ImagePreprocessorBuffer &image,
|
|
const SpotFindingSettings &settings);
|
|
// The components that also pass min-pix.
|
|
static std::vector<DiffractionSpot> Filter(const std::vector<DiffractionSpot> &in,
|
|
const SpotFindingSettings &settings);
|
|
|
|
std::vector<DiffractionSpot> ExtractSpots(const ImagePreprocessorBuffer &image, const SpotFindingSettings &settings);
|
|
std::vector<DiffractionSpot> Run(const ImagePreprocessorBuffer &image, const SpotFindingSettings &settings);
|
|
};
|