MpiParallelDispatch.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2026 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* MpiParallelDispatch.h                                       (C) 2000-2026 */
/*                                                                           */
/* Implementation of messages with MPI.                                      */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_PARALLEL_MPI_MPIPARALLELDISPATCH_H
#define ARCANE_PARALLEL_MPI_MPIPARALLELDISPATCH_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/TraceAccessor.h"
 
#include "arcane/core/IParallelDispatch.h"
 
#include "arcane/parallel/mpi/ArcaneMpi.h"
#include "arcane/parallel/mpi/MpiDatatypeList.h"
 
#include "arccore/message_passing_mpi/internal/MpiTypeDispatcher.h"
#include "arccore/message_passing/PointToPointMessageInfo.h"
#include "arccore/base/ReferenceCounterImpl.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class MpiParallelMng;
namespace MP = ::Arccore::MessagePassing;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <class Type>
class MpiParallelDispatchT
: public TraceAccessor
, public ReferenceCounterImpl
, public IParallelDispatchT<Type>
{
  ARCCORE_INTERNAL_DEFINE_REFERENCE_COUNTED_INCLASS_METHODS();
 
 private:
 
  class ARCANE_MPI_EXPORT MinMaxSumInfo
  {
   public:
 
    Integer m_min_rank;
    Integer m_max_rank;
    Type m_min_value;
    Type m_max_value;
    Type m_sum_value;
  };
 
 public:
 
  typedef Parallel::Request Request;
  typedef Parallel::eReduceType eReduceType;
  using PointToPointMessageInfo = Parallel::PointToPointMessageInfo;
 
 public:
 
  ARCANE_MPI_EXPORT MpiParallelDispatchT(ITraceMng* tm, IMessagePassingMng* parallel_mng, MpiAdapter* adapter, MpiDatatype* datatype);
 
 public:
 
  ARCANE_MPI_EXPORT ~MpiParallelDispatchT() override;
  ARCANE_MPI_EXPORT void finalize() override;
 
 public:
 
  void broadcast(ArrayView<Type> send_buf, Int32 rank) override
  {
    m_mp_dispatcher->broadcast(send_buf, rank);
  }
  void allGather(ConstArrayView<Type> send_buf, ArrayView<Type> recv_buf) override
  {
    m_mp_dispatcher->allGather(send_buf, recv_buf);
  }
  void allGatherVariable(ConstArrayView<Type> send_buf, Array<Type>& recv_buf) override
  {
    m_mp_dispatcher->allGatherVariable(send_buf, recv_buf);
  }
  void gather(ConstArrayView<Type> send_buf, ArrayView<Type> recv_buf, Int32 rank) override
  {
    m_mp_dispatcher->gather(send_buf, recv_buf, rank);
  }
  void gatherVariable(ConstArrayView<Type> send_buf, Array<Type>& recv_buf, Int32 rank) override
  {
    m_mp_dispatcher->gatherVariable(send_buf, recv_buf, rank);
  }
  void scatterVariable(ConstArrayView<Type> send_buf, ArrayView<Type> recv_buf, Int32 root) override
  {
    m_mp_dispatcher->scatterVariable(send_buf, recv_buf, root);
  }
  void allToAll(ConstArrayView<Type> send_buf, ArrayView<Type> recv_buf, Integer count) override
  {
    m_mp_dispatcher->allToAll(send_buf, recv_buf, count);
  }
  void allToAllVariable(ConstArrayView<Type> send_buf, Int32ConstArrayView send_count,
                        Int32ConstArrayView send_index, ArrayView<Type> recv_buf,
                        Int32ConstArrayView recv_count, Int32ConstArrayView recv_index) override
  {
    m_mp_dispatcher->allToAllVariable(send_buf, send_count, send_index, recv_buf, recv_count, recv_index);
  }
  Request send(ConstArrayView<Type> send_buffer, Int32 rank, bool is_blocked) override
  {
    return m_mp_dispatcher->send(send_buffer, rank, is_blocked);
  }
  Request send(Span<const Type> recv_buffer, const PointToPointMessageInfo& message) override
  {
    return m_mp_dispatcher->send(recv_buffer, message);
  }
  Request recv(ArrayView<Type> recv_buffer, Int32 rank, bool is_blocked) override
  {
    return m_mp_dispatcher->receive(recv_buffer, rank, is_blocked);
  }
  Request receive(Span<Type> recv_buffer, const PointToPointMessageInfo& message) override
  {
    return m_mp_dispatcher->receive(recv_buffer, message);
  }
  void send(ConstArrayView<Type> send_buffer, Int32 rank) override
  {
    m_mp_dispatcher->send(send_buffer, rank, true);
  }
  void recv(ArrayView<Type> recv_buffer, Int32 rank) override
  {
    m_mp_dispatcher->receive(recv_buffer, rank, true);
  }
  Type allReduce(eReduceType op, Type send_buf) override
  {
    return m_mp_dispatcher->allReduce(op, send_buf);
  }
  void allReduce(eReduceType op, ArrayView<Type> send_buf) override
  {
    m_mp_dispatcher->allReduce(op, send_buf);
  }
  void allReduce(eReduceType op, ConstArrayView<Type> send_buf, ArrayView<Type> receive_buf) override
  {
    m_mp_dispatcher->allReduce(op, send_buf, receive_buf);
  }
 
 public:
 
  ARCANE_MPI_EXPORT void sendRecv(ConstArrayView<Type> send_buffer, ArrayView<Type> recv_buffer, Int32 rank) override;
  ARCANE_MPI_EXPORT Type scan(eReduceType op, Type send_buf) override;
  ARCANE_MPI_EXPORT void scan(eReduceType op, ArrayView<Type> send_buf) override;
  ARCANE_MPI_EXPORT void computeMinMaxSum(Type val, Type& min_val, Type& max_val, Type& sum_val,
                                          Int32& min_rank,
                                          Int32& max_rank) override;
  ARCANE_MPI_EXPORT void computeMinMaxSum(ConstArrayView<Type> values,
                                          ArrayView<Type> min_values,
                                          ArrayView<Type> max_values,
                                          ArrayView<Type> sum_values,
                                          ArrayView<Int32> min_ranks,
                                          ArrayView<Int32> max_ranks) override;
 
 public:
 
  ITypeDispatcher<Type>* toArccoreDispatcher() override;
  MpiDatatype* datatype() const;
 
 public:
 
  virtual ARCANE_MPI_EXPORT void computeMinMaxSumNoInit(Type& min_val, Type& max_val, Type& sum_val,
                                                        Int32& min_rank, Int32& max_rank);
 
 private:
 
  MP::Mpi::MpiTypeDispatcher<Type>* m_mp_dispatcher;
 
 private:
 
  MPI_Datatype m_min_max_sum_datatype;
  MPI_Op m_min_max_sum_operator;
 
 private:
 
  void _initialize();
  MPI_Datatype _mpiDatatype();
  MpiAdapter* _adapter();
  MPI_Op _mpiReduceOperator(eReduceType rt);
  static void ARCANE_MPIOP_CALL _MinMaxSumOperator(void* a, void* b, int* len, MPI_Datatype* type);
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename Type> inline MpiParallelDispatchT<Type>*
createBuiltInDispatcher(ITraceMng* tm, IMessagePassingMng* pm, MpiAdapter* adapter, MpiDatatypeList* dtlist)
{
  MpiDatatype* dt = dtlist->datatype(Type());
  return new MpiParallelDispatchT<Type>(tm, pm, adapter, dt);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif