base.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 <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/base.hpp>
 
namespace HiCR::channel::variableSize
{
 
class Base : public channel::Base
{
  protected:
 
  Base(CommunicationManager                   &communicationManager,
       const std::shared_ptr<LocalMemorySlot> &coordinationBufferForCounts,
       const std::shared_ptr<LocalMemorySlot> &coordinationBufferForPayloads,
       const size_t                            capacity,
       const size_t                            payloadCapacity)
    : channel::Base(communicationManager, coordinationBufferForCounts, sizeof(size_t), capacity),
      _coordinationBufferForCounts(coordinationBufferForCounts),
      _coordinationBufferForPayloads(coordinationBufferForPayloads)
  {
    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 = 4 * sizeof(_HICR_CHANNEL_COORDINATION_BUFFER_ELEMENT_TYPE);
    auto providedCoordinationBufferSize = coordinationBufferForPayloads->getSize() + coordinationBufferForCounts->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
    _circularBufferForCounts = std::make_unique<channel::CircularBuffer>(
      capacity,
      &static_cast<_HICR_CHANNEL_COORDINATION_BUFFER_ELEMENT_TYPE *>(coordinationBufferForCounts->getPointer())[_HICR_CHANNEL_HEAD_ADVANCE_COUNT_IDX],
      &static_cast<_HICR_CHANNEL_COORDINATION_BUFFER_ELEMENT_TYPE *>(coordinationBufferForCounts->getPointer())[_HICR_CHANNEL_TAIL_ADVANCE_COUNT_IDX]);
 
    _circularBufferForPayloads = std::make_unique<channel::CircularBuffer>(
      payloadCapacity,
      &static_cast<_HICR_CHANNEL_COORDINATION_BUFFER_ELEMENT_TYPE *>(coordinationBufferForPayloads->getPointer())[_HICR_CHANNEL_HEAD_ADVANCE_COUNT_IDX],
      &static_cast<_HICR_CHANNEL_COORDINATION_BUFFER_ELEMENT_TYPE *>(coordinationBufferForPayloads->getPointer())[_HICR_CHANNEL_TAIL_ADVANCE_COUNT_IDX]);
  }
 
  [[nodiscard]] __INLINE__ auto getCircularBufferForCounts() const { return _circularBufferForCounts.get(); }
 
  [[nodiscard]] __INLINE__ auto getCircularBufferForPayloads() const { return _circularBufferForPayloads.get(); }
 
  [[nodiscard]] __INLINE__ auto getCoordinationBufferForCounts() const { return _coordinationBufferForCounts; }
 
  [[nodiscard]] __INLINE__ auto getCoordinationBufferForPayloads() const { return _coordinationBufferForPayloads; }
 
  private:
 
  std::unique_ptr<channel::CircularBuffer> _circularBufferForCounts;
  std::unique_ptr<channel::CircularBuffer> _circularBufferForPayloads;
  const std::shared_ptr<LocalMemorySlot> _coordinationBufferForCounts;
  const std::shared_ptr<LocalMemorySlot> _coordinationBufferForPayloads;
};
 
} // namespace HiCR::channel::variableSize