communications.h

/****************************************************************************
* Copyright (c) 2026, 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 communications_included
#define communications_included
 
#include <communications_array.h>
#include <TRUSTTabs_forward.h>
#include <type_traits>
#include <vector>
 
#ifdef MPI_
#if INT_is_64_ == 1
#define MPI_ENTIER MPI_LONG
#else
#define MPI_ENTIER MPI_INT
#endif /* INT_is_64_ */
#endif /* MPI_ */
 
// For Objet_U ... we use a buffer!!
bool envoyer(const Objet_U& t, int source, int cible, int canal);
bool envoyer(const Objet_U& t, int cible, int canal);
bool recevoir(Objet_U& t, int source, int cible, int canal);
bool recevoir(Objet_U& t, int source, int canal);
bool envoyer_broadcast(Objet_U& t, int source);
 
void assert_parallel(const Objet_U& obj);
bool is_parallel_object(const Objet_U& obj);
bool is_parallel_object(const double x);
bool is_parallel_object(const int x);
#if INT_is_64_ == 2
bool is_parallel_object(const trustIdType x);
#endif
 
bool envoyer_all_to_all(const TRUST_Vector<TRUSTTab<double>>& src, TRUST_Vector<TRUSTTab<double>>& dest);
bool envoyer_all_to_all(const TRUST_Vector<TRUSTArray<int>>& src, TRUST_Vector<TRUSTArray<int>>& dest);
#if INT_is_64_ == 2
bool envoyer_all_to_all(const TRUST_Vector<TRUSTArray<trustIdType>>& src, TRUST_Vector<TRUSTArray<trustIdType>>& dest);
#endif
bool envoyer_all_to_all(std::vector<long long>& src, std::vector<long long>& dest);
void envoyer_all_to_all(const DoubleTab& src, DoubleTab& dest);
void envoyer_all_gather(const DoubleTab& src, DoubleTab& dest);
void envoyer_gather(const IntTab& src, IntTab& dest, int root);
void envoyer_gather(const DoubleTab& src, DoubleTab& dest, int root);
void envoyer_all_gather(const IntTab& src, IntTab& dest);
void envoyer_all_gatherv(const DoubleTab& src, DoubleTab& dest, const IntTab& recv_size);
 
bool reverse_send_recv_pe_list(const ArrOfInt& src_list, ArrOfInt& dest_list);
bool comm_check_enabled();
 
/* ******************************************************************************************************** *
 * FUNCTION TEMPLATE IMPLEMENTATIONS with SFINAE to avoid substitution failure because now IT IS AN ERROR ! *
 * ******************************************************************************************************** */
 
// For simple types, we go through envoyer_array_ which does not use a buffer but sends values directly. Faster.
// SIMPLE TYPES (std::is_arithmetic) => NOT Objet_U => SFINAE
template<typename _TYPE_> std::enable_if_t<std::is_arithmetic<_TYPE_>::value,bool >
inline envoyer(const _TYPE_ t, int source, int cible, int canal)
{
  return envoyer_array<_TYPE_>(&t, 1, source, cible, canal);
}
 
#ifndef INT_is_64_
inline bool envoyer(const long t, int source, int cible, int canal) { return envoyer_array<long>(&t, 1, source, cible, canal); }
#endif
 
template<typename _TYPE_> std::enable_if_t<std::is_arithmetic<_TYPE_>::value,bool >
inline envoyer(const _TYPE_ t, int cible, int canal)
{
  return envoyer_array<_TYPE_>(&t, 1, Process::me(), cible, canal);
}
 
#ifndef INT_is_64_
inline bool envoyer(const long t, int cible, int canal) { return envoyer_array<long>(&t, 1, Process::me(), cible, canal); }
#endif
 
template<typename _TYPE_> std::enable_if_t<std::is_arithmetic<_TYPE_>::value,bool >
inline recevoir(_TYPE_& t, int source, int cible, int canal)
{
  return recevoir_array<_TYPE_>(&t, 1, source, cible, canal);
}
 
#ifndef INT_is_64_
inline bool recevoir(long& t, int source, int cible, int canal) { return recevoir_array<long>(&t, 1, source, cible, canal); }
#endif
 
template<typename _TYPE_> std::enable_if_t<std::is_arithmetic<_TYPE_>::value,bool >
inline recevoir(_TYPE_& t, int source, int canal)
{
  return recevoir_array<_TYPE_>(&t, 1, source, Process::me(), canal);
}
 
#ifndef INT_is_64_
inline bool recevoir(long& t, int source, int canal) { return recevoir_array<long>(&t, 1, source, Process::me(), canal); }
#endif
 
template<typename _TYPE_> std::enable_if_t<std::is_arithmetic<_TYPE_>::value,bool >
inline envoyer_broadcast(_TYPE_& t, int source)
{
  return envoyer_broadcast_array<_TYPE_>(&t, 1, source);
}
 
#ifndef INT_is_64_
inline bool envoyer_broadcast(long& t, int source) { return envoyer_broadcast_array<long>(&t, 1, source); }
#endif
 
/*! @brief In comm_check_enabled() mode, verifies that the parameter has the same value on all processors.
 *
 */
template<typename _TYPE_> std::enable_if_t<(std::is_arithmetic<_TYPE_>::value),void >
inline assert_parallel(const _TYPE_ x)
{
  if (!Comm_Group::check_enabled())
    return;
  if (!is_parallel_object(x))
    {
      Cerr << "Fatal error in template<typename _TYPE_>assert_parallel(const _TYPE_ x). See log files" << finl;
      Process::Journal() << "Error in template<typename _TYPE_>assert_parallel(const _TYPE_ x)" << "This processor has this value: " << x << finl;
      Process::barrier();
      Process::exit();
    }
}
 
/*! @brief Assumes that the input and output arrays are of size nproc().
 *
 * src[0] is sent to proc 0, src[1] to proc 1, etc... the value received from processor 0 is placed in dest[0], processor 1 in dest[1], etc...
 *   It is allowed to call this function with the same array for src and dest.
 *
 */
template<typename _TYPE_>
inline bool envoyer_all_to_all(const TRUSTArray<_TYPE_>& src, TRUSTArray<_TYPE_>& dest)
{
  const Comm_Group& grp = PE_Groups::current_group();
  assert(src.size_array() == grp.nproc());
  assert(dest.size_array() == grp.nproc());
  if (src.data() == dest.data())
    {
      TRUSTArray<_TYPE_> tmp;
      tmp.resize_array(grp.nproc(), RESIZE_OPTIONS::NOCOPY_NOINIT);
      grp.all_to_all(src.data(), tmp.data(), sizeof(_TYPE_));
      dest.inject_array(tmp);
    }
  else
    grp.all_to_all(src.data(), dest.data(), sizeof(_TYPE_));
  return true;
}
 
#endif /* communications_included */