base.hpp

/*
 *   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 <cstring>
#include <hicr/core/definitions.hpp>
#include <hicr/core/exceptions.hpp>
#include <hicr/core/globalMemorySlot.hpp>
#include <hicr/core/communicationManager.hpp>
#include <hicr/frontends/channel/circularBuffer.hpp>
 
enum
{
  _HICR_CHANNEL_COORDINATION_BUFFER_ELEMENT_COUNT = 2
};
 
#define _HICR_CHANNEL_COORDINATION_BUFFER_ELEMENT_TYPE size_t
 
enum
{
  _HICR_CHANNEL_HEAD_ADVANCE_COUNT_IDX = 0
};
 
enum
{
  _HICR_CHANNEL_TAIL_ADVANCE_COUNT_IDX = 1
};
 
namespace HiCR::channel
{
 
class Base
{
  public:
 
  [[nodiscard]] __INLINE__ size_t getTokenSize() const noexcept { return _tokenSize; }
 
  __INLINE__ static size_t getCoordinationBufferSize() noexcept { return _HICR_CHANNEL_COORDINATION_BUFFER_ELEMENT_COUNT * sizeof(_HICR_CHANNEL_COORDINATION_BUFFER_ELEMENT_TYPE); }
 
  __INLINE__ static void initializeCoordinationBuffer(const std::shared_ptr<LocalMemorySlot> &coordinationBuffer)
  {
    // Checking for correct size
    auto requiredSize = getCoordinationBufferSize();
    auto size         = coordinationBuffer->getSize();
    if (size < requiredSize)
      HICR_THROW_LOGIC("Attempting to initialize coordination buffer size on a memory slot (%lu) smaller than the required size (%lu).\n", size, requiredSize);
 
    // Getting actual buffer of the coordination buffer
    auto bufferPtr = coordinationBuffer->getPointer();
 
    // Resetting all its values to zero
    memset(bufferPtr, 0, getCoordinationBufferSize());
  }
 
  __INLINE__ static size_t getTokenBufferSize(const size_t tokenSize, const size_t capacity) noexcept { return tokenSize * capacity; }
 
  [[nodiscard]] __INLINE__ size_t getDepth() const noexcept { return _circularBuffer->getDepth(); }
 
  [[nodiscard]] __INLINE__ bool isFull() const noexcept { return _circularBuffer->isFull(); }
 
  [[nodiscard]] __INLINE__ bool isEmpty() const noexcept { return _circularBuffer->isEmpty(); }
 
  [[nodiscard]] __INLINE__ auto getCircularBuffer() const noexcept { return _circularBuffer.get(); }
 
  protected:
 
  Base(CommunicationManager &communicationManager, const std::shared_ptr<LocalMemorySlot> &coordinationBuffer, const size_t tokenSize, const size_t capacity)
    : _communicationManager(&communicationManager),
      _coordinationBuffer(coordinationBuffer),
      _tokenSize(tokenSize)
  {
    if (tokenSize == 0) HICR_THROW_LOGIC("Attempting to create a channel with token size 0.\n");
    if (capacity == 0) HICR_THROW_LOGIC("Attempting to create a channel with zero capacity \n");
 
    // Checking that the provided coordination buffers have the right size
    auto requiredCoordinationBufferSize = getCoordinationBufferSize();
    auto providedCoordinationBufferSize = _coordinationBuffer->getSize();
    if (providedCoordinationBufferSize < requiredCoordinationBufferSize)
      HICR_THROW_LOGIC("Attempting to create a channel with a local coordination buffer size (%lu) smaller than the required size (%lu).\n",
                       providedCoordinationBufferSize,
                       requiredCoordinationBufferSize);
 
    // Creating internal circular buffer
    _circularBuffer = std::make_unique<channel::CircularBuffer>(
      capacity,
      &static_cast<_HICR_CHANNEL_COORDINATION_BUFFER_ELEMENT_TYPE *>(coordinationBuffer->getPointer())[_HICR_CHANNEL_HEAD_ADVANCE_COUNT_IDX],
      &static_cast<_HICR_CHANNEL_COORDINATION_BUFFER_ELEMENT_TYPE *>(coordinationBuffer->getPointer())[_HICR_CHANNEL_TAIL_ADVANCE_COUNT_IDX]);
  }
 
  ~Base() = default;
 
  [[nodiscard]] __INLINE__ CommunicationManager *getCommunicationManager() const { return _communicationManager; }
 
  [[nodiscard]] __INLINE__ auto getCoordinationBuffer() const { return _coordinationBuffer; }
 
  private:
 
  CommunicationManager *const _communicationManager;
 
  const std::shared_ptr<LocalMemorySlot> _coordinationBuffer;
  const size_t _tokenSize;
 
  std::unique_ptr<channel::CircularBuffer> _circularBuffer;
};
 
} // namespace HiCR::channel