rely.h

/*
 * Copyright (c) 2021 Cisco and/or its affiliates.
 * 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 <hicn/transport/utils/chrono_typedefs.h>
#include <hicn/transport/utils/membuf.h>
#include <protocols/fec/fec_info.h>
#include <protocols/fec_base.h>
 
#include <rely/decoder.hpp>
#include <rely/encoder.hpp>
 
#define RELY_DEBUG 0
 
namespace transport {
namespace protocol {
namespace fec {
 
#define foreach_rely_fec_type \
  _(Rely, 1, 3)               \
  _(Rely, 2, 3)               \
  _(Rely, 4, 5)               \
  _(Rely, 4, 6)               \
  _(Rely, 4, 7)               \
  _(Rely, 6, 10)              \
  _(Rely, 8, 10)              \
  _(Rely, 8, 11)              \
  _(Rely, 8, 12)              \
  _(Rely, 8, 14)              \
  _(Rely, 8, 16)              \
  _(Rely, 8, 32)              \
  _(Rely, 10, 30)             \
  _(Rely, 10, 40)             \
  _(Rely, 10, 90)             \
  _(Rely, 16, 21)             \
  _(Rely, 16, 23)             \
  _(Rely, 16, 24)             \
  _(Rely, 16, 27)             \
  _(Rely, 17, 21)             \
  _(Rely, 17, 34)             \
  _(Rely, 32, 41)             \
  _(Rely, 32, 46)             \
  _(Rely, 32, 54)             \
  _(Rely, 34, 42)             \
  _(Rely, 35, 70)             \
  _(Rely, 52, 62)
 
class RelyBase : public virtual FECBase {
 protected:
  static const constexpr size_t kmax_stream_size = 125U;
  static const constexpr size_t kmtu = 1500U;
  static const constexpr size_t ktimeout = 100U;
  struct fec_header {
    uint32_t seq_number;
 
    void setSeqNumberBase(uint32_t suffix) { seq_number = htonl(suffix); }
    uint32_t getSeqNumberBase() { return ntohl(seq_number); }
  };
 
  RelyBase(uint32_t k, uint32_t n, uint32_t seq_offset = 0)
      : k_(k),
        n_(n),
        seq_offset_(seq_offset % n_),
        current_index_(seq_offset)
#if RELY_DEBUG
        ,
        time_(0)
#endif
  {
  }
 
  int64_t getCurrentTime() {
    // Get the current time
#if RELY_DEBUG
    return time_++;
#else
    auto _time = utils::SteadyClock::now().time_since_epoch();
    auto time = std::chrono::duration_cast<utils::Milliseconds>(_time).count();
    return time;
#endif
  }
 
 protected:
  uint32_t k_;
  uint32_t n_;
  std::uint32_t seq_offset_;
  std::vector<std::pair<uint32_t, buffer>> packets_;
 
  uint32_t current_index_;
#if RELY_DEBUG
  uint32_t time_;
#endif
};
 
class RelyEncoder : private RelyBase,
                    private rely::encoder,
                    public ProducerFEC {
 public:
  RelyEncoder(uint32_t k, uint32_t n, uint32_t seq_offset = 0);
  void onPacketProduced(core::ContentObject &content_object,
                        uint32_t offset) override;
 
  std::size_t getFecHeaderSize() override {
    return header_bytes() + sizeof(fec_header) + 4;
  }
 
  void reset() override {}
};
 
class RelyDecoder : private RelyBase,
                    private rely::decoder,
                    public ConsumerFEC {
 public:
  RelyDecoder(uint32_t k, uint32_t n, uint32_t seq_offset = 0);
 
  void onDataPacket(core::ContentObject &content_object,
                    uint32_t offset) override;
 
  std::size_t getFecHeaderSize() override {
    return header_bytes() + sizeof(fec_header);
  }
 
  void reset() override {}
};
 
}  // namespace fec
 
}  // namespace protocol
}  // namespace transport