Debog_Pb.tpp

/****************************************************************************
* Copyright (c) 2025, CEA
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
* 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*****************************************************************************/
 
#ifndef Debog_Pb_TPP_included
#define Debog_Pb_TPP_included
 
// In gdb: set the message number in parentheses in this variable with "set msg_debog_breakpoint=x" and a breakpoint in the debog_breakpoint() method
static int msg_debog_breakpoint = 0;
inline void debog_breakpoint() { }
inline void debog_break_test(int msg) { if (msg == msg_debog_breakpoint) debog_breakpoint(); }
 
template<typename _TYPE_>
void Debog_Pb::verifier_gen(const char *const msg, const TRUSTVect<_TYPE_>& arr, TRUSTVect<_TYPE_> *arr_ref)
{
  if (!arr.get_md_vector().non_nul())
    {
      Cerr << "WARNING in Debog::verifier_gen: array has no parallel metadata. Not checked\n (message: " << msg << ")" << finl;
      if (Process::je_suis_maitre())
        log_file_ << "WARNING in Debog::verifier_gen: array has no parallel metadata. Not checked\n (message: " << msg << ")" << finl;
 
      detailed_log_file_ << "WARNING in Debog::verifier_gen: array has no parallel metadata. Not checked\n (message: " << msg << ")" << finl;
      return;
    }
 
  if (test_ignore_msg(msg)) return; // Ignore this test
 
  goto_msg(msg);
  const TRUSTTab<_TYPE_>* scalT = dynamic_cast<const TRUSTTab<_TYPE_>*>(&arr);
  if (scalT)
    {
      // read tab header
      ArrOfInt dims;
      debog_data_file_ >> dims;
    }
 
  TRUSTVect<_TYPE_> reference;
  debog_data_file_ >> reference;
 
  const int n = reference.size_array();
  const trustIdType nb_items_seq = arr.get_md_vector()->nb_items_seq_tot();
  const int ls = arr.line_size();
 
  if (n != nb_items_seq * ls)
    {
      Cerr << "Error in Debog_Pb::verifier_gen : wrong sequential size " << n << " (expected " << nb_items_seq * ls << ")" << finl;
      Process::exit();
    }
  verifier_partie(reference, arr, arr_ref);
}
 
template <typename _TYPE_>
void Debog_Pb::verifier_partie(const TRUSTVect<_TYPE_>& reference, const TRUSTVect<_TYPE_>& arr, TRUSTVect<_TYPE_> *arr_ref)
{
  const MD_Vector_base& md = arr.get_md_vector().valeur();
  if (sub_type(MD_Vector_std, md) || sub_type(MD_Vector_seq, md))
    {
      verifier_partie_std(reference, arr, arr_ref);
    }
  else if (sub_type(MD_Vector_composite, md))
    {
      // This way, each processor writes each part sequentially : part1proc1, part1proc2, ... part2proc1, part2proc2, etc...
      ConstTRUSTTab_parts<_TYPE_> parts(arr);
      TRUSTTab<_TYPE_> ref_part;
      const int n = parts.size();
      int index = 0;
      for (int i = 0; i < n; i++)
        {
          // Build the reference sub-part:
          // (the reference array contains all sequential values, sub-part by sub-part; the size of a sub-part equals the total number
          // of sequential items multiplied by the linesize of that sub-part). Note: not all sub-parts necessarily have the same linesize
          const TRUSTTab<_TYPE_>& part = parts[i];
          const trustIdType s0 = part.get_md_vector()->nb_items_seq_tot();
          if (s0 > std::numeric_limits<int>::max())
            Process::exit("Debog_Pb::verifier_partie() - case is too big to be checked with Debog_Pb!!");
          const int sequential_size = static_cast<int>(s0);
          const int line_size = part.line_size();
          // ref_array() requires a non-const array, but we will use it as const only...
          TRUSTArray<_TYPE_>& cast_array = ref_cast_non_const(TRUSTArray<_TYPE_>, reference);
          ref_part.ref_array(cast_array, index, sequential_size * line_size);
          // Recursive call for the sub-part:
          verifier_partie(ref_part, part, arr_ref);
          index += sequential_size * line_size;
        }
    }
}
 
