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
41 lines
1.5 KiB
C++
41 lines
1.5 KiB
C++
// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
|
|
// SPDX-License-Identifier: GPL-3.0-only
|
|
|
|
#pragma once
|
|
|
|
#include <cstddef>
|
|
#include <cstdint>
|
|
|
|
// FNV-1a over a block of bytes. Not a cryptographic hash and does not need to be - it exists to
|
|
// notice that the bytes behind a reused address changed, not to resist anyone. Its user is the
|
|
// shared device-table cache (image_analysis/indexing/CudaSharedTables.h), which keys on it; it lives
|
|
// here so the classes that own those tables can compute their own checksum once and hand it in.
|
|
//
|
|
// Run over eight interleaved lanes and fold them at the end. FNV's multiply is a loop-carried
|
|
// dependency, so one lane retires a byte every few cycles however much memory bandwidth is going
|
|
// spare; eight independent chains fill that latency.
|
|
inline uint64_t TableChecksum(const void *data, size_t bytes) {
|
|
constexpr uint64_t PRIME = 1099511628211ULL;
|
|
constexpr size_t LANES = 8;
|
|
const auto *p = static_cast<const unsigned char *>(data);
|
|
uint64_t h[LANES];
|
|
for (size_t l = 0; l < LANES; l++)
|
|
h[l] = 1469598103934665603ULL + l;
|
|
const size_t n = bytes / LANES * LANES;
|
|
for (size_t i = 0; i < n; i += LANES)
|
|
for (size_t l = 0; l < LANES; l++) {
|
|
h[l] ^= p[i + l];
|
|
h[l] *= PRIME;
|
|
}
|
|
uint64_t out = 1469598103934665603ULL;
|
|
for (size_t l = 0; l < LANES; l++) {
|
|
out ^= h[l];
|
|
out *= PRIME;
|
|
}
|
|
for (size_t i = n; i < bytes; i++) {
|
|
out ^= p[i];
|
|
out *= PRIME;
|
|
}
|
|
return out;
|
|
}
|