TaskFactory.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* TaskFactory.h                                               (C) 2000-2025 */
/*                                                                           */
/* Factory for tasks.                                                        */
/*---------------------------------------------------------------------------*/
#ifndef ARCCORE_CONCURRENCY_TASKFACTORY_H
#define ARCCORE_CONCURRENCY_TASKFACTORY_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arccore/base/ConcurrencyBase.h"
#include "arccore/concurrency/Task.h"
#include "arccore/concurrency/ITaskImplementation.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class ARCCORE_CONCURRENCY_EXPORT TaskFactory
{
  friend TaskFactoryInternal;
 
 public:
 
  TaskFactory() = delete;
 
 public:

  template <typename InstanceType> static ITask*
  createTask(InstanceType* instance, void (InstanceType::*function)(const TaskContext& tc))
  {
    TaskFunctorWithContext<InstanceType> functor(instance, function);
    return m_impl->createRootTask(&functor);
  }

  template <typename InstanceType> static ITask*
  createTask(InstanceType* instance, void (InstanceType::*function)())
  {
    TaskFunctor<InstanceType> functor(instance, function);
    return m_impl->createRootTask(&functor);
  }

  template <typename InstanceType> static ITask*
  createChildTask(ITask* parent_task, InstanceType* instance, void (InstanceType::*function)(const TaskContext& tc))
  {
    ARCCORE_CHECK_POINTER(parent_task);
    TaskFunctorWithContext<InstanceType> functor(instance, function);
    return parent_task->_createChildTask(&functor);
  }

  template <typename InstanceType> static ITask*
  createChildTask(ITask* parent_task, InstanceType* instance, void (InstanceType::*function)())
  {
    ARCCORE_CHECK_POINTER(parent_task);
    TaskFunctor<InstanceType> functor(instance, function);
    return parent_task->_createChildTask(&functor);
  }

  static void executeParallelFor(Integer begin, Integer size, const ParallelLoopOptions& options, IRangeFunctor* f)
  {
    m_impl->executeParallelFor(begin, size, options, f);
  }

  static void executeParallelFor(Integer begin, Integer size, Integer block_size, IRangeFunctor* f)
  {
    m_impl->executeParallelFor(begin, size, block_size, f);
  }

  static void executeParallelFor(Integer begin, Integer size, IRangeFunctor* f)
  {
    m_impl->executeParallelFor(begin, size, f);
  }

  static void executeParallelFor(const ParallelFor1DLoopInfo& loop_info)
  {
    m_impl->executeParallelFor(loop_info);
  }

  static void executeParallelFor(const ComplexForLoopRanges<1>& loop_ranges,
                                 const ParallelLoopOptions& options,
                                 IMDRangeFunctor<1>* functor)
  {
    m_impl->executeParallelFor(loop_ranges, ForLoopRunInfo(options), functor);
  }

  static void executeParallelFor(const ComplexForLoopRanges<1>& loop_ranges,
                                 const ForLoopRunInfo& run_info,
                                 IMDRangeFunctor<1>* functor)
  {
    m_impl->executeParallelFor(loop_ranges, run_info, functor);
  }

  static void executeParallelFor(const ComplexForLoopRanges<2>& loop_ranges,
                                 const ParallelLoopOptions& options,
                                 IMDRangeFunctor<2>* functor)
  {
    m_impl->executeParallelFor(loop_ranges, ForLoopRunInfo(options), functor);
  }

  static void executeParallelFor(const ComplexForLoopRanges<2>& loop_ranges,
                                 const ForLoopRunInfo& run_info,
                                 IMDRangeFunctor<2>* functor)
  {
    m_impl->executeParallelFor(loop_ranges, run_info, functor);
  }

  static void executeParallelFor(const ComplexForLoopRanges<3>& loop_ranges,
                                 const ParallelLoopOptions& options,
                                 IMDRangeFunctor<3>* functor)
  {
    m_impl->executeParallelFor(loop_ranges, ForLoopRunInfo(options), functor);
  }

  static void executeParallelFor(const ComplexForLoopRanges<3>& loop_ranges,
                                 const ForLoopRunInfo& run_info,
                                 IMDRangeFunctor<3>* functor)
  {
    m_impl->executeParallelFor(loop_ranges, run_info, functor);
  }

  static void executeParallelFor(const ComplexForLoopRanges<4>& loop_ranges,
                                 const ParallelLoopOptions& options,
                                 IMDRangeFunctor<4>* functor)
  {
    m_impl->executeParallelFor(loop_ranges, ForLoopRunInfo(options), functor);
  }

  static void executeParallelFor(const ComplexForLoopRanges<4>& loop_ranges,
                                 const ForLoopRunInfo& run_info,
                                 IMDRangeFunctor<4>* functor)
  {
    m_impl->executeParallelFor(loop_ranges, run_info, functor);
  }

  static Int32 nbAllowedThread() { return ConcurrencyBase::maxAllowedThread(); }

  static Int32 currentTaskThreadIndex()
  {
    return m_impl->currentTaskThreadIndex();
  }

  static Int32 currentTaskIndex()
  {
    return m_impl->currentTaskIndex();
  }
 
 public:
 
  // TODO: mark these two methods as obsolete and indicate using
  // those from ConcurrencyBase instead.

  static void setDefaultParallelLoopOptions(const ParallelLoopOptions& v)
  {
    ConcurrencyBase::setDefaultParallelLoopOptions(v);
  }

  static const ParallelLoopOptions& defaultParallelLoopOptions()
  {
    return ConcurrencyBase::defaultParallelLoopOptions();
  }
 
 public:

  static bool isActive()
  {
    return m_impl->isActive();
  }

  static void printInfos(std::ostream& o)
  {
    return m_impl->printInfos(o);
  }

  ARCCORE_DEPRECATED_REASON("Y2024: This method is internal to Arcane. Do not use it")
  static IObservable* createThreadObservable();

  ARCCORE_DEPRECATED_REASON("Y2024: This method is internal to Arcane. Do not use it")
  static IObservable* destroyThreadObservable();

  static void terminate();
 
 public:

  static void setVerboseLevel(Integer v) { m_verbose_level = v; }

  static Integer verboseLevel() { return m_verbose_level; }
 
 public:

  ARCCORE_DEPRECATED_REASON("Y2024: This method is internal to Arcane. "
                            "Use TaskFactoryInternal::setImplementation() instead")
  static void _internalSetImplementation(ITaskImplementation* task_impl);
 
 private:
 
  static ITaskImplementation* m_impl;
  static Int32 m_verbose_level;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif