bddcTransferAudit.hh

Go to the documentation of this file.

 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*                                                                           */
/*  This file is part of the library KASKADE 7                               */
/*  https://www.zib.de/research/projects/kaskade7-finite-element-toolbox     */
/*                                                                           */
/*  Copyright (C) 2026 Zuse Institute Berlin                            */
/*                                                                           */
/*  KASKADE 7 is distributed under the terms of the ZIB Academic License.    */
/*    see $KASKADE/academic.txt                                              */
/*                                                                           */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
// Read-only, first-packet transfer audit. Disabled unless explicitly requested.
#ifndef KASKADE_BDDC_TRANSFER_AUDIT_HH
#define KASKADE_BDDC_TRANSFER_AUDIT_HH
#include <algorithm>
#include <cstdlib>
#include <filesystem>
#include <fstream>
#include <iomanip>
#include <limits>
#include <mutex>
#include <set>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <vector>
 
namespace Kaskade::BDDC::TransferAudit
{
  inline std::string const& directory()
  {
    static std::string const path = [] {
      auto p = std::getenv("KASKADE_TRANSFER_AUDIT_DIR");
      return std::string(p ? p : "");
    }();
    return path;
  }
  inline bool enabled() { return !directory().empty(); }
  inline std::mutex outputMutex;
  inline std::set<std::string> written;
 
  // Capture the first observation of each stage on each directed interface.
  // MPI owners write distinct subdomain names. No reductions, feedback changes,
  // codebook changes or transfer-counter updates are performed by this observer.
  template<class T>
  void vector(char const* phase, char const* direction, int id, int peer,
              char const* stage, std::vector<T> const& data)
  {
    if (!enabled()) return;
    std::string key = std::string(phase)+"_"+direction+"_"+std::to_string(id)+"_"+
                      std::to_string(peer)+"_"+stage;
    std::lock_guard<std::mutex> lock(outputMutex);
    if (written.count(key)) return;
    std::filesystem::create_directories(directory());
    std::ofstream out(std::filesystem::path(directory())/(key+".txt"));
    if (!out) throw std::runtime_error("Cannot open transfer audit: "+key);
    out << data.size() << '\n' << std::setprecision(std::numeric_limits<double>::max_digits10);
    for (auto const& value : data)
    {
      if constexpr (std::is_integral_v<T>) out << +value << '\n';
      else out << value << '\n';
    }
    out.close();
    if (!out) throw std::runtime_error("Cannot finish transfer audit: "+key);
    written.insert(key);
  }
 
  // Interface-relative indices describe the exact predictor used in lifting.
  // Comparing these plans does not depend on subdomain-local DOF numbering.
  template<class Scalar>
  void plan(char const* phase, char const* direction, int id, int peer,
            std::vector<int> const& coarse, std::vector<int> const& fine,
            std::vector<std::vector<int>> const& neighbors,
            std::vector<std::vector<Scalar>> const& weights)
  {
    if (!enabled()) return;
    std::vector<std::size_t> offsets{0};
    std::vector<int> flatNeighbors;
    std::vector<Scalar> flatWeights;
    for (std::size_t k=0; k<neighbors.size(); ++k)
    {
      flatNeighbors.insert(flatNeighbors.end(),neighbors[k].begin(),neighbors[k].end());
      flatWeights.insert(flatWeights.end(),weights[k].begin(),weights[k].end());
      offsets.push_back(flatNeighbors.size());
    }
    vector(phase,direction,id,peer,"coarse",coarse);
    vector(phase,direction,id,peer,"fine",fine);
    vector(phase,direction,id,peer,"offsets",offsets);
    vector(phase,direction,id,peer,"neighbors",flatNeighbors);
    vector(phase,direction,id,peer,"weights",flatWeights);
  }
 
  template<class Packet>
  void wire(char const* phase, char const* direction, int id, int peer,
            Packet const& packet)
  {
    if (!enabled()) return;
    std::vector<unsigned char> bytes(packet.size()*sizeof(typename Packet::value_type));
    if (!bytes.empty())
    {
      auto p = reinterpret_cast<unsigned char const*>(packet.data());
      std::copy(p,p+bytes.size(),bytes.begin());
    }
    vector(phase,direction,id,peer,"wire",bytes);
  }
}
#endif