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 <CL/opencl.h>
#include <hicr/core/exceptions.hpp>
#include <hicr/core/executionState.hpp>
#include <hicr/backends/opencl/executionUnit.hpp>
#include <hicr/backends/opencl/device.hpp>
 
namespace HiCR::backend::opencl
{
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<opencl::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 setQueue(cl::CommandQueue *queue) { _queue = queue; }
 
  __INLINE__ void finalizeStream()
  {
    if (_isStreamActive == true)
    {
      // synchronize on the queue
      auto err = _syncEvent.wait();
      if (err != CL_SUCCESS) [[unlikely]] { HICR_THROW_RUNTIME("Failed to wait after kernel execution. Error %d", err); }
 
      // avoid deleting the queue more than once
      _isStreamActive = false;
    }
  }
 
  protected:
 
  __INLINE__ void resumeImpl() override
  {
    // Create event to wait for completion and check kernel status
    _syncEvent = cl::Event();
 
    _isStreamActive = true;
 
    // start the sequence of kernels execution
    _executionUnit->start(_queue);
 
    // add an event at the end of the operations to query its status and check for completion
    auto err = _queue->enqueueMarkerWithWaitList(nullptr, &_syncEvent);
    if (err != CL_SUCCESS) [[unlikely]] { HICR_THROW_RUNTIME("Failed to write event in the queue", err); }
  }
 
  __INLINE__ void suspendImpl() { HICR_THROW_RUNTIME("Suspend functionality not supported by OpenCL backend"); }
 
  __INLINE__ bool checkFinalizationImpl() override
  {
    // Check if the event has been processed
    auto status = _syncEvent.getInfo<CL_EVENT_COMMAND_EXECUTION_STATUS>();
 
    if (status != CL_COMPLETE) { return false; }
 
    // synchronize the queue and destroy it
    finalizeStream();
 
    return true;
  }
 
  private:
 
  std::shared_ptr<ExecutionUnit> _executionUnit;
 
  cl::Event _syncEvent;
 
  cl::CommandQueue *_queue;
 
  bool _isStreamActive = false;
};
 
} // namespace HiCR::backend::opencl