MD_Vector_std.h

/****************************************************************************
* Copyright (c) 2024, 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 MD_Vector_std_included
#define MD_Vector_std_included
 
#include <MD_Vector_mono.h>
#include <Schema_Comm_Vecteurs.h>
#include <Schema_Comm.h>
#include <Echange_EV_Options.h>
#include <Static_Int_Lists.h>
#include <communications.h>
#include <TRUSTArrays.h>
#include <TRUSTVect.h>
#include <ArrOfBit.h>
 
/*! @brief This is the simplest descriptor, used for arrays of values at vertices, elements, faces, edges, boundary faces, etc.
 *
 * ..
 *   It supports the notion of "shared" items (mesh vertices shared among multiple processors)
 *   and "distant" and "virtual" items (vertices, elements in the ghost layer).
 *
 *   @sa MD_Vector_composite (descriptor composed of a union of several descriptors, for P1Bulle
 *   for example)
 *
 */
class MD_Vector_std : public MD_Vector_mono
{
  Declare_instanciable(MD_Vector_std);
 
public:
  MD_Vector_std(int n);  // Simple ctor for SIDES
  MD_Vector_std(int nb_items_tot, int nb_items_reels, const ArrOfInt& pe_voisins,
                const ArrsOfInt& items_to_send, const ArrsOfInt& items_to_recv, const ArrsOfInt& blocs_to_recv);
 
  inline void initialize_comm(const Echange_EV_Options& opt, Schema_Comm_Vecteurs& sc, DoubleVect& v) const override { initialize_comm_template<double>(opt,sc,v); }
  inline void prepare_send_data(const Echange_EV_Options& opt, Schema_Comm_Vecteurs& sc, DoubleVect& v) const override { prepare_send_data_template<double>(opt,sc,v); }
  inline void process_recv_data(const Echange_EV_Options& opt, Schema_Comm_Vecteurs& sc, DoubleVect& v) const override { process_recv_data_template<double>(opt,sc,v); }
 
  inline void initialize_comm(const Echange_EV_Options& opt, Schema_Comm_Vecteurs& sc, FloatVect& v) const override { initialize_comm_template<float>(opt,sc,v); }
  inline void prepare_send_data(const Echange_EV_Options& opt, Schema_Comm_Vecteurs& sc, FloatVect& v) const override { prepare_send_data_template<float>(opt,sc,v); }
  inline void process_recv_data(const Echange_EV_Options& opt, Schema_Comm_Vecteurs& sc, FloatVect& v) const override { process_recv_data_template<float>(opt,sc,v); }
 
  inline void initialize_comm(const Echange_EV_Options& opt, Schema_Comm_Vecteurs& sc, IntVect& v) const override { initialize_comm_template<int>(opt,sc,v); }
  inline void prepare_send_data(const Echange_EV_Options& opt, Schema_Comm_Vecteurs& sc, IntVect& v) const override { prepare_send_data_template<int>(opt,sc,v); }
  inline void process_recv_data(const Echange_EV_Options& opt, Schema_Comm_Vecteurs& sc, IntVect& v) const override { process_recv_data_template<int>(opt,sc,v); }
 
#if INT_is_64_ == 2
  inline void initialize_comm(const Echange_EV_Options& opt, Schema_Comm_Vecteurs& sc, TIDVect& v) const override { initialize_comm_template<trustIdType>(opt,sc,v); }
  inline void prepare_send_data(const Echange_EV_Options& opt, Schema_Comm_Vecteurs& sc, TIDVect& v) const override { prepare_send_data_template<trustIdType>(opt,sc,v); }
  inline void process_recv_data(const Echange_EV_Options& opt, Schema_Comm_Vecteurs& sc, TIDVect& v) const override { process_recv_data_template<trustIdType>(opt,sc,v); }
#endif
 
  inline const ArrOfInt& pe_voisins() const { return pe_voisins_; }
  inline const Static_Int_Lists& items_to_send() const { return items_to_send_; }
  inline const Static_Int_Lists& items_to_recv() const { return items_to_recv_; }
  inline const Static_Int_Lists& blocs_to_recv() const { return blocs_to_recv_; }
 
  void append_from_other_std(const MD_Vector_std& src, int offset, int multiplier) override;
  void fill_md_vect_renum(const IntVect& renum, MD_Vector& md_vect) const override;
 
  bool use_blocks() const override { return true; }
 
protected:
 
  // Indices of neighbouring processors with whom I exchange data (same size as the following VECTs)
  ArrOfInt pe_voisins_;
  // Indices of individual items to send to each neighbour (one list per neighbouring processor)
  //  The lists contain both the shared items to send and the "distant" items that will be
  //  stored in the virtual spaces. The first items in this list correspond to "items_to_recv_"
  //  on the neighbouring processor, the following items to "blocs_to_recv_".
  Static_Int_Lists items_to_send_;
  // Among the items to send, how many on each processor will be received in "items_to_recv_"? (the following are received in blocs_to_recv_)
  ArrOfInt nb_items_to_items_;
  // Indices of individual items to receive from each neighbour (in principle, these are the shared items received, rarely contiguous in the arrays)
  Static_Int_Lists items_to_recv_;
  // Blocks of items to receive
  // Each list contains start_bloc1, end_bloc1, start_bloc2, end_bloc2, etc... note that end_bloc is the index of the last element + 1
  // In principle these are the virtual items, which are often contiguous in the arrays.
  Static_Int_Lists blocs_to_recv_;
  // To speed up buffer size computation, total number of items mentioned in blocs_to_recv_ for each processor (equal to the sum of end_bloc-start_bloc)
  ArrOfInt blocs_items_count_;
 
private:
  template <typename _TYPE_>
  void initialize_comm_template(const Echange_EV_Options& opt, Schema_Comm_Vecteurs&, TRUSTVect<_TYPE_>&) const;
 
