computeManager.hpp

Go to the documentation of this file.

/*
 *   Copyright 2025 Huawei Technologies Co., Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
/*
 * Copyright Huawei Technologies Switzerland AG
 * All rights reserved.
 */
 
#pragma once
 
#include <memory>
#include <hicr/core/definitions.hpp>
#include <hicr/core/exceptions.hpp>
#include <hicr/core/computeResource.hpp>
#include <hicr/core/executionUnit.hpp>
#include <hicr/core/executionState.hpp>
#include <hicr/core/processingUnit.hpp>
 
namespace HiCR
{
 
class ComputeManager
{
  public:
 
  virtual ~ComputeManager() = default;
 
  virtual __INLINE__ std::shared_ptr<HiCR::ExecutionUnit> createExecutionUnit(const replicableFc_t &function)
  {
    HICR_THROW_RUNTIME("This compute manager cannot create execution units out of replicable CPU-executable functions");
  }
 
  [[nodiscard]] virtual std::unique_ptr<HiCR::ProcessingUnit> createProcessingUnit(std::shared_ptr<HiCR::ComputeResource> resource) const = 0;
 
  virtual std::unique_ptr<HiCR::ExecutionState> createExecutionState(std::shared_ptr<HiCR::ExecutionUnit> executionUnit, void *const argument = nullptr) const = 0;
 
  __INLINE__ void initialize(std::unique_ptr<HiCR::ProcessingUnit> &processingUnit)
  {
    // Getting processing unit's internal state
    auto state = processingUnit->getState();
 
    // Checking internal state
    if (state != HiCR::ProcessingUnit::uninitialized && state != HiCR::ProcessingUnit::terminated)
      HICR_THROW_RUNTIME("Attempting to initialize already initialized processing unit");
 
    // Calling PU-specific initialization
    initializeImpl(processingUnit);
 
    // Transitioning state
    processingUnit->setState(HiCR::ProcessingUnit::ready);
  }
 
  __INLINE__ void start(std::unique_ptr<HiCR::ProcessingUnit> &processingUnit, std::unique_ptr<HiCR::ExecutionState> &executionState)
  {
    // Getting processing unit's internal state
    auto state = processingUnit->getState();
 
    // Checking internal state
    if (state != HiCR::ProcessingUnit::ready) HICR_THROW_RUNTIME("Attempting to start processing unit that is not in the 'ready' state");
 
    // Transitioning state
    processingUnit->setState(HiCR::ProcessingUnit::running);
 
    // Running internal implementation of the start function
    startImpl(processingUnit, executionState);
  }
 
  __INLINE__ void suspend(std::unique_ptr<HiCR::ProcessingUnit> &processingUnit)
  {
    // Getting processing unit's internal state
    auto state = processingUnit->getState();
 
    // Checking state
    if (state != HiCR::ProcessingUnit::running) HICR_THROW_RUNTIME("Attempting to suspend processing unit that is not in the 'running' state");
 
    // Transitioning state
    processingUnit->setState(HiCR::ProcessingUnit::suspended);
 
    // Calling internal implementation of the suspend function
    suspendImpl(processingUnit);
  }
 
  __INLINE__ void resume(std::unique_ptr<HiCR::ProcessingUnit> &processingUnit)
  {
    // Getting processing unit's internal state
    auto state = processingUnit->getState();
 
    // Checking state
    if (state != HiCR::ProcessingUnit::suspended) HICR_THROW_RUNTIME("Attempting to resume processing unit that is not in the 'suspended' state");
 
    // Transitioning state
    processingUnit->setState(HiCR::ProcessingUnit::running);
 
    // Calling internal implementation of the resume function
    resumeImpl(processingUnit);
  }
 
  __INLINE__ void terminate(std::unique_ptr<HiCR::ProcessingUnit> &processingUnit)
  {
    // Transitioning state
    processingUnit->setState(HiCR::ProcessingUnit::terminating);
 
    // Calling internal implementation of the terminate function
    terminateImpl(processingUnit);
  }
 
  __INLINE__ void await(std::unique_ptr<HiCR::ProcessingUnit> &processingUnit)
  {
    // Getting processing unit's internal state
    auto state = processingUnit->getState();
 
    // Checking state
    if (state != HiCR::ProcessingUnit::terminating && state != HiCR::ProcessingUnit::running && state != HiCR::ProcessingUnit::suspended) return;
 
    // Calling internal implementation of the await function
    awaitImpl(processingUnit);
 
    // Transitioning state
    processingUnit->setState(HiCR::ProcessingUnit::terminated);
  }
 
  protected:
 
  virtual void initializeImpl(std::unique_ptr<HiCR::ProcessingUnit> &processingUnit) = 0;
 
  virtual void startImpl(std::unique_ptr<HiCR::ProcessingUnit> &processingUnit, std::unique_ptr<HiCR::ExecutionState> &executionState) = 0;
 
  virtual void suspendImpl(std::unique_ptr<HiCR::ProcessingUnit> &processingUnit) = 0;
 
  virtual void resumeImpl(std::unique_ptr<HiCR::ProcessingUnit> &processingUnit) = 0;
 
  virtual void terminateImpl(std::unique_ptr<HiCR::ProcessingUnit> &processingUnit) = 0;
 
  virtual void awaitImpl(std::unique_ptr<HiCR::ProcessingUnit> &processingUnit) = 0;
};
} // namespace HiCR