DataSynchronizeBuffer.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2023 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-2023 */
/*                                                                           */
/* Implémentation d'un buffer générique pour la synchronisation de donnéess. */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_IMPL_DATASYNCHRONIZEBUFFER_H
#define ARCANE_IMPL_DATASYNCHRONIZEBUFFER_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/MemoryView.h"
#include "arcane/utils/Array.h"
#include "arcane/utils/SmallArray.h"
#include "arcane/utils/TraceAccessor.h"
 
#include "arcane/impl/IDataSynchronizeBuffer.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
namespace Arcane
{
class IBufferCopier;
class DataSynchronizeResult;
class DataSynchronizeInfo;
class DataSynchronizeBufferInfoList;
class MemoryBuffer;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_IMPL_EXPORT DataSynchronizeBufferBase
: public IDataSynchronizeBuffer
{
  class BufferInfo
  {
    friend DataSynchronizeBufferBase;
 
   public:

    MutableMemoryView globalBuffer() { return m_memory_view; }

    MutableMemoryView localBuffer(Int32 index);

    Int64 displacement(Int32 index) const;

    Int64 totalSize() const { return m_memory_view.bytes().size(); }

    ConstArrayView<Int32> localIds(Int32 index) const;
 
    void checkValid() const
    {
      ARCANE_CHECK_POINTER(m_buffer_info);
    }
 
   private:
 
    MutableMemoryView m_memory_view;
    Int32 m_datatype_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(Int32 datatype_size, bool is_compare_sync) = 0;
 
 protected:
 
  void _allocateBuffers(Int32 datatype_size);
  void _compute(Int32 datatype_size);
 
 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 DataSynchronizeBufferBase
{
 public:
 
  SingleDataSynchronizeBuffer(DataSynchronizeInfo* sync_info, Ref<IBufferCopier> copier)
  : DataSynchronizeBufferBase(sync_info, copier)
  {}
 
 public:
 
  void copyReceiveAsync(Int32 index) final;
  void copySendAsync(Int32 index) final;
 
 public:
 
  void setDataView(MutableMemoryView v) { m_data_view = v; }
  MutableMemoryView dataView() { return m_data_view; }
  void prepareSynchronize(Int32 datatype_size, bool is_compare_sync) override;

  DataSynchronizeResult finalizeSynchronize();
 
 private:

  MutableMemoryView m_data_view;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
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 index) final;
  void copySendAsync(Int32 index) final;
 
 public:
 
  void setNbData(Int32 nb_data)
  {
    m_data_views.resize(nb_data);
  }
  void setDataView(Int32 index, MutableMemoryView v) { m_data_views[index] = v; }
 
  void prepareSynchronize(Int32 datatype_size, bool is_compare_sync) override;
 
 private:

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