calculations.h

Go to the documentation of this file.

/* Copyright 2013-present Barefoot Networks, Inc.
 *
 * 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.
 */
 
/*
 * Antonin Bas (antonin@barefootnetworks.com)
 *
 */
 
 
 
 
 
#ifndef BM_BM_SIM_CALCULATIONS_H_
#define BM_BM_SIM_CALCULATIONS_H_
 
#include <algorithm>  // for std::copy
#include <iosfwd>
#include <memory>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include "boost/variant.hpp"
 
#include "bytecontainer.h"
#include "named_p4object.h"
#include "phv_forward.h"
 
namespace bm {
 
class Packet;
 
/* Used to determine whether a class overloads the '()' operator */
template <typename T>
struct defines_functor_operator {
  using yes = char (&)[1];
  using no = char (&)[2];
 
  // we need a template here to enable SFINAE
  template <typename U>
  static yes deduce(char (*)[sizeof(&U::operator())]);
  // fallback
  template <typename> static no deduce(...);
 
  static bool constexpr value = sizeof(deduce<T>(0)) == sizeof(yes);
};
 
namespace detail {
 
template <class ReturnType, class... Args>
struct callable_traits_base {
  using return_type = ReturnType;
  using argument_type = std::tuple<Args...>;
 
  template<std::size_t I>
  using arg = typename std::tuple_element<I, argument_type>::type;
};
 
}  // namespace detail
 
/* Used to determine the return type and argument type of the '()' operator */
template <class T>
struct callable_traits : callable_traits<decltype(&T::operator())> { };
 
/* lambda / functor */
template <class ClassType, class ReturnType, class... Args>
struct callable_traits<ReturnType(ClassType::*)(Args...) const>
  : detail::callable_traits_base<ReturnType, Args...> { };
 
/* non-const case */
template <class ClassType, class ReturnType, class... Args>
struct callable_traits<ReturnType(ClassType::*)(Args...)>
  : detail::callable_traits_base<ReturnType, Args...> { };
 
template <bool functor, typename H>
struct HashChecker {
 protected:
  static bool constexpr valid_hash = false;
 
  ~HashChecker() { }
};
 
/* specific to hash algorithms
   checks that the signature of the '()' operator is what we want */
template<typename T, typename Return>
struct check_functor_signature {
  template<typename U, Return (U::*)(const char *, size_t) const>
  struct SFINAE {};
 
  template<typename U> static char Test(SFINAE<U, &U::operator()>*);
  template<typename U> static int Test(...);
  static const bool value = sizeof(Test<T>(0)) == sizeof(char);
};
 
/* provides "readable" error messages if an hash functor was not define
   correctly */
template <typename H>
struct HashChecker<true, H> {
 private:
  using return_type = typename callable_traits<H>::return_type;
  using argument_type = typename callable_traits<H>::argument_type;
 
  static bool constexpr v1 = std::is_unsigned<return_type>::value;
  static bool constexpr v2 =
    std::is_same<argument_type, std::tuple<const char *, size_t>>::value;
 
  static_assert(v1, "Invalid return type for HashFn");
  static_assert(v2, "Invalid parameters for HashFn");
 
  static bool constexpr v3 = check_functor_signature<H, return_type>::value;
  static_assert(!(v1 && v2) || v3, "HashFn is not const");
 
 protected:
  static bool constexpr valid_hash = v1 && v2 && v3;
 
  ~HashChecker() { }
};
 
 
template <typename U,
          typename std::enable_if<std::is_unsigned<U>::value, int>::type = 0>
class RawCalculationIface {
 public:
  U output(const char *buffer, size_t s) const {
    return output_(buffer, s);
  }
 
  std::unique_ptr<RawCalculationIface<U> > clone() const {
    return std::unique_ptr<RawCalculationIface<U> > (clone_());
  }
 
  virtual ~RawCalculationIface() { }
 
 private:
  virtual U output_(const char *buffer, size_t s) const = 0;
 
  virtual RawCalculationIface<U> *clone_() const = 0;
};
 
 
template <typename T, typename HashFn,
          typename std::enable_if<std::is_unsigned<T>::value, int>::type = 0>
class RawCalculation
  : HashChecker<defines_functor_operator<HashFn>::value, HashFn>,
    public RawCalculationIface<T> {
 public:
  // explicit RawCalculation(const HashFn &hash) : hash(hash) { }
 
  std::unique_ptr<RawCalculation<T, HashFn> > clone() const {
    return std::unique_ptr<RawCalculation<T, HashFn> > (clone_());
  }
 
  HashFn &get_hash_fn() { return hash; }
 
 private:
  T output_(const char *buffer, size_t s) const override {
    return output__(buffer, s);
  }
 
  RawCalculation<T, HashFn> *clone_() const override {
    RawCalculation<T, HashFn> *ptr = new RawCalculation<T, HashFn>();
    return ptr;
  }
 
  using HC = HashChecker<defines_functor_operator<HashFn>::value, HashFn>;
 
  static_assert(defines_functor_operator<HashFn>::value,
                "HashFn needs to overload '()' operator");
 
  template <typename U = T,
            typename std::enable_if<std::is_unsigned<U>::value, int>::type = 0>
  typename std::enable_if<HC::valid_hash, U>::type
  output__(const char *buffer, size_t s) const {
    return static_cast<U>(hash(buffer, s));
  }
 
  template <typename U = T,
            typename std::enable_if<std::is_unsigned<U>::value, int>::type = 0>
  typename std::enable_if<!HC::valid_hash, U>::type
  output__(const char *buffer, size_t s) const {
    (void) buffer; (void) s;
    return static_cast<U>(0u);
  }
 
  HashFn hash;
};
 
 
class BufBuilder {
 public:
  void push_back_field(header_id_t header, int field_offset);
  void push_back_constant(const ByteContainer &v, size_t nbits);
  void push_back_header(header_id_t header);
  void append_payload();
 
