Memory.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2022 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* Memory.h                                                    (C) 2000-2022 */
/*                                                                           */
/* Classes de gestion mémoire associées aux accélérateurs.                   */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_ACCELERATOR_CORE_MEMORY_H
#define ARCANE_ACCELERATOR_CORE_MEMORY_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/UtilsTypes.h"
#include "arcane/utils/MemoryView.h"
 
#include "arccore/base/Span.h"
 
#include "arcane/accelerator/core/DeviceId.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::Accelerator
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
enum class eMemoryAdvice
{
  None = 0,
  MostlyRead,
  PreferredLocationDevice,
  PreferredLocationHost,
  AccessedByDevice,
  AccessedByHost
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
extern "C++" ARCANE_ACCELERATOR_CORE_EXPORT std::ostream&
operator<<(std::ostream& o,eMemoryAdvice r);
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_ACCELERATOR_CORE_EXPORT MemoryCopyArgs
{
 private:
 
  static Span<const std::byte> _toSpan(const void* ptr, Int64 length)
  {
    return { reinterpret_cast<const std::byte*>(ptr), length };
  }
  static Span<std::byte> _toSpan(void* ptr, Int64 length)
  {
    return { reinterpret_cast<std::byte*>(ptr), length };
  }
 
 public:
 
  MemoryCopyArgs(void* destination, const void* source, Int64 length)
  : MemoryCopyArgs(_toSpan(destination, length),_toSpan(source, length))
  {}
 
  MemoryCopyArgs(Span<std::byte> destination, Span<const std::byte> source)
  : m_source(source)
  , m_destination(destination)
  {
    // TODO: vérifier destination.size() > source.size();
  }
 
  MemoryCopyArgs(MutableMemoryView destination, ConstMemoryView source)
  : m_source(source)
  , m_destination(destination)
  {}
 
 public:
 
  MemoryCopyArgs& addAsync()
  {
    m_is_async = true;
    return (*this);
  }
  MemoryCopyArgs& addAsync(bool v)
  {
    m_is_async = v;
    return (*this);
  }
  ConstMemoryView source() const { return m_source; }
  MutableMemoryView destination() const { return m_destination; }
  bool isAsync() const { return m_is_async; }
 
 private:
 
  ConstMemoryView m_source;
  MutableMemoryView m_destination;
  bool m_is_async = false;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_ACCELERATOR_CORE_EXPORT MemoryPrefetchArgs
{
 private:
 
  static Span<const std::byte> _toSpan(const void* ptr, Int64 length)
  {
    return { reinterpret_cast<const std::byte*>(ptr), length };
  }
  /*static Span<std::byte> _toSpan(void* ptr, Int64 length)
  {
    return { reinterpret_cast<std::byte*>(ptr), length };
    }*/
 
 public:
 
  MemoryPrefetchArgs(const void* source, Int64 length)
  : MemoryPrefetchArgs(_toSpan(source, length))
  {}
 
  explicit MemoryPrefetchArgs(ConstMemoryView source)
  : m_source(source)
  {}
 
  explicit MemoryPrefetchArgs(Span<const std::byte> source)
  : m_source(ConstMemoryView(source))
  {}
 
 public:
 
  MemoryPrefetchArgs& addAsync()
  {
    m_is_async = true;
    return (*this);
  }
  MemoryPrefetchArgs& addAsync(bool v)
  {
    m_is_async = v;
    return (*this);
  }
  MemoryPrefetchArgs& addDeviceId(DeviceId v)
  {
    m_device_id = v;
    return (*this);
  }
  ConstMemoryView source() const { return m_source; }
  bool isAsync() const { return m_is_async; }
  DeviceId deviceId() const { return m_device_id; }
 
 private:
 
  ConstMemoryView m_source;
  DeviceId m_device_id;
  bool m_is_async = false;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane::Accelerator
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif