processingUnit.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.
 */
 
#pragma once
 
#include <memory>
#include <utility>
#include <nosv.h>
#include <nosv/affinity.h>
#include <hicr/core/definitions.hpp>
#include <hicr/backends/hwloc/computeResource.hpp>
#include <hicr/core/processingUnit.hpp>
 
#include <hicr/backends/nosv/executionState.hpp>
#include <hicr/backends/nosv/common.hpp>
 
namespace HiCR::backend::nosv
{
 
class ComputeManager;
 
class ProcessingUnit final : public HiCR::ProcessingUnit
{
  friend class HiCR::backend::nosv::ComputeManager;
 
  public:
 
  __INLINE__ ProcessingUnit(const std::shared_ptr<HiCR::ComputeResource> &computeResource)
    : HiCR::ProcessingUnit(computeResource)
  {
    // Getting up-casted pointer for the processing unit
    auto c = dynamic_pointer_cast<HiCR::backend::hwloc::ComputeResource>(computeResource);
 
    // Checking whether the execution unit passed is compatible with this backend
    if (c == nullptr) HICR_THROW_LOGIC("The passed compute resource is not supported by this processing unit type\n");
 
    // Getting the logical processor ID of the compute resource
    auto pid = c->getProcessorId();
 
    // setting up the nosv affinity for the execution task
    _nosv_affinity = nosv_affinity_get(pid, NOSV_AFFINITY_LEVEL_CPU, NOSV_AFFINITY_TYPE_STRICT);
  };
 
  [[nodiscard]] __INLINE__ std::string getType() override { return "nOS-V worker thread"; }
 
  private:
 
  __INLINE__ void initialize()
  {
    // Nothing to do here
  }
 
  __INLINE__ void suspend() { HICR_THROW_RUNTIME("nOS-V can't suspend a worker thread.\n"); }
 
  __INLINE__ void resume() { HICR_THROW_RUNTIME("nOS-V can't resume a worker thread.\n"); }
 
  __INLINE__ void start(std::unique_ptr<HiCR::ExecutionState> &executionState)
  {
    // Getting up-casted pointer of the execution state
    auto c = std::unique_ptr<HiCR::backend::nosv::ExecutionState>(dynamic_cast<HiCR::backend::nosv::ExecutionState *>(executionState.get()));
 
    // Checking whether the execution state passed is compatible with this backend
    if (c == nullptr) HICR_THROW_LOGIC("The passed execution state is not supported by this processing unit type\n");
 
    // Prevent double deletion since c now owns the pointer
    executionState.release();
 
    // Move the ovnership of the execution state to this instance
    _executionState = std::move(c);
 
    // Set execution state task metadata for this PU
    auto metadata      = (ExecutionState::taskMetadata_t *)getTaskMetadata(_executionState->_executionStateTask);
    metadata->mainLoop = true;
 
    // Initialize the barrier
    check(nosv_barrier_init(&(metadata->mainLoop_barrier), NOSV_BARRIER_NONE, 2));
 
    // Set the task affinity
    nosv_set_task_affinity(_executionState->_executionStateTask, &_nosv_affinity);
 
    // Submit the job (Now, nosv will put it inside a queue and runs it ASAP)
    check(nosv_submit(_executionState->_executionStateTask, NOSV_SUBMIT_NONE));
 
    // Barrier to as we have to wait until the execution state task is properly initialized and running
    check(nosv_barrier_wait(metadata->mainLoop_barrier));
 
    // Destroying the barrier as it is no longer needed
    check(nosv_barrier_destroy(metadata->mainLoop_barrier));
  }
 
  __INLINE__ void terminate()
  {
    // Nothing to do here. Just wait for the nOS-V worker thread to finalize on its own.
  }
 
  __INLINE__ void await()
  {
    // Get the execution state metadata
    auto metadata = (ExecutionState::taskMetadata_t *)getTaskMetadata(_executionState->_executionStateTask);
 
    // Assertion to check that only the PU task is getting to this
    if (metadata->mainLoop == false) HICR_THROW_RUNTIME("Abort, only PU from the worker mainLoop should get here.\n");
 
    // Busy wait until the function call fully executed (i.e. the worker mainLoop finished)
    while (_executionState->checkFinalization() == false) { check(nosv_yield(NOSV_YIELD_NOFLUSH)); };
  }
 
  std::unique_ptr<HiCR::backend::nosv::ExecutionState> _executionState;
 
  nosv_affinity_t _nosv_affinity;
};
 
} // namespace HiCR::backend::nosv