RestartNodeInfo.cpp

Go to the documentation of this file.

// RestartNodeInfo.cpp: implementation of the RestartNodeInfo class.
//
 
#include "RestartNodeInfo.h"
#include <boost/serialization/export.hpp>
#include "SimulationContext.h"
//BOOST_CLASS_EXPORT(RestartNodeInfo)
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <chrono>
#include <cstdio>
#include <cstdlib>
#include <sstream>
BOOST_CLASS_EXPORT_IMPLEMENT(RestartNodeInfo)
using namespace std;
 
namespace {
template <typename T>
std::pair<size_t, size_t> snap_blob_sig(const T& obj) {
    std::ostringstream oss(std::ios::binary);
    boost::archive::binary_oarchive oa(oss);
    oa << obj;
    const std::string blob = oss.str();
    return {blob.size(), std::hash<std::string>{}(blob)};
}
} // namespace
 
 
// Construction/Destruction
 
RestartNodeInfo::RestartNodeInfo() {
 
}
 
RestartNodeInfo::~RestartNodeInfo() {
  r_Command_handler.clearCommandControlCenteFromRestartInfo();
  r_Action_Taker.clearOperatorATFromRestartInfo();
  r_Decision_Maker.clearOperatorDMFromRestartInfo();
}
void RestartNodeInfo::saveRestartNodeInfo() {
  corresponding_branch_cluster_ID = g_sim.Branch_center.getIDOfRecentGeneratedBranchCluster();
  // Per-member snapshot weight diagnostic. Enabled when the environment
  // variable ADSIDAC_SNAPSHOT_PROFILE is set to any value (read once per
  // process, default off): prints a "[SNAP-PROF]" line on stderr with copy
  // time, serialized size and content hash for every member of every snapshot.
  static const bool snap_prof = getenv("ADSIDAC_SNAPSHOT_PROFILE") != nullptr;
  auto timed = [](const char* name, auto&& copy_fn, auto&& sig_fn) {
    if (!snap_prof) { copy_fn(); return; }
    auto t0 = std::chrono::steady_clock::now();
    copy_fn();
    auto us = std::chrono::duration_cast<std::chrono::microseconds>(
                  std::chrono::steady_clock::now() - t0).count();
    auto sig = sig_fn();
    fprintf(stderr, "[SNAP-PROF] %s copy_us=%lld bytes=%zu hash=%zx\n",
            name, static_cast<long long>(us), sig.first, sig.second);
  };
  timed("ControlPanel",
        [&]{ r_Indicator.copyControlPanel(g_sim.Indicator); },
        [&]{ return snap_blob_sig(r_Indicator); });
  timed("CommandControlCenter",
        [&]{ r_Command_handler.copyCommandControlCenterToRestartInfo(g_sim.Command_handler); },
        [&]{ return snap_blob_sig(r_Command_handler); });
  timed("AnalysisInfoContainer",
        [&]{ r_Aux_info.copyAnalysisInfoContainer(g_sim.Aux_info); },
        [&]{ return snap_blob_sig(r_Aux_info); });
  timed("Procedures",
        [&]{ r_All_procedure.copyProceduresToRestartInfoForRestart(g_sim.All_procedure); },
        [&]{ return snap_blob_sig(r_All_procedure); });
  timed("InitiatingEventController",
        [&]{ r_IE.copyInitiatingEventController(g_sim.IE); },
        [&]{ return snap_blob_sig(r_IE); });
  timed("OperatorDM",
        [&]{ r_Decision_Maker.copyOperatorDMToRestartInfo(g_sim.Decision_Maker); },
        [&]{ return snap_blob_sig(r_Decision_Maker); });
  timed("OperatorAT",
        [&]{ r_Action_Taker.copyOperatorATToRestartInfo(g_sim.Action_Taker); },
        [&]{ return snap_blob_sig(r_Action_Taker); });
  timed("HWReliabilityModule",
        [&]{ r_System_reliability.copyHWReliabilityModule(g_sim.System_reliability); },
        [&]{ return snap_blob_sig(r_System_reliability); });
//  r_Support_system.copySupportSystemModule(Support_system_reliability);
  timed("KeyParameterHistory",
        [&]{ r_KPS.copyKeyParameterHistory(g_sim.KPS); },
        [&]{ return snap_blob_sig(r_KPS); });
  timed("CalculationAid",
        [&]{ r_All_polynomial.copyCalculationAidToRestartInfoForRestart(g_sim.All_polynomial); },
        [&]{ return snap_blob_sig(r_All_polynomial); });
  // Whole-snapshot single-archive size: Boost object tracking dedups shared
  // subobjects WITHIN one archive, so this (what actually travels) can be
  // smaller than the per-member sum above.
  if (snap_prof) {
    auto whole = snap_blob_sig(*this);
    fprintf(stderr, "[SNAP-PROF] WHOLE_RINFO copy_us=0 bytes=%zu hash=%zx\n",
            whole.first, whole.second);
  }
}
void RestartNodeInfo::setCorrespondingBranchClusterID(int n) { corresponding_branch_cluster_ID = n; }
int RestartNodeInfo::getCorrespondingBranchClusterID() { return corresponding_branch_cluster_ID; }