ConfigFingerprint.h

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <cstdint>
#include <filesystem>
#include <fstream>
#include <string>
#include <vector>
 
namespace adsidac {
 
inline void fingerprint_feed(uint64_t& h, const char* data, size_t n) {
    for (size_t i = 0; i < n; ++i) {
        h ^= static_cast<unsigned char>(data[i]);
        h *= 1099511628211ULL;
    }
}
 
inline void fingerprint_feed_file(uint64_t& h, const std::filesystem::path& p) {
    std::ifstream in(p, std::ios::binary);
    char buf[1 << 16];
    while (in.read(buf, sizeof buf) || in.gcount() > 0)
        fingerprint_feed(h, buf, static_cast<size_t>(in.gcount()));
}
 
inline uint64_t compute_config_fingerprint(const std::string& project_dir,
                                           const std::string& deck_path) {
    namespace fs = std::filesystem;
    uint64_t h = 1469598103934665603ULL;  // FNV-1a 64 offset basis
 
    std::vector<fs::path> files;
    std::error_code ec;
    if (!deck_path.empty() && fs::is_regular_file(deck_path, ec))
        files.emplace_back(deck_path);
    fs::path ctrl = fs::path(project_dir) / "ZCtrlPar.txt";
    if (fs::is_regular_file(ctrl, ec))
        files.push_back(ctrl);
    fs::path input_dir = fs::path(project_dir) / "Input";
    if (fs::is_directory(input_dir, ec))
        for (auto& e : fs::recursive_directory_iterator(input_dir, ec))
            if (e.is_regular_file(ec))
                files.push_back(e.path());
 
    // Sort by project-relative path so directory iteration order, absolute
    // prefixes, and machine differences cannot change the digest. Keys are
    // derived LEXICALLY and once per file: fs::relative canonicalizes both
    // paths with per-component syscalls, which is costly inside a sort
    // comparator when many ranks stat the same directory at MPI startup.
    const fs::path base = fs::path(project_dir).lexically_normal();
    auto rel_key = [&](const fs::path& p) {
        fs::path r = p.lexically_normal().lexically_relative(base);
        return (r.empty() || *r.begin() == "..") ? p.filename().generic_string()
                                                 : r.generic_string();
    };
    std::vector<std::pair<std::string, fs::path>> keyed;
    keyed.reserve(files.size());
    for (auto& p : files)
        keyed.emplace_back(rel_key(p), p);
    std::sort(keyed.begin(), keyed.end(),
              [](const auto& a, const auto& b) { return a.first < b.first; });
 
    for (const auto& [key, p] : keyed) {
        fingerprint_feed(h, key.data(), key.size());
        fingerprint_feed_file(h, p);
    }
    return h;
}
 
} // namespace adsidac