core/RunQueue.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2024 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* RunQueue.h                                                  (C) 2000-2024 */
/*                                                                           */
/* Gestion d'une file d'exécution sur accélérateur.                          */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_ACCELERATOR_CORE_RUNQUEUE_H
#define ARCANE_ACCELERATOR_CORE_RUNQUEUE_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/AutoRef.h"
 
#include "arcane/accelerator/core/RunCommand.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::Accelerator
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_ACCELERATOR_CORE_EXPORT RunQueue
{
  friend RunCommand;
  friend ProfileRegion;
  friend Runner;
  friend ViewBuildInfo;
  friend class impl::RunCommandLaunchInfo;
  friend RunCommand makeCommand(const RunQueue& run_queue);
  friend RunCommand makeCommand(const RunQueue* run_queue);
  // Pour _internalNativeStream()
  friend class impl::CudaUtils;
  friend class impl::HipUtils;
  friend class impl::SyclUtils;
 
 public:

  class ScopedAsync
  {
   public:
 
    explicit ScopedAsync(RunQueue* queue)
    : m_queue(queue)
    {
      // Rend la file asynchrone
      if (m_queue) {
        m_is_async = m_queue->isAsync();
        m_queue->setAsync(true);
      }
    }
    ~ScopedAsync() noexcept(false)
    {
      // Remet la file dans l'état d'origine lors de l'appel au constructeur
      if (m_queue)
        m_queue->setAsync(m_is_async);
    }
 
   private:
 
    RunQueue* m_queue = nullptr;
    bool m_is_async = false;
  };
 
 public:

  RunQueue();
  ~RunQueue();
 
 public:

  ARCANE_DEPRECATED_REASON("Y2024: Use makeQueue(runner) instead")
  explicit RunQueue(const Runner& runner);
  ARCANE_DEPRECATED_REASON("Y2024: Use makeQueue(runner,bi) instead")
  RunQueue(const Runner& runner, const RunQueueBuildInfo& bi);
 
 public:
 
  RunQueue(const RunQueue&);
  RunQueue& operator=(const RunQueue&);
  RunQueue(RunQueue&&) noexcept;
  RunQueue& operator=(RunQueue&&) noexcept;
 
 public:

  bool isNull() const { return !m_p; }

  eExecutionPolicy executionPolicy() const;
  bool isAcceleratorPolicy() const;

  void setAsync(bool v);
  bool isAsync() const;

  const RunQueue& addAsync(bool is_async) const;

  void barrier() const;

  void copyMemory(const MemoryCopyArgs& args) const;
  void prefetchMemory(const MemoryPrefetchArgs& args) const;

  void recordEvent(RunQueueEvent& event);
  void recordEvent(Ref<RunQueueEvent>& event);
  void waitEvent(RunQueueEvent& event);
  void waitEvent(Ref<RunQueueEvent>& event);


  MemoryAllocationOptions allocationOptions() const;

  void setMemoryRessource(eMemoryRessource mem);

  eMemoryRessource memoryRessource() const;
 
 public:

  void setConcurrentCommandCreation(bool v);
  bool isConcurrentCommandCreation() const;
 
 public:

  ARCANE_DEPRECATED_REASON("Y2024: Use toCudaNativeStream(), toHipNativeStream() or toSyclNativeStream() instead")
  void* platformStream() const;
 
 public:
 
  friend bool operator==(const RunQueue& q1, const RunQueue& q2)
  {
    return q1.m_p.get() == q2.m_p.get();
  }
  friend bool operator!=(const RunQueue& q1, const RunQueue& q2)
  {
    return q1.m_p.get() != q2.m_p.get();
  }
 
 public:
 
  impl::RunQueueImpl* _internalImpl() const;
 
 private:
 
  // Les méthodes de création sont réservée à Runner.
  // On ajoute un argument supplémentaire non utilisé pour ne pas utiliser
  // le constructeur obsolète.
  RunQueue(const Runner& runner, bool);
  RunQueue(const Runner& runner, const RunQueueBuildInfo& bi, bool);
  explicit RunQueue(impl::RunQueueImpl* p);
 
 private:
 
  impl::IRunnerRuntime* _internalRuntime() const;
  impl::IRunQueueStream* _internalStream() const;
  impl::RunCommandImpl* _getCommandImpl() const;
  impl::NativeStream _internalNativeStream() const;
  void _checkNotNull() const;
 
  // Pour VariableViewBase
  friend class VariableViewBase;
  friend class NumArrayViewBase;
 
 private:
 
  AutoRef2<impl::RunQueueImpl> m_p;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
inline RunCommand
makeCommand(const RunQueue& run_queue)
{
  run_queue._checkNotNull();
  return RunCommand(run_queue);
}

inline RunCommand
makeCommand(const RunQueue* run_queue)
{
  ARCANE_CHECK_POINTER(run_queue);
  run_queue->_checkNotNull();
  return RunCommand(*run_queue);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane::Accelerator
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif