[Algs] add buf to checksum utility (for debug)

examples/benchmarks/sph_weak_scale_test.py

@@ -63,7 +63,6 @@
     )
     cfg.set_boundary_periodic()
     cfg.set_eos_adiabatic(gamma)
-    cfg.set_max_neigh_cache_size(int(100e9))
     cfg.print_status()
     model.set_solver_config(cfg)
     model.init_scheduler(scheduler_split_val, scheduler_merge_val)
@@ -102,7 +101,7 @@
 
     model.set_value_in_a_box("uint", "f64", 0, bmin, bmax)
 
-    rinj = 8 * dr
+    rinj = 16 * dr
     u_inj = 1
     model.add_kernel_value("uint", "f64", u_inj, (0, 0, 0), rinj)
 
@@ -116,9 +115,6 @@
     model.set_cfl_cour(0.1)
     model.set_cfl_force(0.1)
 
-    model.set_cfl_multipler(1e-4)
-    model.set_cfl_mult_stiffness(1e6)
-
     shamrock.backends.reset_mem_info_max()
 
     # converge smoothing length and compute initial dt
@@ -128,11 +124,42 @@
     res_rates = []
     res_cnts = []
     res_system_metrics = []
+    res_mpi_timers = []
+
+    """
+    Here we insert callbacks to measure solver MPI usage by fetching the timers twice at the begining and end of the step
+    """
+    before_mpi_timers, after_mpi_timers = None, None
+
+    def callback_before_mpi_timer():
+        global before_mpi_timers
+        # print(shamrock.sys.world_rank(), "register before_mpi_timers")
+        before_mpi_timers = shamrock.comm.get_timers()
+
+    def callback_after_mpi_timer():
+        global after_mpi_timers
+        # print(shamrock.sys.world_rank(), "register after_mpi_timers")
+        after_mpi_timers = shamrock.comm.get_timers()
+
+    model.add_timestep_callback(
+        step_begin=callback_before_mpi_timer, step_end=callback_after_mpi_timer
+    )
+
+    continue
+
+    for i in range(10):
+        if shamrock.sys.world_rank() == 0:
+            print("running step ", i + 1, "/", 10, " ...")
 
-    for i in range(5):
         shamrock.sys.mpi_barrier()
+
+        # To replay the same step
+        model.set_next_dt(0.0)
         model.timestep()
 
+        if shamrock.sys.world_rank() == 0:
+            print("collecting results ...")
+
         tmp_res_rate, tmp_res_cnt, tmp_system_metrics = (
             model.solver_logs_last_rate(),
             model.solver_logs_last_obj_count(),
@@ -141,14 +168,25 @@
         res_rates.append(tmp_res_rate)
         res_cnts.append(tmp_res_cnt)
         res_system_metrics.append(tmp_system_metrics)
+        res_mpi_timers.append(shamrock.comm.mpi_timers_delta(before_mpi_timers, after_mpi_timers))
+
+        if shamrock.sys.world_rank() == 0:
+            print("sleeping 1 second ...")
+
+        import time
+
+        time.sleep(1)
+
+        if shamrock.sys.world_rank() == 0:
+            print("done sleeping 1 second ...")
 
     # result is the best rate of the 5 steps
     res_rate, res_cnt = max(res_rates), res_cnts[0]
 
     # index of the max rate
     max_rate_index = res_rates.index(max(res_rates))
     max_rate_system_metrics = res_system_metrics[max_rate_index]
-
+    max_mpi_timers = res_mpi_timers[max_rate_index]
     step_time = res_cnt / res_rate
 
     if shamrock.sys.world_rank() == 0:
@@ -168,6 +206,7 @@
             "rate": res_rate,
             "cnt": res_cnt,
             "step_time": step_time,
+            "mpi_timers": max_mpi_timers,
         }
 
         # print the system metrics

src/shamalgs/include/shamalgs/buf_checksum.hpp

