core/Runner.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2025 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* Runner.h                                                    (C) 2000-2025 */
/*                                                                           */
/* Gestion de l'exécution sur accélérateur.                                  */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_ACCELERATOR_CORE_RUNNER_H
#define ARCANE_ACCELERATOR_CORE_RUNNER_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/Ref.h"
#include "arcane/utils/MemoryRessource.h"
 
#include "arcane/accelerator/core/RunQueue.h"
 
#include <memory>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::Accelerator
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_ACCELERATOR_CORE_EXPORT Runner
{
  friend impl::RunQueueImpl;
  friend impl::RunCommandImpl;
  friend RunQueue;
  friend RunQueueEvent;
  friend impl::RunnerImpl;
 
  friend RunQueue makeQueue(const Runner& runner);
  friend RunQueue makeQueue(const Runner* runner);
  friend RunQueue makeQueue(const Runner& runner, const RunQueueBuildInfo& bi);
  friend RunQueue makeQueue(const Runner* runner, const RunQueueBuildInfo& bi);
  friend Ref<RunQueue> makeQueueRef(const Runner& runner);
  friend Ref<RunQueue> makeQueueRef(Runner& runner, const RunQueueBuildInfo& bi);
  friend Ref<RunQueue> makeQueueRef(Runner* runner);
 
 public:

  Runner();
  explicit Runner(eExecutionPolicy p);
  Runner(eExecutionPolicy p, DeviceId device);
 
 public:

  eExecutionPolicy executionPolicy() const;

  void initialize(eExecutionPolicy v);

  void initialize(eExecutionPolicy v, DeviceId device);

  bool isInitialized() const;

  ARCANE_DEPRECATED_REASON("Y2025: this method is a no op. Concurrent queue creation is always thread-safe")
  void setConcurrentQueueCreation(bool v);

  bool isConcurrentQueueCreation() const;

  double cumulativeCommandTime() const;

  ARCANE_DEPRECATED_REASON("Y2025: this method is a no op. reduce policy is always eDeviceReducePolicy::Grid")
  void setDeviceReducePolicy(eDeviceReducePolicy v);

  eDeviceReducePolicy deviceReducePolicy() const;

  void setMemoryAdvice(ConstMemoryView buffer, eMemoryAdvice advice);

  void unsetMemoryAdvice(ConstMemoryView buffer, eMemoryAdvice advice);

  DeviceId deviceId() const;

  void setAsCurrentDevice();

  const DeviceInfo& deviceInfo() const;

  DeviceMemoryInfo deviceMemoryInfo() const;

  void fillPointerAttribute(PointerAttribute& attr, const void* ptr);
 
 public:

  static const IDeviceInfoList* deviceInfoList(eExecutionPolicy policy);
 
 private:
 
  // La création est réservée aux méthodes globales makeQueue()
  static RunQueue _makeQueue(const Runner& runner)
  {
    return RunQueue(runner, true);
  }
  static RunQueue _makeQueue(const Runner& runner, const RunQueueBuildInfo& bi)
  {
    return RunQueue(runner, bi, true);
  }
  static Ref<RunQueue> _makeQueueRef(const Runner& runner)
  {
    return makeRef(new RunQueue(runner, true));
  }
  static Ref<RunQueue> _makeQueueRef(Runner& runner, const RunQueueBuildInfo& bi)
  {
    return makeRef(new RunQueue(runner, bi, true));
  }
 
 public:

  RunnerInternal* _internalApi();
 
 private:
 
  impl::IRunnerRuntime* _internalRuntime() const;
  impl::RunnerImpl* _impl() const { return m_p.get(); }
 
 private:
 
  std::shared_ptr<impl::RunnerImpl> m_p;
 
 private:
 
  void _checkIsInit() const;
  bool _isAutoPrefetchCommand() const;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

inline RunQueue
makeQueue(const Runner& runner)
{
  return Runner::_makeQueue(runner);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
inline RunQueue
makeQueue(const Runner* runner)
{
  ARCANE_CHECK_POINTER(runner);
  return Runner::_makeQueue(*runner);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
inline RunQueue
makeQueue(const Runner& runner, const RunQueueBuildInfo& bi)
{
  return Runner::_makeQueue(runner, bi);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
inline RunQueue
makeQueue(const Runner* runner, const RunQueueBuildInfo& bi)
{
  ARCANE_CHECK_POINTER(runner);
  return Runner::_makeQueue(*runner, bi);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
inline Ref<RunQueue>
makeQueueRef(const Runner& runner)
{
  return Runner::_makeQueueRef(runner);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
inline Ref<RunQueue>
makeQueueRef(Runner& runner, const RunQueueBuildInfo& bi)
{
  return Runner::_makeQueueRef(runner, bi);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
inline Ref<RunQueue>
makeQueueRef(Runner* runner)
{
  ARCANE_CHECK_POINTER(runner);
  return Runner::_makeQueueRef(*runner);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane::Accelerator
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif