MD_Vector_base.cpp

/****************************************************************************
* 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.
*
*****************************************************************************/
 
#include <MD_Vector_base.h>
#include <TRUSTTabs.h>
#include <ArrOfBit.h>
#include <Param.h>
 
Implemente_base(MD_Vector_base, "MD_Vector_base", Objet_U);
 
/*! @brief method used to dump/restore a descriptor in a file Each process writes a different descriptor.
 *
 * See MD_Vector_tools::dump_vector_with_md()
 *
 */
Entree& MD_Vector_base::readOn(Entree& is)
{
  Param p("MD_Vector_base");
  p.ajouter("nb_items_tot", &nb_items_tot_);
  p.ajouter("nb_items_reels", &nb_items_reels_);
  p.ajouter("nb_items_seq_tot", &nb_items_seq_tot_);
  p.ajouter("nb_items_seq_local", &nb_items_seq_local_);
  p.lire_avec_accolades(is);
  return is;
}
 
Sortie& MD_Vector_base::printOn(Sortie& os) const
{
  os << "{" << finl;
  os << "nb_items_tot" << tspace << nb_items_tot_ << finl;
  os << "nb_items_reels" << tspace << nb_items_reels_ << finl;
  os << "nb_items_seq_tot" << tspace << nb_items_seq_tot_ << finl;
  os << "nb_items_seq_local" << tspace << nb_items_seq_local_ << finl;
  os << "}" << finl;
  return os;
}
 
/*! Check the consistency of array size as defined by the MD_Vector and as found in the array.
 */
bool MD_Vector_base::validate(trustIdType sz_array, int line_size) const
{
  int size_tot = this->get_nb_items_tot() * line_size;
  if (size_tot != sz_array)
    {
      Cerr << "Internal error in TRUSTVect::set_md_vector(): wrong array size\n"
           << " Needed size = " << this->get_nb_items_tot() << " x " << line_size
           << "\n Actual size = " << sz_array << finl;
      Process::exit();
    }
  if (line_size == 0)
    {
      Cerr << "Internal error in TRUSTVect::set_md_vector():\n"
           << " cannot attach descriptor to empty array (line_size_ is zero)" << finl;
      Process::exit();
    }
  return true;
}
 
int MD_Vector_base::get_sequential_items_flags(ArrOfBit& flags, int line_size) const
{
  const int sz = get_nb_items_tot() * line_size;
  flags.resize_array(sz);
  flags = 1; // most common default value (0 is the special case)
  return get_seq_flags_impl(flags, line_size);
}
 
// This version is just used in SSOR I think:
int MD_Vector_base::get_sequential_items_flags(ArrOfInt& flags, int line_size) const
{
  const int sz = get_nb_items_tot() * line_size;
  flags.resize_array(sz);
 
  ArrOfBit flgs_bits(sz);
  flgs_bits = 1; // most common default value (0 is the special case)
  int n = get_seq_flags_impl(flgs_bits, line_size);
  for (int i=0; i<sz; i++)
    flags[i] = flgs_bits[i];
 
  return n;
}
 
 
/*! @brief Helper method to append an item to a "blocs"-type array containing series of blocks.
 *
 * Extends the previous block or starts a new block if the item is not contiguous with the previous block.
 */
void MD_Vector_base::append_item_to_blocs(ArrOfInt& blocs, int item)
{
  int n = blocs.size_array();
  assert(n % 2 == 0); // the array contains blocks, so an even number of elements
  assert(n == 0 || item >= blocs[n - 1]); // items must be added in ascending order
  if (n == 0 || blocs[n - 1] != item)
    {
      // new block
      blocs.append_array(item);
      blocs.append_array(item + 1);
    }
  else blocs[n - 1] = item + 1;
}
 
void MD_Vector_base::append_blocs(ArrOfInt& dest, const ArrOfInt& src, int offset, int multiplier)
{
  int i = dest.size_array();
  const int n = src.size_array();
  dest.resize_array(i + n);
  for (int j = 0; j < n; j++, i++)
    dest[i] = offset + src[j] * multiplier;
}
 
void MD_Vector_base::append_items(ArrOfInt& dest, const ArrOfInt& src, int offset, int multiplier)
{
  int i = dest.size_array();
  const int n = src.size_array();
  dest.resize_array(i + n * multiplier);
  for (int j = 0; j < n; j++)
    {
      int x = offset + src[j] * multiplier;
      for (int k = 0; k < multiplier; k++)
        dest[i++] = x++;
    }
}
 
int MD_Vector_base::get_seq_flags_impl(ArrOfBit& flags, int line_size) const
{
  int count = 0;
  const ArrOfInt& itm_sum = get_blocs_items_to_sum();
  const int nblocs = itm_sum.size_array() >> 1;
  const int *ptr = itm_sum.addr();
  int j = 0;
  for (int i = nblocs; i; i--)
    {
      // Could be optimised for ArrOfBit by adding a setflag/clearflag(range_begin, range_end) method to this class;
      int jmax = (*(ptr++)) * line_size; // start of the next block of sequential items
      for (; j < jmax; j++)
        flags.clearbit(j);
      jmax = (*(ptr++)) * line_size; // end of the block of sequential items
      assert(jmax > j);
      count += jmax - j;
      for (; j < jmax; j++)
        {
          assert(flags[j] == 1); // was already set by default in caller
        }
    }
  // End of filling
  int sz = get_nb_items_tot() * line_size;
  for (; j < sz; j++)
    flags.clearbit(j);
  return count;
}