GatherGroup.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* GatherGroup.h                                               (C) 2000-2026 */
/*                                                                           */
/* Class allowing the management of data groupings across the writer         */
/* sub-domains.                                                              */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_CORE_INTERNAL_GATHERGROUP_H
#define ARCANE_CORE_INTERNAL_GATHERGROUP_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/core/internal/IGatherGroup.h"
 
#include "arcane/utils/Array.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class GatherGroupInfo;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class ARCANE_CORE_EXPORT GatherGroup
: public IGatherGroup
{
 
 public:

  explicit GatherGroup(GatherGroupInfo* gather_group_info);

  GatherGroup();
 
  ~GatherGroup() override;
 
 public:
 
  bool isNeedGather() override;
  void gatherToMasterIO(Int64 sizeof_elem, Span<const Byte> in, Span<Byte> out) override;
 
 public:

  void setGatherGroupInfo(GatherGroupInfo* gather_group_info);

  template <class T>
  void gatherToMasterIOT(Span<const T> in, Array<T>& out);

  template <class T>
  void gatherToMasterIOT(Span2<const T> in, Array2<T>& out);
 
 private:
 
  GatherGroupInfo* m_gather_group_info = nullptr;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class ARCANE_CORE_EXPORT GatherGroupInfo
: public IGatherGroupInfo
{
  friend class GatherGroup;
 
 public:

  GatherGroupInfo(IParallelMng* parallel_mng, bool use_collective_io);
 
  ~GatherGroupInfo() override;
 
 public:
 
  void computeSize(Int32 nb_elem_in) override;
  void setNeedRecompute() override { m_is_computed = false; }
  bool isComputed() override { return m_is_computed; }
  Int32 nbElemOutput() override { return m_nb_elem_output; }
  Int32 sizeOfOutput(Int32 sizeof_type) override { return m_nb_elem_output * sizeof_type; }
  SmallSpan<Int32> nbElemRecvGatherToMasterIO() override;
  Int32 nbWriterGlobal() override { return m_nb_writer_global; }
 
 public:
 
  void setCollectiveIO(bool enable) { m_use_collective_io = enable; }

  template <class T>
  void computeSizeT(Span<const T> in);

  template <class T>
  void computeSizeT(Span2<const T> in);
 
 private:
 
  IParallelMng* m_parallel_mng = nullptr;
  bool m_use_collective_io = false;
  UniqueArray<Int32> m_nb_elem_recv;
  Int32 m_nb_elem_output = -1;
  Int32 m_writer = -1;
  Int32 m_nb_sender_to_writer = -1;
  Int32 m_nb_writer_global = -1;
  bool m_is_computed = false;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <class T>
void GatherGroup::
gatherToMasterIOT(Span<const T> in, Array<T>& out)
{
  out.clear();
 
  Span<const Byte> in_b(reinterpret_cast<const Byte*>(in.data()), in.sizeBytes());
 
  Int32 final_nb_elem = m_gather_group_info->m_nb_elem_output;
  out.resizeNoInit(final_nb_elem);
 
  Span<Byte> out_b(reinterpret_cast<Byte*>(out.data()), final_nb_elem * sizeof(T));
 
  gatherToMasterIO(sizeof(T), in_b, out_b);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <class T>
void GatherGroup::
gatherToMasterIOT(Span2<const T> in, Array2<T>& out)
{
  out.clear();
 
  Span<const Byte> in_b(reinterpret_cast<const Byte*>(in.data()), in.totalNbElement() * sizeof(T));
 
  Int32 final_nb_elem = m_gather_group_info->m_nb_elem_output;
  out.resizeNoInit(final_nb_elem, in.dim2Size());
 
  Span<Byte> out_b(reinterpret_cast<Byte*>(out.span().data()), final_nb_elem * in.dim2Size() * sizeof(T));
 
  gatherToMasterIO(in.dim2Size() * sizeof(T), in_b, out_b);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <class T>
void GatherGroupInfo::
computeSizeT(Span<const T> in)
{
  computeSize(in.size());
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <class T>
void GatherGroupInfo::
computeSizeT(Span2<const T> in)
{
  computeSize(in.dim1Size());
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif