diff --git a/image_analysis/structure_refinement/Refinement.cpp b/image_analysis/structure_refinement/Refinement.cpp index ff4471b86..e92060510 100644 --- a/image_analysis/structure_refinement/Refinement.cpp +++ b/image_analysis/structure_refinement/Refinement.cpp @@ -2000,7 +2000,7 @@ void TwinNull(const Context &ctx, RefinementResult &result, size_t first = 0) { // on the CPU otherwise. `restraint_records`, `restraint_slots`: what its restraint sets hold at most (0: the GPU // engine's estimate per atom). void MakeEngine(Context &ctx, bool gpu, const RefinementSettings &settings, Logger &logger, size_t restraint_records = 0, - size_t restraint_slots = 0) { + size_t restraint_slots = 0, size_t normal_bytes = 0) { const RefinementStage stage("engine"); ctx.engine.reset(); #ifdef JFJOCH_USE_CUDA @@ -2014,7 +2014,7 @@ void MakeEngine(Context &ctx, bool gpu, const RefinementSettings &settings, Logg RefinementGPUBytes bytes; ctx.engine = MakeRefinementEngineGPU(device, ctx.cell, *ctx.sg, ctx.d_min, ctx.refl, ctx.Model(), ctx.b_ceiling, budget, &bytes, settings.nthreads, restraint_records, - restraint_slots); + restraint_slots, normal_bytes); ctx.device = device; ctx.engine_bytes = bytes.engine; ctx.card_bytes = bytes.card; @@ -3072,7 +3072,27 @@ RefinementResult RefineOnce(const gemmi::Structure &placed, const std::vector block_atoms; + size_t i = 0; + for (const gemmi::Chain &ch : ctx.Model().chains) + for (const gemmi::Residue &r : ch.residues) { + int a = 0; + for (size_t k = 0; k < r.atoms.size(); k++, i++) + if (ctx.rider_parent.empty() || ctx.rider_parent[i] < 0) + a++; + block_atoms.push_back(a); + } + normal_bytes = RestraintNormalMatrixGPU::DeviceBytes(RestraintsNow(ctx, topo, ncs_p, 1.0), ctx.atoms.size(), + block_atoms, NORMAL_CG_ITERATIONS); + logger.Debug("Refinement: the positions' normal matrix {:.2f} GB per trial on a GPU", normal_bytes / 1e9); + } +#endif + MakeEngine(ctx, settings.gpu, settings, logger, restraint_records, restraint_slots, normal_bytes); result.on_gpu = ctx.engine->OnGPU(); std::vector input_tls; @@ -4272,7 +4292,7 @@ RefinementResult RefineOnce(const gemmi::Structure &placed, const std::vectorctx.engine.reset(); ctx.b_ceiling = ceiling; - MakeEngine(ctx, settings.gpu, settings, logger, restraint_records, restraint_slots); + MakeEngine(ctx, settings.gpu, settings, logger, restraint_records, restraint_slots, normal_bytes); ctx.engine->SetRestraints(0, RestraintsNow(ctx, topo)); ctx.engine->SetRestraints(1, topo.adp); for (size_t k = 0; k < own.size(); k++) diff --git a/image_analysis/structure_refinement/RefinementGPU.cpp b/image_analysis/structure_refinement/RefinementGPU.cpp index e2dc285c1..d37c7bf09 100644 --- a/image_analysis/structure_refinement/RefinementGPU.cpp +++ b/image_analysis/structure_refinement/RefinementGPU.cpp @@ -102,7 +102,7 @@ class RefinementEngineGPU : public RefinementEngine { public: RefinementEngineGPU(int device, const gemmi::UnitCell &cell, const gemmi::SpaceGroup &sg, double d_min, const RefinementReflections &refl, const gemmi::Model &model, double b_max, size_t nthreads, - size_t restraint_records, size_t restraint_slots) + size_t restraint_records, size_t restraint_slots, size_t normal_bytes) : device_(device), cell_(cell), sg_(sg), d_min_(d_min), nthreads_(nthreads), setup_(std::make_shared()), cards_(std::make_shared()) { const gemmi::Grid grid = RigidBodyZoneGrid(cell, sg, d_min); @@ -215,7 +215,7 @@ public: restraint_records = 30 * widest.size(); restraint_slots = 60 * widest.size(); } - bytes_.engine = RefinementGPUEngine::DeviceBytes(*setup_, restraint_records, restraint_slots); + bytes_.engine = RefinementGPUEngine::DeviceBytes(*setup_, restraint_records, restraint_slots) + normal_bytes; bytes_.card = RefinementGPUEngine::CardBytes(*setup_); bytes_.lane = RefinementGPUEngine::LaneBytes(*setup_, fft_work_); } @@ -465,9 +465,10 @@ std::unique_ptr MakeRefinementEngineGPU(int device, const gemm const RefinementReflections &refl, const gemmi::Model &model, double b_max, size_t budget, RefinementGPUBytes *bytes, size_t nthreads, - size_t restraint_records, size_t restraint_slots) { + size_t restraint_records, size_t restraint_slots, + size_t normal_bytes) { auto engine = std::make_unique(device, cell, sg, d_min, refl, model, b_max, nthreads, - restraint_records, restraint_slots); + restraint_records, restraint_slots, normal_bytes); if (bytes != nullptr) *bytes = engine->Bytes(); if (!engine->Supported() || engine->Bytes().engine + engine->Bytes().card + engine->Bytes().lane > budget) diff --git a/image_analysis/structure_refinement/RefinementGPU.h b/image_analysis/structure_refinement/RefinementGPU.h index d937ce4c2..aba5b75e1 100644 --- a/image_analysis/structure_refinement/RefinementGPU.h +++ b/image_analysis/structure_refinement/RefinementGPU.h @@ -25,13 +25,16 @@ struct RefinementGPUBytes { // `b_max`: the largest B an atom may reach, which the gather's reserve is sized for. Throws JFJochException on a // CUDA failure. `nthreads`: the host threads that work out the atoms' densities. `restraint_records`, // `restraint_slots`: the most records (plane atoms included) and gradient slots its two restraint sets hold together, -// which the memory is worked out for (0: about thirty records and sixty slots per atom). +// which the memory is worked out for (0: about thirty records and sixty slots per atom). `normal_bytes`: what the +// minimiser's normal matrix holds beside it while a trial refines on the engine (RestraintNormalMatrixGPU::DeviceBytes), +// counted as the engine's own. std::unique_ptr MakeRefinementEngineGPU(int device, const gemmi::UnitCell &cell, const gemmi::SpaceGroup &sg, double d_min, const RefinementReflections &refl, const gemmi::Model &model, double b_max, size_t budget, RefinementGPUBytes *bytes = nullptr, size_t nthreads = 1, - size_t restraint_records = 0, size_t restraint_slots = 0); + size_t restraint_records = 0, size_t restraint_slots = 0, + size_t normal_bytes = 0); // An engine like `like` (one the function above made) on `device`: the same case, and on a card where an engine // like it is, that card's shared part with it - so it holds RefinementGPUBytes::engine there, and ::lane beside where // `own_lane` (else it shares the card's least used lane). Throws JFJochException on a CUDA failure. diff --git a/image_analysis/structure_refinement/RefinementNewtonGPU.cpp b/image_analysis/structure_refinement/RefinementNewtonGPU.cpp index 990a3b692..149e0e1c4 100644 --- a/image_analysis/structure_refinement/RefinementNewtonGPU.cpp +++ b/image_analysis/structure_refinement/RefinementNewtonGPU.cpp @@ -5,6 +5,45 @@ #include "RefinementRestraints.h" +size_t RestraintNormalMatrixGPU::DeviceBytes(const RestraintSet &set, size_t n_atoms, + const std::vector &block_atoms, int iterations) { + size_t entries = 0, rows = 0, params = 0, inverse = 0; + for (const RestraintRecord &r : set.records) // as At() lays out J + switch (static_cast(r.kind)) { + case RestraintKind::Plane: + entries += static_cast(r.atom[1]) * r.atom[1]; + rows += r.atom[1]; + break; + case RestraintKind::Angle: + entries += 3; + rows++; + break; + case RestraintKind::Torsion: + case RestraintKind::Chiral: + case RestraintKind::NcsDistance: + entries += 4; + rows++; + break; + default: + entries += 2; + rows++; + break; + } + for (int a : block_atoms) { + params += a; + inverse += static_cast(3 * a) * (3 * a + 1) / 2; + } + const size_t n = 3 * params; + return n_atoms * 4 * sizeof(float) // the positions + + set.records.size() * (sizeof(RestraintRecord) + sizeof(int)) + set.plane_atoms.size() * sizeof(int) + + rows * (sizeof(int) + 2 * sizeof(float)) // row starts, J v + + entries * (4 * sizeof(float) + 3 * sizeof(int)) + params * sizeof(int) // J, its index + + n * 15 * sizeof(float) // seven vectors, diagonal + + n * (2 * sizeof(float) + 2 * sizeof(int)) + 2 * block_atoms.size() * sizeof(int) // h, the blocks + + inverse * 2 * sizeof(float) // their inverses + + static_cast(iterations) * n * 3 * sizeof(float); // the kept residuals +} + // The host half: the index of J, as RestraintGaussNewton lays out its rows, with every row kept. void RestraintNormalMatrixGPU::At(const RestraintSet &set, const std::vector> &xyzb) { if (!indexed_) { diff --git a/image_analysis/structure_refinement/RefinementNewtonGPU.h b/image_analysis/structure_refinement/RefinementNewtonGPU.h index 2b07898f3..b8186eee5 100644 --- a/image_analysis/structure_refinement/RefinementNewtonGPU.h +++ b/image_analysis/structure_refinement/RefinementNewtonGPU.h @@ -28,6 +28,12 @@ public: RestraintNormalMatrixGPU(int device, const std::vector ¶m_atoms, size_t n_atoms, bool xyz); ~RestraintNormalMatrixGPU(); + // The device memory a matrix on the x y z of the model's `n_atoms` holds with the restraints of `set`, its + // conjugate gradients of `iterations` and its preconditioner's blocks of `block_atoms` parameter atoms each (every + // parameter atom in one): what the allocations below come to, the few small ones left out. + static size_t DeviceBytes(const RestraintSet &set, size_t n_atoms, const std::vector &block_atoms, + int iterations); + void At(const RestraintSet &set, const std::vector> &xyzb); // hv = J^T J v void Multiply(const std::vector &v, std::vector &hv);