@@ -0,0 +1,35 @@
+// -------------------------------------------------------//
+//
+// SHAMROCK code for hydrodynamics
+// Copyright (c) 2021-2026 Timothée David--Cléris <tim.shamrock@proton.me>
+// SPDX-License-Identifier: CeCILL Free Software License Agreement v2.1
+// Shamrock is licensed under the CeCILL 2.1 License, see LICENSE for more information
+//
+// -------------------------------------------------------//
+
+#pragma once
+
+/**
+ * @file buf_checksum.hpp
+ * @author Timothée David--Cléris (tim.shamrock@proton.me)
+ * @brief
+ *
+ */
+
+#include "shambase/checksum.hpp"
+#include "shamalgs/primitives/flatten.hpp"
+#include "shambackends/DeviceBuffer.hpp"
+
+namespace shamalgs {
+
+    template<class T>
+    inline u64 buf_checksum(const sham::DeviceBuffer<T> &buf) {
+        auto flattened_buf = primitives::flatten_buffer(buf);
+
+        using Tscal             = typename shambase::VectorProperties<T>::component_type;
+        std::vector<Tscal> data = flattened_buf.copy_to_stdvec();
+        return shambase::fnv1a_hash(
+            reinterpret_cast<const char *>(data.data()), data.size() * sizeof(Tscal));
+    }
+
+} // namespace shamalgs

src/shamalgs/src/collective/sparse_exchange.cpp

