instanceManager.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 <map>
#include <memory>
#include <unordered_set>
#include <utility>
#include <functional>
#include <hicr/core/executionUnit.hpp>
#include <hicr/core/instance.hpp>
#include <hicr/core/instanceTemplate.hpp>
#include <hicr/core/localMemorySlot.hpp>
#include <hicr/core/memorySpace.hpp>
#include <hicr/core/processingUnit.hpp>
#include <hicr/core/topology.hpp>
#include <hicr/core/memoryManager.hpp>
#include <hicr/core/communicationManager.hpp>
#include <hicr/core/computeManager.hpp>
 
namespace HiCR
{
 
class InstanceManager
{
  public:
 
  using instanceList_t = std::vector<std::shared_ptr<HiCR::Instance>>;
 
  InstanceManager() = default;
 
  virtual ~InstanceManager() = default;
 
  [[nodiscard]] __INLINE__ instanceList_t &getInstances() { return _instances; }
 
  [[nodiscard]] __INLINE__ std::shared_ptr<HiCR::Instance> getCurrentInstance() const { return _currentInstance; }
 
  __INLINE__ std::shared_ptr<HiCR::InstanceTemplate> createInstanceTemplate(const HiCR::Topology &requestedTopology = HiCR::Topology())
  {
    return std::make_shared<HiCR::InstanceTemplate>(requestedTopology);
  }
 
  __INLINE__ std::shared_ptr<HiCR::Instance> createInstance(const HiCR::InstanceTemplate instanceTemplate = HiCR::InstanceTemplate())
  {
    // Requesting the creating of the instance to the specific backend
    auto newInstance = createInstanceImpl(instanceTemplate);
 
    // If successul, adding the instance to the internal list
    if (newInstance != nullptr) _instances.push_back(newInstance);
 
    // Returning value for immediate use
    return newInstance;
  }
 
  __INLINE__ void terminateInstance(const std::shared_ptr<HiCR::Instance> instance)
  {
    // Requesting the terminating of the instance to the specific backend
    terminateInstanceImpl(instance);
 
    // Remove from internal list
    _instances.erase(std::remove_if(_instances.begin(), _instances.end(), [&](std::shared_ptr<Instance> &i) { return i->getId() == instance->getId(); }), _instances.end());
  }
 
  __INLINE__ void addInstance(HiCR::Instance::instanceId_t instanceId)
  {
    // Adding a new instance
    auto instance = addInstanceImpl(instanceId);
 
    // Adding the instance to the internal list
    _instances.push_back(instance);
  }
 
  virtual void finalize() = 0;
 
  virtual void abort(int errorCode) = 0;
 
  [[nodiscard]] virtual HiCR::Instance::instanceId_t getRootInstanceId() const = 0;
 
  protected:
 
  virtual std::shared_ptr<HiCR::Instance> createInstanceImpl(const HiCR::InstanceTemplate instanceTemplate)
  {
    HICR_THROW_LOGIC("This backend does not currently support the launching of new instances during runtime");
  }
 
  virtual std::shared_ptr<HiCR::Instance> addInstanceImpl(HiCR::Instance::instanceId_t instanceId)
  {
    HICR_THROW_LOGIC("This backend does not currently support the detection of new instances during runtime");
  }
 
  virtual void terminateInstanceImpl(const std::shared_ptr<HiCR::Instance> instance)
  {
    HICR_THROW_LOGIC("This backend does not currently support the termination of instances during runtime");
  }
 
  protected:
 
  __INLINE__ void setCurrentInstance(const std::shared_ptr<HiCR::Instance> &instance) { _currentInstance = instance; }
 
  __INLINE__ void addInstance(const std::shared_ptr<HiCR::Instance> &instance) { _instances.push_back(instance); }
 
  private:
 
  instanceList_t _instances;
 
  std::shared_ptr<HiCR::Instance> _currentInstance;
};
 
} // namespace HiCR