template <typename _TYPE_>
void Debog_Pb::verifier_partie_std(const TRUSTVect<_TYPE_>& reference, const TRUSTVect<_TYPE_>& array, TRUSTVect<_TYPE_> *arr_reference)
{
  TRUSTVect<_TYPE_> arr(array);
  // Sanity check if HostDevice (e.g.: the array was modified on the host via pointers but the flag was not updated!)
  if (array.get_data_location()==DataLocation::HostDevice)
    {
      // Force copy to host:
      arr.set_data_location(DataLocation::Device);
      copyFromDevice(arr);
      assert(arr.get_data_location()==DataLocation::HostDevice);
      // Comparison with array:
      int size = arr.size_array();
      for (int i = 0; i < size; i++)
        if (arr.addr()[i] != array.addr()[i])
          {
            Cerr << "An array has a wrong status of HostDevice!" << finl;
            Process::exit();
          }
    }
  else
    copyFromDevice(arr); // Copy to host if Device
 
  static constexpr bool IS_DOUBLE = std::is_same<_TYPE_,double>::value;
  Nom identificateur;
  // Search for the descriptor of array arr among the known descriptors
  const IntVect& renum = find_renum_vector(arr.get_md_vector(), identificateur);
 
  _TYPE_ adim = 0;
  if (IS_DOUBLE)
    {
      // Compute a reference value for non-dimensionalization:
      // The reference array is sequential: all processors have the same
      const _TYPE_ adim1 = local_max_abs_vect(reference);
      // The arr array is parallel. We compute the reference using only
      //  the real part (the virtual part may not be up to date)
      const _TYPE_ adim2 = mp_max_abs_vect(arr, VECT_REAL_ITEMS);
      adim = std::max(adim1, adim2);
 
      if (seuil_absolu_ <= 0.)
        {
          Cerr << "Error in Debog.cpp verifier_partie_std: seuil_absolu <= 0" << finl;
          Process::exit();
        }
      if (adim < seuil_absolu_)
        {
          // All values are below the absolute threshold => ok
          if (Process::je_suis_maitre())
            {
              log_file_ << " OK            : All values below seuil_absolu_ (" << seuil_absolu_ << ") id=" << identificateur << finl;
              detailed_log_file_ << " OK            : All values below seuil_absolu_ (" << seuil_absolu_ << ") id=" << identificateur << finl;
            }
          return;
        }
    }
 
  const int ls = arr.line_size();
  int i = 0;
  _TYPE_ max_err_items_reels = 0, max_err_items_virt = 0;
 
  int outbounds = 0;
  // real items, then virtual items
  for (int step = 0; step < 2; step++)
    {
      int n;
      const char * message;
      if (step == 0)
        {
          n = renum.size();
          message = "on real item:";
        }
      else
        {
          n = renum.size_totale();
          message = "on virtual item:";
        }
      _TYPE_ max_err = 0;
      const _TYPE_ *arr_ptr = arr.addr();
 
      for (; i < n; i++)
        {
          if (renum[i]>=0)
            {
              const int i1 = i * ls; // index in "arr"
              const int i2 = renum[i] * ls; // index in "reference"
              for (int j = 0; j < ls; j++)
                {
                  const _TYPE_ x = arr_ptr[i1 + j]; // do not use operator[] to avoid crashing on DMAXFLOAT
                  const _TYPE_ y = reference[i2 + j];
                  // Comparison of x and y
                  if (IS_DOUBLE)
                    {
                      const _TYPE_ delta = (_TYPE_)std::fabs(x - y) / adim;
                      max_err = std::max(max_err, delta);
                      // for real items, indicate if out of bounds:
                      if (step == 0 && !(x >= -DMAXFLOAT && x <= DMAXFLOAT))
                        outbounds = 1;
                      if (delta > seuil_relatif_)
                        {
                          detailed_log_file_ << " DIFF " << message << " reference[" << i2 + j << "]=" << y << " \tcurrent[" << i1 + j
                                             << "]=" << x << " \trelative error=" << delta << finl;
                        }
                    }
                  else   // int
                    {
                      // For integers, values must match exactly !
                      if (x != y)
                        {
                          detailed_log_file_ << " DIFF " << message << " reference[" << i2 + j << "]=" << y << " \tcurrent[" << i1 + j
                                             << "]=" << x << finl;
                          max_err = 1;
                        }
                    }
                }
            }
        }
 
      max_err = Process::mp_max(max_err);
 
      if (step == 0)
        max_err_items_reels = max_err;
      else
        max_err_items_virt = max_err;
    }
 
  const char * resu = 0;
  int call_error_function = 0;
  _TYPE_ seuil = IS_DOUBLE ? seuil_relatif_ : 0;
 
  if (max_err_items_reels <= seuil)
    {
      if (max_err_items_virt <= seuil)
        resu = "OK           ";
      else
        resu = "OK REAL ONLY ";
    }
  else
    {
      call_error_function = 1;
      if (!outbounds)
        resu = "ERROR        ";
      else
        resu = "ERROR(DMAXFLT)";
    }
  if (Process::je_suis_maitre())
    {
      if (IS_DOUBLE)
        log_file_ << " " << resu << " : Max relative error " << max_err_items_reels << " (max ref value=" << adim << ") id=" << identificateur << finl;
      else
        log_file_ << " " << resu << " : integer field " << identificateur << finl;
    }
 
  if (IS_DOUBLE)
    detailed_log_file_ << " " << resu << " : Max relative error " << max_err_items_reels << " (max ref value=" << adim << ") id=" << identificateur << finl;
  else
    detailed_log_file_ << " " << resu << " : integer field " << identificateur << finl;
 
  if (call_error_function)
    error_function();
  if (arr_reference)
    {
      TRUSTVect<_TYPE_>& arr_ref = *arr_reference;
 
      if (arr_ref.line_size() != ls || !(arr_ref.get_md_vector() == arr.get_md_vector()))
        {
          Cerr << "Error in Debog_Pb::verifier_partie_std: the array provided to store the reference value\n"
               << " does not have the same size/descriptor as the source array" << finl;
          Process::exit();
        }
      if (Process::je_suis_maitre())
        log_file_ << "                 Return reference value (including virtual items)" << finl;
      const int n = renum.size_totale();
      _TYPE_ *arr_ptr = arr_ref.addr();
      for (int ibis = 0; ibis < n; ibis++)
        {
          if (renum[ibis]>=0)
            {
              const int i1 = ibis * ls; // index in "arr"
              const int i2 = renum[ibis] * ls; // index in "reference"
              for (int j = 0; j < ls; j++)
                {
                  const _TYPE_ y = reference[i2 + j];
                  arr_ptr[i1 + j] = y; // do not use operator[] to avoid crashing on DMAXFLOAT
                }
            }
        }
    }
}
 