  template <typename _TYPE_>
  void prepare_send_data_template(const Echange_EV_Options& opt, Schema_Comm_Vecteurs&, TRUSTVect<_TYPE_>&) const;
 
  template <typename _TYPE_>
  void process_recv_data_template(const Echange_EV_Options& opt, Schema_Comm_Vecteurs&, TRUSTVect<_TYPE_>&) const;
};
 
#include <MD_Vector_std_tools.tpp>
 
template<typename _TYPE_>
void MD_Vector_std::initialize_comm_template(const Echange_EV_Options& opt, Schema_Comm_Vecteurs& comm_, TRUSTVect<_TYPE_>& v) const
{
  const int reverse = (opt.get_op() != Echange_EV_Options::SYNC);
  const int have_items_to_recv = (items_to_recv_.get_data().size_array() > 0);
  const int have_blocs_to_recv = (blocs_to_recv_.get_data().size_array() > 0);
  const int nprocs = pe_voisins_.size_array();
  for (int i = 0; i < nprocs; i++)
    {
      const int pe = pe_voisins_[i];
      int sz1 = items_to_send_.get_list_size(i), sz2 = 0;
 
      if (have_items_to_recv) sz2 = items_to_recv_.get_list_size(i);
      if (have_blocs_to_recv) sz2 += blocs_items_count_[i];
      if (reverse)
        {
          // Reverse scheme: read from items to recv, write to items to send
          int tmp = sz1;
          sz1 = sz2;
          sz2 = tmp;
        }
      comm_.add_send_area_template < _TYPE_ > (pe, sz1 * v.line_size());
      comm_.add_recv_area_template < _TYPE_ > (pe, sz2 * v.line_size());
    }
}
 
/*! @brief This is the first part of the echange_espace_virtuel() process.
 *
 * We take the data that has to be sent to other processors in "vect" and put it in appropriate send buffers in "buffers". The data taken depends on "opt".
 *  Preconditon: The buffers must have been initialized to the appropriate size and neighbour processors.
 *
 */
template<typename _TYPE_>
void MD_Vector_std::prepare_send_data_template(const Echange_EV_Options& opt, Schema_Comm_Vecteurs& buffers,  TRUSTVect<_TYPE_>& vect) const
{
  const int line_size = vect.line_size();
  switch(opt.get_op())
    {
    case Echange_EV_Options::SYNC:
      read_from_vect_items(line_size, pe_voisins_, items_to_send_, vect, buffers);
      break;
    case Echange_EV_Options::SUM:
    case Echange_EV_Options::MAX:
    case Echange_EV_Options::MINCOL1:
      if (items_to_recv_.get_data().size_array() > 0)
        read_from_vect_items(line_size, pe_voisins_, items_to_recv_, vect, buffers);
      if (blocs_to_recv_.get_data().size_array() > 0)
        read_from_vect_blocs(line_size, pe_voisins_, blocs_to_recv_, blocs_items_count_, vect, buffers);
      break;
    default:
      Cerr << "Error in MD_Vector_std.tpp prepare_send_data_template : operation not implemented" << finl;
      Process::exit();
    }
}
 
template<typename _TYPE_>
void MD_Vector_std::process_recv_data_template(const Echange_EV_Options& opt, Schema_Comm_Vecteurs& buffers, TRUSTVect<_TYPE_>& vect) const
{
  const int line_size = vect.line_size();
  switch(opt.get_op())
    {
    case Echange_EV_Options::SYNC:
      if (items_to_recv_.get_data().size_array() > 0)
        write_to_vect_items(line_size, pe_voisins_, items_to_recv_, vect, buffers);
      if (blocs_to_recv_.get_data().size_array() > 0)
        write_to_vect_blocs(line_size, pe_voisins_, blocs_to_recv_, blocs_items_count_, vect, buffers);
      break;
    case Echange_EV_Options::SUM:
      add_to_vect_items(line_size, pe_voisins_, items_to_send_, vect, buffers);
      break;
    case Echange_EV_Options::MAX:
      max_to_vect_items(line_size, pe_voisins_, items_to_send_, vect, buffers);
      break;
    case Echange_EV_Options::MINCOL1:
      mincol1_to_vect_items(line_size, pe_voisins_, items_to_send_, vect, buffers);
      break;
    default:
      Cerr << "Error in MD_Vector_std.tpp process_recv_data_template : operation not implemented" << finl;
      Process::exit();
    }
}
 
#endif /* MD_Vector_std_included */