@@ -56,6 +56,7 @@ namespace shamalgs::collective {
     /// fetch u64_2 from global message data
     std::vector<u64_2> fetch_global_message_data(
         const std::vector<CommMessageInfo> &messages_send) {
+        __shamrock_stack_entry();
 
         std::vector<u64_2> local_data = std::vector<u64_2>(messages_send.size());
 
@@ -84,6 +85,7 @@ namespace shamalgs::collective {
 
     /// decode message to get message
     std::vector<CommMessageInfo> decode_all_message(const std::vector<u64_2> &global_data) {
+        __shamrock_stack_entry();
         std::vector<CommMessageInfo> message_all(global_data.size());
         for (u64 i = 0; i < global_data.size(); i++) {
             message_all[i] = unpack(global_data[i]);
@@ -94,6 +96,7 @@ namespace shamalgs::collective {
 
     /// compute message tags
     void compute_tags(std::vector<CommMessageInfo> &message_all) {
+        __shamrock_stack_entry();
 
         std::vector<i32> tag_map(shamcomm::world_size(), 0);
 

src/shambase/include/shambase/checksum.hpp

@@ -0,0 +1,43 @@
+// -------------------------------------------------------//
+//
+// SHAMROCK code for hydrodynamics
+// Copyright (c) 2021-2026 Timothée David--Cléris <tim.shamrock@proton.me>
+// SPDX-License-Identifier: CeCILL Free Software License Agreement v2.1
+// Shamrock is licensed under the CeCILL 2.1 License, see LICENSE for more information
+//
+// -------------------------------------------------------//
+
+#pragma once
+
+/**
+ * @file checksum.hpp
+ * @author Timothée David--Cléris (tim.shamrock@proton.me)
+ * @brief
+ *
+ */
+
+#include "shambase/aliases_int.hpp"
+#include <cstddef>
+
+namespace shambase {
+
+    /**
+     * @brief Compute the FNV-1a hash of a given data
+     *
+     * @param data
+     * @param size
+     * @return u64
+     */
+    inline u64 fnv1a_hash(const char *data, size_t size) {
+        constexpr u64 fnv_offset_basis = 14695981039346656037ULL;
+        constexpr u64 fnv_prime        = 1099511628211ULL;
+
+        u64 hash = fnv_offset_basis;
+        for (size_t i = 0; i < size; ++i) {
+            hash ^= static_cast<u64>(static_cast<unsigned char>(data[i]));
+            hash *= fnv_prime;
+        }
+        return hash;
+    }
+
+} // namespace shambase

src/shammodels/gsph/src/modules/GSPHGhostHandler.cpp

@@ -344,13 +344,13 @@ auto GSPHGhostHandler<vec>::gen_id_table_interfaces(GeneratorMap &&gen)
 
     for (auto &[k, v] : send_count_stats) {
         if (v > 0.2) {
-            warn_log += shambase::format("\n    patch {} high interf/patch volume: {}", k, v);
+            // warn_log += shambase::format("\n    patch {} high interf/patch volume: {}", k, v);
             has_warn = true;
         }
     }
 
     if (has_warn && shamcomm::world_rank() == 0) {
-        warn_log = "\n    This can lead to high mpi "
+        warn_log = "\n    High interf/patch volume. This can lead to high mpi "
                    "overhead, try to increase the patch split crit"
                    + warn_log;
     }

src/shammodels/sph/include/shammodels/sph/SPHUtilities.hpp

@@ -86,7 +86,14 @@ namespace shammodels::sph {
             PatchField<flt> interactR_patch = sched.map_owned_to_patch_field_simple<flt>(
                 [&](const Patch p, PatchDataLayer &pdat) -> flt {
                     if (!pdat.is_empty()) {
+#if false
+                        auto tmp = pdat.get_field<flt>(ihpart).compute_max() * h_evol_max * Rkern;
+                        shamcomm::logs::raw_ln(
+                            shambase::format("patch {}, Rghost = {}", p.id_patch, tmp));
+                        return tmp;
+#else
                         return pdat.get_field<flt>(ihpart).compute_max() * h_evol_max * Rkern;
+#endif
                     } else {
                         return shambase::VectorProperties<flt>::get_min();
                     }

src/shammodels/sph/include/shammodels/sph/Solver.hpp

@@ -30,9 +30,12 @@
 #include "shamrock/scheduler/ShamrockCtx.hpp"
 #include "shamsys/legacy/log.hpp"
 #include "shamtree/TreeTraversalCache.hpp"
+#include <functional>
 #include <memory>
+#include <optional>
 #include <stdexcept>
 #include <variant>
+#include <vector>
 namespace shammodels::sph {
 
     struct TimestepLog {
@@ -75,6 +78,12 @@ namespace shammodels::sph {
         Config solver_config;
         SolverLog solve_logs;
 
+        struct SolverStepCallback {
+            std::optional<std::function<void(void)>> step_begin_callback;
+            std::optional<std::function<void(void)>> step_end_callback;
+        };
+        std::vector<SolverStepCallback> timestep_callbacks{};
+
         inline void init_required_fields() { solver_config.set_layout(context.get_pdl_write()); }
 
         // serial patch tree control

src/shammodels/sph/src/BasicSPHGhosts.cpp

@@ -560,13 +560,13 @@ auto BasicSPHGhostHandler<vec>::gen_id_table_interfaces(GeneratorMap &&gen)
 
     for (auto &[k, v] : send_count_stats) {
         if (v > 0.2) {
-            warn_log += shambase::format("\n    patch {} high interf/patch volume: {}", k, v);
+            // warn_log += shambase::format("\n    patch {} high interf/patch volume: {}", k, v);
             has_warn = true;
         }
     }
 
     if (has_warn && shamcomm::world_rank() == 0) {
-        warn_log = "\n    This can lead to high mpi "
+        warn_log = "\n    High interf/patch volume. This can lead to high mpi "
                    "overhead, try to increase the patch split crit"
                    + warn_log;
     }

src/shammodels/sph/src/Solver.cpp

@@ -1583,6 +1583,12 @@ shammodels::sph::TimestepLog shammodels::sph::Solver<Tvec, Kern>::evolve_once()
     sham::MemPerfInfos mem_perf_infos_start = sham::details::get_mem_perf_info();
     f64 mpi_timer_start                     = shamcomm::mpi::get_timer("total");
 
+    for (auto &callbacks : timestep_callbacks) {
+        if (callbacks.step_begin_callback) {
+            shambase::get_check_ref(callbacks.step_begin_callback)();
+        }
+    }
+
     Tscal t_current = solver_config.get_time();
     Tscal dt        = solver_config.get_dt_sph();
 
@@ -2643,6 +2649,12 @@ shammodels::sph::TimestepLog shammodels::sph::Solver<Tvec, Kern>::evolve_once()
 
     tstep.end();
 
+    for (auto it = timestep_callbacks.rbegin(); it != timestep_callbacks.rend(); ++it) {
+        if (it->step_begin_callback) {
+            shambase::get_check_ref(it->step_end_callback)();
+        }
+    }
+
     f64 delta_mpi_timer                   = shamcomm::mpi::get_timer("total") - mpi_timer_start;
     sham::MemPerfInfos mem_perf_infos_end = sham::details::get_mem_perf_info();