template <typename _TYPE_>
void Debog_Pb::ecrire_gen(const char* const msg, const TRUSTVect<_TYPE_>& arr, int num_deb)
{
  if (!arr.get_md_vector().non_nul())
    {
      Cerr << "WARNING in Debog::ecrire: array has no parallel metadata" << finl;
      Cerr << " (message: " << msg << ")" << finl;
      return;
    }
  Sortie& os = write_debog_data_file_;
  const MD_Vector_base& md = arr.get_md_vector().valeur();
  const int ls = arr.line_size();
  if (Process::je_suis_maitre())
    {
      os << "msg : " << debog_msg_count_ << " : " << msg << " FinMsg " << finl;
      Cerr << "DEBOG: writing array, message " << debog_msg_count_ << " : " << msg << finl;
      if (num_deb >= 0)
        os << num_deb << finl;
      // Dump array header:
 
      const TRUSTTab<_TYPE_>* tabb = dynamic_cast<const TRUSTTab<_TYPE_>*>(&arr);
      if (tabb)
        {
          // Header for TRUSTTab<_TYPE_>:
          const TRUSTTab<_TYPE_>& tab = *tabb;
          const int n =  tab.nb_dim();
          os << n << finl;
          // total number of lines:
          os << md.nb_items_seq_tot();
          // other dimensions:
          for (int i = 1; i < n; i++)
            os << tspace << tab.dimension(i);
          os << finl;
        }
      // Header of ArrayOfDouble:
      os << md.nb_items_seq_tot() * ls << finl;
    }
 
  ecrire_partie(arr);
}
 
