RESULT-CHANGING on the CPU (ulp level): the B factor's exp in EvaluatorCPU::Contribution is
BraggExp (bragg_integration/BraggExp.h, at most 0.53 ulp) instead of the libm expf, so that the
Apple GPU, whose exp no host function reproduces, computes the same bits.
MakeSideChainFieldEvaluatorCPU takes a `gpu` flag (the refinement passes settings.gpu); on macOS the
evaluator's Contribution() and the per-state sums of Evaluate() then run on the Apple GPU
(SideChainFieldMetal.mm/.metal): one thread per reflection and state, as SideChainFieldGPU.cu's
contribution_kernel, the evaluator's tables uploaded once, states in batches of 32 so that the
GPU's buffer stays small beside the states' own. Fast math and contraction off - also over the
BraggExp prepended to the kernel source, which a first version left contracted (91 of 60000
values 1-2 ulp off). The likelihood over the combinations stays on the CPU (double). Where the
GPU is hidden (--no-gpu) or fails (one warning) the CPU does the same sums.
SideChainFieldMetal_BitIdenticalToCPU ([portable][Metal]): 20000 reflections, P212121, 70
six-atom states (three batches): every contribution the same bits, every combination's -ln L equal.
M6 Mac mini, rugnux --mode refine of an open-arm set's merged MTZ and refined model, on top of the
Metal gradient (previous commit):
9s02 (20355 atoms, 306298 reflections, 5 NCS copies): side-chain field 149.0 -> 30.4 s, refinement
309 -> 184 s wall; R-work 0.2254 / R-free 0.2390 both.
9zlo: field 7.6 -> 2.4 s, 45.8 -> 41.3 s; R unchanged.
--no-gpu on 9zlo: the refined model byte-identical to the build before (the field moved nothing).
Not run here: SideChainFieldTest.cpp's [Refinement] cases (jfjoch_test is not built on macOS).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UqXYdJDrM65gxsCn2PrbfK
78 lines
3.4 KiB
C++
78 lines
3.4 KiB
C++
// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
|
|
// SPDX-License-Identifier: GPL-3.0-only
|
|
|
|
#include <catch2/catch_all.hpp>
|
|
|
|
#ifdef __APPLE__
|
|
|
|
#include <complex>
|
|
#include <cstring>
|
|
#include <random>
|
|
#include <vector>
|
|
|
|
#include "gemmi/it92.hpp"
|
|
#include "gemmi/symmetry.hpp"
|
|
#include "../image_analysis/structure_refinement/SideChainField.h"
|
|
#include "../image_analysis/structure_refinement/SideChainFieldMetal.h"
|
|
|
|
// The side-chain field's direct sums on the Apple GPU (SideChainFieldMetal.h) are the CPU's, bit for bit, so the
|
|
// contributions are compared as bit patterns and the energies exactly. A Mac without a Metal device fails rather than
|
|
// skips, as in ModelDensityMetalTest.cpp.
|
|
|
|
TEST_CASE("SideChainFieldMetal_BitIdenticalToCPU", "[portable][Metal]") {
|
|
std::mt19937 rng(23);
|
|
std::uniform_real_distribution<float> unit(0.0f, 1.0f);
|
|
std::uniform_int_distribution<int> index(-25, 25);
|
|
// reflections of a 50 A cell to about 2 A, in no particular order, a tenth of them free
|
|
FieldReflections fr;
|
|
for (int i = 0; i < 20000; i++) {
|
|
const float h = static_cast<float>(index(rng)), k = static_cast<float>(index(rng)), l = static_cast<float>(index(rng));
|
|
fr.hkl.push_back({h, k, l});
|
|
fr.stol2.push_back((h * h + k * k + l * l) / (4.0f * 50 * 50));
|
|
fr.fo.push_back(100 * unit(rng));
|
|
fr.d.push_back(0.9f);
|
|
fr.var.push_back(50 + 100 * unit(rng));
|
|
fr.centric.push_back(i % 7 == 0);
|
|
fr.work.push_back(i % 10 != 0);
|
|
fr.k_total.push_back(1.0f);
|
|
fr.fmask.push_back({10 * unit(rng), 10 * unit(rng)});
|
|
}
|
|
const std::vector<FormFactor> elements = {gemmi::IT92<float>::get(gemmi::El::C, 0).coefs,
|
|
gemmi::IT92<float>::get(gemmi::El::N, 0).coefs,
|
|
gemmi::IT92<float>::get(gemmi::El::O, 0).coefs};
|
|
const auto ops = FieldOperators(*gemmi::find_spacegroup_by_name("P 21 21 21"));
|
|
// 70 states of six atoms each - more than one batch - and combinations of one and of two states
|
|
FieldStates states;
|
|
for (int s = 0; s < 70; s++) {
|
|
std::vector<FieldAtom> atoms;
|
|
for (int a = 0; a < 6; a++)
|
|
atoms.push_back({unit(rng), unit(rng), unit(rng), 10 + 50 * unit(rng), 0.5f + 0.5f * unit(rng), a % 3});
|
|
states.Add(atoms);
|
|
}
|
|
states.current = {0};
|
|
for (int c = 0; c < 69; c++)
|
|
states.AddCombo(c % 2 == 0 ? std::vector<int>{c} : std::vector<int>{c, c + 1});
|
|
|
|
auto cpu = MakeSideChainFieldEvaluatorCPU(fr, ops, elements, 4, false);
|
|
auto gpu = MakeSideChainFieldEvaluatorCPU(fr, ops, elements, 4, true);
|
|
const size_t before = SideChainFieldMetal::States();
|
|
size_t different = 0;
|
|
for (int s : {0, 33, 69}) {
|
|
const std::vector<std::complex<float>> c = cpu->Contribution(states, s), g = gpu->Contribution(states, s);
|
|
REQUIRE(c.size() == g.size());
|
|
for (size_t m = 0; m < c.size(); m++)
|
|
different += std::memcmp(&c[m], &g[m], sizeof(c[m])) != 0;
|
|
}
|
|
REQUIRE(SideChainFieldMetal::States() == before + 3); // the GPU summed them
|
|
CHECK(different == 0);
|
|
|
|
const std::vector<std::complex<float>> total = cpu->Contribution(states, 0);
|
|
cpu->SetTotal(total);
|
|
gpu->SetTotal(total);
|
|
const std::vector<double> ec = cpu->Evaluate(states), eg = gpu->Evaluate(states);
|
|
REQUIRE(SideChainFieldMetal::States() == before + 3 + 70);
|
|
CHECK(ec == eg);
|
|
}
|
|
|
|
#endif
|