executionState.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 <acl/acl.h>
#include <hicr/core/exceptions.hpp>
#include <hicr/core/executionState.hpp>
#include <hicr/backends/ascend/executionUnit.hpp>
#include <hicr/backends/ascend/device.hpp>
 
namespace HiCR::backend::ascend
{
 
class ExecutionState final : public HiCR::ExecutionState
{
  public:
 
  ExecutionState(const std::shared_ptr<HiCR::ExecutionUnit> executionUnit)
    : HiCR::ExecutionState(executionUnit)
  {
    // Getting up-casted pointer for the execution unit
    auto e = dynamic_pointer_cast<ascend::ExecutionUnit>(executionUnit);
 
    // Checking whether the execution unit passed is compatible with this backend
    if (e == NULL) HICR_THROW_LOGIC("The execution unit of type '%s' is not supported by this backend\n", executionUnit->getType());
 
    _executionUnit = e;
  }
 
  ~ExecutionState() = default;
 
  __INLINE__ void setStream(const aclrtStream stream) { _stream = stream; }
 
  __INLINE__ void finalizeStream()
  {
    if (_isStreamActive)
    {
      // synchronize on the stream
      aclError err = aclrtSynchronizeStream(_stream);
      if (err != ACL_SUCCESS) HICR_THROW_RUNTIME("Failed to synchronize stream after kernel execution. Error %d", err);
 
      // Destroy the related event
      err = aclrtDestroyEvent(_syncEvent);
      if (err != ACL_SUCCESS) HICR_THROW_RUNTIME("Failed to destroy event. Error %d", err);
 
      // avoid deleting the stream more than once
      _isStreamActive = false;
    }
  }
 
  protected:
 
  __INLINE__ void resumeImpl() override
  {
    // Create an ACL event
    aclError err = aclrtCreateEvent(&_syncEvent);
    if (err != ACL_SUCCESS) HICR_THROW_RUNTIME("Can not create synchronize event. Error %d", err);
 
    // Signal that the execution unit is running
    _isStreamActive = true;
 
    // start the sequence of kernels execution
    _executionUnit->start(_stream);
 
    // add an event at the end of the operations to query its status and check for completion
    err = aclrtRecordEvent(_syncEvent, _stream);
    if (err != ACL_SUCCESS) HICR_THROW_RUNTIME("can not set sync bit to 1. Error %d", err);
  }
 
  __INLINE__ void suspendImpl() { HICR_THROW_RUNTIME("Suspend functionality not supported by Ascend backend"); }
 
  __INLINE__ bool checkFinalizationImpl() override
  {
    // Check if the event has been processed
    aclrtEventRecordedStatus status;
    aclError                 err = aclrtQueryEventStatus(_syncEvent, &status);
    if (err != ACL_SUCCESS) HICR_THROW_RUNTIME("failed to query event status. err %d", err);
 
    // check the synchronization event status for stream completion
    if (status == ACL_EVENT_RECORDED_STATUS_NOT_READY) return false;
 
    // synchronize the stream and destroy it
    finalizeStream();
 
    return true;
  }
 
  private:
 
  std::shared_ptr<ExecutionUnit> _executionUnit;
 
  aclrtEvent _syncEvent;
 
  aclrtStream _stream;
 
  bool _isStreamActive = false;
};
 
} // namespace HiCR::backend::ascend