template<typename _TYPE_>
void Debog_Pb::ecrire_partie(const TRUSTVect<_TYPE_>& arr)
{
  const MD_Vector_base& md = arr.get_md_vector().valeur();
  if (sub_type(MD_Vector_std, md) || sub_type(MD_Vector_seq, md))
    {
      const int ls = arr.line_size();
      write_debog_data_file_.put(arr.addr(), arr.size_array(), ls);
    }
  else if (sub_type(MD_Vector_composite, md))
    {
      // This way, each processor writes each part sequentially : part1proc1, part1proc2, ... part2proc1, part2proc2, etc...
      ConstTRUSTTab_parts<_TYPE_> parts(arr);
      const int n = parts.size();
      for (int i = 0; i < n; i++)
        {
          const TRUSTTab<_TYPE_>& t = parts[i];
          ecrire_partie(t);
        }
    }
}
 
template<typename _TYPE_>
void Debog_Pb::verifier(const char *const msg, const TRUSTVect<_TYPE_>& arr, TRUSTVect<_TYPE_> *arr_ref)
{
  if (nom_pb_ != nom_pb_actuel_)
    return;
 
  if (test_ignore_msg(msg))
    {
      // Ignorer ce test
      return;
    }
  debog_break_test(debog_msg_count_);
  if(mode_db_ == 0)
    {
      ecrire_gen(msg, arr);
    }
  else
    {
      verifier_gen(msg, arr, arr_ref);
    }
  debog_msg_count_++;
}
 
template<typename _TYPE_> std::enable_if_t< (std::is_convertible<_TYPE_, double>::value) || (std::is_convertible<_TYPE_, int>::value),void >
Debog_Pb::verifier(const char *const msg, _TYPE_ x, _TYPE_ *ref_value)
{
  static constexpr bool IS_DOUBLE = std::is_same<_TYPE_,double>::value;
 
  if (nom_pb_ != nom_pb_actuel_) return;
 
  if (test_ignore_msg(msg)) return; // Ignore this test
 
  debog_break_test (debog_msg_count_);
  if (mode_db_ == 0)
    {
      // write
      Sortie& os = write_debog_data_file_;
      Cerr << "DEBOG: writing scalar, message " << debog_msg_count_ << " : " << msg << finl;
      os << "msg : " << debog_msg_count_ << " : " << msg << " FinMsg " << finl;
      os << x << finl;
    }
  else
    {
      // read and compare
      goto_msg(msg);
      _TYPE_ y, err;
      debog_data_file_ >> y;
 
      if (IS_DOUBLE)
        {
          const _TYPE_ adim = (_TYPE_)std::max(std::fabs(x), std::fabs(y));  // explicit (double) for old compilo which do not handle const expr properly
          const _TYPE_ delta = (_TYPE_)std::fabs(x - y);
          err = 0;
          if (delta >= seuil_absolu_ && delta / adim >= seuil_relatif_)
            {
              err = (_TYPE_)delta;
              detailed_log_file_ << " DIFF (double) reference=" << y << " \tcurrent=" << x << " \trelative error=" << delta / adim << " \t(max ref value=" << adim << ")" << finl;
            }
        }
      else // int
        {
          err = ((x - y) != 0);
          if (err) detailed_log_file_ << " DIFF (int) reference=" << y << " \tcurrent=" << x << finl;
        }
 
      //err = static_cast<int>(mp_sum(err));  // always within 'int' range
      err = Process::mp_max(err);
      if (Process::je_suis_maitre())
        {
          const char *ok = (err > 0.) ? " ERROR       " : " OK           ";
          if (IS_DOUBLE)
            {
              log_file_ << ok << " : comparing double: reference=" << y << " absolute error=" << err << finl;
              if (err > 0.) error_function();
            }
          else // int
            {
              log_file_ << ok << " : comparing int: reference=" << y << finl;
              if (err) error_function();
            }
        }
      if (ref_value)
        {
          if (Process::je_suis_maitre())
            log_file_ << "                Request reference value" << finl;
          *ref_value = y;
        }
    }
  debog_msg_count_++;
}
 
#endif /* Debog_Pb_TPP_included */