  void operator()(const Packet &pkt, ByteContainer *buf) const;
 
 private:
  struct field_t {
    header_id_t header;
    int field_offset;
  };
 
  struct constant_t {
    ByteContainer v;
    size_t nbits;
  };
 
  struct header_t {
    header_id_t header;
  };
 
  struct Deparse;  // defined in calculations.cpp
 
  std::vector<boost::variant<field_t, constant_t, header_t> > entries{};
  bool with_payload{false};
};
 
 
template <typename T,
          typename std::enable_if<std::is_unsigned<T>::value, int>::type = 0>
class Calculation_ {
 public:
  Calculation_(const BufBuilder &builder,
               std::unique_ptr<RawCalculationIface<T> > c)
    : builder(builder), c(std::move(c)) { }
 
  T output(const Packet &pkt) const {
    static thread_local ByteContainer key;
    builder(pkt, &key);
    return c->output(key.data(), key.size());
  }
 
  RawCalculationIface<T> *get_raw_calculation() { return c.get(); }
 
 protected:
  ~Calculation_() { }
 
 private:
  BufBuilder builder;
  std::unique_ptr<RawCalculationIface<T> > c;
};
 
 
class CalculationsMap {
 public:
  using MyC = RawCalculationIface<uint64_t>;
 
  static CalculationsMap *get_instance();
  bool register_one(const char *name, std::unique_ptr<MyC> c);
  std::unique_ptr<MyC> get_copy(const std::string &name);
 
 private:
  std::unordered_map<std::string, std::unique_ptr<MyC> > map_{};
};
 
 
class Calculation : public Calculation_<uint64_t> {
 public:
  Calculation(const BufBuilder &builder,
              std::unique_ptr<RawCalculationIface<uint64_t> > c)
    : Calculation_(builder, std::move(c)) { }
 
  Calculation(const BufBuilder &builder, const std::string &hash_name)
    : Calculation_(
        builder, CalculationsMap::get_instance()->get_copy(hash_name)
      ) { }
};
 
 
class NamedCalculation : public NamedP4Object, public Calculation_<uint64_t> {
 public:
  NamedCalculation(const std::string &name, p4object_id_t id,
                   const BufBuilder &builder,
                   std::unique_ptr<RawCalculationIface<uint64_t> > c)
    : NamedP4Object(name, id),
      Calculation_(builder, std::move(c)) { }
 
  NamedCalculation(const std::string &name, p4object_id_t id,
                   const BufBuilder &builder, const std::string &hash_name)
    : NamedP4Object(name, id),
      Calculation_(
        builder, CalculationsMap::get_instance()->get_copy(hash_name)
      ) { }
};
 
 
#define REGISTER_HASH(hash_name)                                        \
  bool hash_name##_create_ =                                            \
      bm::CalculationsMap::get_instance()->register_one(                \
          #hash_name,                                                   \
          std::unique_ptr<bm::CalculationsMap::MyC>(                    \
              new bm::RawCalculation<uint64_t, hash_name>()));
 
 
namespace hash {
 
uint64_t xxh64(const char *buffer, size_t s);
 
}  // namespace hash
 
 
enum class CustomCrcErrorCode {
  SUCCESS = 0,
  INVALID_CALCULATION_NAME,
  WRONG_TYPE_CALCULATION,
  INVALID_CONFIG,
};
 
namespace detail {
 
template <typename T>
struct crc_config_t {
  T polynomial;
  T initial_remainder;
  T final_xor_value;
  bool data_reflected;
  bool remainder_reflected;
};
 
template <typename T>
std::ostream &operator<<(std::ostream &out, const crc_config_t<T> &c);
 
}  // namespace detail
 
// can be used for crc8, with T == uint8_t
// can be used for crc16, with T == uint16_t
// can be used for crc32, with T == uint32_t
// can be used for crc64, with T == uint64_t
template <typename T>
class CustomCrcMgr {
 public:
  using crc_config_t = detail::crc_config_t<T>;
 
  static CustomCrcErrorCode update_config(NamedCalculation *calculation,
                                          const crc_config_t &config);
 
  static CustomCrcErrorCode update_config(RawCalculationIface<uint64_t> *c,
                                          const crc_config_t &config);
};
 
enum class ToeplitzErrorCode {
  SUCCESS = 0,
  INVALID_CALCULATION_NAME,
  WRONG_TYPE_CALCULATION,
  INVALID_KEY,
};
 
class ToeplitzMgr {
 public:
  using key_t = ByteContainer;
 
  static ToeplitzErrorCode update_key(NamedCalculation *calculation,
                                      const key_t &key);
 
  static ToeplitzErrorCode update_key(RawCalculationIface<uint64_t> *c,
                                      const key_t &key);
};
 
}  // namespace bm
 
#endif  // BM_BM_SIM_CALCULATIONS_H_