DataSynchronizeBuffer.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* DataSynchronizeBuffer.h                                     (C) 2000-2025 */
/*                                                                           */
/* Implementation of a generic buffer for data synchronization.              */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_IMPL_DATASYNCHRONIZEBUFFER_H
#define ARCANE_IMPL_DATASYNCHRONIZEBUFFER_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/MemoryView.h"
#include "arcane/utils/Array.h"
#include "arcane/utils/Array2.h"
#include "arcane/utils/SmallArray.h"
#include "arcane/utils/TraceAccessor.h"
 
#include "arcane/impl/IDataSynchronizeBuffer.h"
#include "arcane/utils/FixedArray.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
namespace Arcane
{
class IBufferCopier;
class DataSynchronizeResult;
class DataSynchronizeInfo;
class DataSynchronizeBufferInfoList;
class MemoryBuffer;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class ARCANE_IMPL_EXPORT DataSynchronizeBufferBase
: public IDataSynchronizeBuffer
{
  class BufferInfo
  {
   public:

    MutableMemoryView globalBuffer() const { return m_memory_view; }

    void setGlobalBuffer(MutableMemoryView v);

    MutableMemoryView localBuffer(Int32 rank_index) const;

    MutableMemoryView dataLocalBuffer(Int32 rank_index, Int32 data_index) const;

    Int64 displacement(Int32 rank_index) const;

    Int64 localBufferSize(Int32 rank_index) const;

    Int64 totalSize() const { return m_total_size; }

    ConstArrayView<Int32> localIds(Int32 index) const;
 
    void checkValid() const
    {
      ARCANE_CHECK_POINTER(m_buffer_info);
    }
 
    void initialize(ConstArrayView<Int32> datatype_sizes, const DataSynchronizeBufferInfoList* buffer_info);
 
   private:

    MutableMemoryView m_memory_view;
    UniqueArray2<Int64> m_displacements;
    SmallArray<Int64> m_local_buffer_size;
    ConstArrayView<Int32> m_datatype_sizes;
    Int64 m_total_size = 0;
    const DataSynchronizeBufferInfoList* m_buffer_info = nullptr;
  };
 
 public:
 
  Int32 nbRank() const final { return m_nb_rank; }
  Int32 targetRank(Int32 index) const final;
  bool hasGlobalBuffer() const final { return true; }
 
  MutableMemoryView receiveBuffer(Int32 index) final { return m_ghost_buffer_info.localBuffer(index); }
  MutableMemoryView sendBuffer(Int32 index) final { return m_share_buffer_info.localBuffer(index); }
 
  Int64 receiveDisplacement(Int32 index) const final { return m_ghost_buffer_info.displacement(index); }
  Int64 sendDisplacement(Int32 index) const final { return m_share_buffer_info.displacement(index); }
 
  MutableMemoryView globalReceiveBuffer() final { return m_ghost_buffer_info.globalBuffer(); }
  MutableMemoryView globalSendBuffer() final { return m_share_buffer_info.globalBuffer(); }
 
  Int64 totalReceiveSize() const final { return m_ghost_buffer_info.totalSize(); }
  Int64 totalSendSize() const final { return m_share_buffer_info.totalSize(); }
 
  void barrier() final;
 
 public:
 
  DataSynchronizeBufferBase(DataSynchronizeInfo* sync_info, Ref<IBufferCopier> copier);
 
 public:

  bool isCompareSynchronizedValues() const { return m_is_compare_sync_values; }
 
  void setSynchronizeBuffer(Ref<MemoryBuffer> v)
  {
    m_memory = v;
  }

  virtual void prepareSynchronize(bool is_compare_sync) = 0;
 
 protected:
 
  void _allocateBuffers();
  void _compute(ConstArrayView<Int32> datatype_sizes);
 
 protected:
 
  DataSynchronizeInfo* m_sync_info = nullptr;
  BufferInfo m_ghost_buffer_info;
  BufferInfo m_share_buffer_info;
  BufferInfo m_compare_sync_buffer_info;
 
 protected:
 
  Int32 m_nb_rank = 0;
  bool m_is_compare_sync_values = false;

  Ref<MemoryBuffer> m_memory;
 
  Ref<IBufferCopier> m_buffer_copier;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class ARCANE_IMPL_EXPORT SingleDataSynchronizeBuffer
: public TraceAccessor
, public DataSynchronizeBufferBase
{
 public:
 
  SingleDataSynchronizeBuffer(ITraceMng* tm, DataSynchronizeInfo* sync_info, Ref<IBufferCopier> copier)
  : TraceAccessor(tm)
  , DataSynchronizeBufferBase(sync_info, copier)
  {}
 
 public:
 
  void copyReceiveAsync(Int32 index) final;
  void copySendAsync(Int32 index) final;
 
 public:
 
  void setDataView(MutableMemoryView v)
  {
    m_data_view = v;
    m_datatype_sizes[0] = v.datatypeSize();
  }
  MutableMemoryView dataView() { return m_data_view; }
  void prepareSynchronize(bool is_compare_sync) override;

  DataSynchronizeResult finalizeSynchronize();
 
 private:

  MutableMemoryView m_data_view;
  FixedArray<Int32, 1> m_datatype_sizes;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class ARCANE_IMPL_EXPORT MultiDataSynchronizeBuffer
: public TraceAccessor
, public DataSynchronizeBufferBase
{
 
 public:
 
  MultiDataSynchronizeBuffer(ITraceMng* tm, DataSynchronizeInfo* sync_info,
                             Ref<IBufferCopier> copier)
  : TraceAccessor(tm)
  , DataSynchronizeBufferBase(sync_info, copier)
  {}
 
 public:
 
  void copyReceiveAsync(Int32 rank_index) final;
  void copySendAsync(Int32 rank_index) final;
 
 public:
 
  void setNbData(Int32 nb_data)
  {
    m_data_views.resize(nb_data);
    m_datatype_sizes.resize(nb_data);
  }
  void setDataView(Int32 index, MutableMemoryView v)
  {
    m_data_views[index] = v;
    m_datatype_sizes[index] = v.datatypeSize();
  }
 
  void prepareSynchronize(bool is_compare_sync) override;
 
 private:

  SmallArray<MutableMemoryView> m_data_views;
  SmallArray<Int32> m_datatype_sizes;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif