phv.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_PHV_H_
#define BM_BM_SIM_PHV_H_
 
#include <vector>
#include <unordered_map>
#include <string>
#include <functional>
#include <set>
#include <unordered_set>
#include <map>
#include <memory>
 
#include <cassert>
 
#include "fields.h"
#include "headers.h"
#include "header_unions.h"
#include "stacks.h"
#include "named_p4object.h"
#include "expressions.h"
 
namespace bm {
 
using header_id_t = p4object_id_t;
 
// forward declaration
class PHVFactory;
 
class PHV {
  using HeaderRef = std::reference_wrapper<Header>;
  using FieldRef = std::reference_wrapper<Field>;
 
 public:
  friend class PHVFactory;
  friend class Packet;
 
  using HeaderNamesMap = std::unordered_map<std::string, HeaderRef>;
  using header_name_iterator = HeaderNamesMap::iterator;
  using const_header_name_iterator = HeaderNamesMap::const_iterator;
 
  using FieldNamesMap = std::unordered_map<std::string, FieldRef>;
 
  using header_iterator = std::vector<Header>::iterator;
  using const_header_iterator = std::vector<Header>::const_iterator;
 
 public:
  PHV() {}
 
  PHV(size_t num_headers, size_t num_header_stacks,
      size_t num_header_unions, size_t num_header_union_stacks);
 
  Header &get_header(header_id_t header_index) {
    return headers[header_index];
  }
 
  const Header &get_header(header_id_t header_index) const {
    return headers[header_index];
  }
 
  Header &get_header(const std::string &header_name) {
    return headers_map.at(header_name);
  }
 
  const Header &get_header(const std::string &header_name) const {
    return headers_map.at(header_name);
  }
 
  bool has_header(const std::string &header_name) const {
    auto it = headers_map.find(header_name);
    return (it != headers_map.end());
  }
 
  Field &get_field(header_id_t header_index, int field_offset) {
    return headers[header_index].get_field(field_offset);
  }
 
  const Field &get_field(header_id_t header_index, int field_offset) const {
    return headers[header_index].get_field(field_offset);
  }
 
  Field &get_field(const std::string &field_name) {
    return fields_map.at(field_name);
  }
 
  const Field &get_field(const std::string &field_name) const {
    return fields_map.at(field_name);
  }
 
  bool has_field(const std::string &field_name) const {
    auto it = fields_map.find(field_name);
    return (it != fields_map.end());
  }
 
  HeaderStack &get_header_stack(header_stack_id_t header_stack_index) {
    return header_stacks[header_stack_index];
  }
 
  const HeaderStack &get_header_stack(
      header_stack_id_t header_stack_index) const {
    return header_stacks[header_stack_index];
  }
 
  HeaderUnion &get_header_union(header_union_id_t header_union_index) {
    return header_unions[header_union_index];
  }
 
  const HeaderUnion &get_header_union(
      header_union_id_t header_union_index) const {
    return header_unions[header_union_index];
  }
 
  HeaderUnionStack &get_header_union_stack(
      header_union_stack_id_t header_union_stack_index) {
    return header_union_stacks[header_union_stack_index];
  }
 
  const HeaderUnionStack &get_header_union_stack(
      header_union_stack_id_t header_union_stack_index) const {
    return header_union_stacks[header_union_stack_index];
  }
 
  void reset();
 
  void reset_header_stacks();
 
  void reset_metadata();
 
  void reset_headers();
 
  void set_written_to(bool written_to_value);
 
  PHV(const PHV &other) = delete;
  PHV &operator=(const PHV &other) = delete;
 
  PHV(PHV &&other) = default;
  PHV &operator=(PHV &&other) = default;
 
  void copy_headers(const PHV &src);
 
  void set_packet_id(const uint64_t id1, const uint64_t id2) {
    packet_id = {id1, id2};
  }
 
  // iterators
 
  header_name_iterator header_name_begin() {
    return headers_map.begin();
  }
 
  const_header_name_iterator header_name_begin() const {
    return headers_map.begin();
  }
 
  header_name_iterator header_name_end() {
    return headers_map.end();
  }
 
  const_header_name_iterator header_name_end() const {
    return headers_map.end();
  }
 
  header_iterator header_begin() { return headers.begin(); }
 
  const_header_iterator header_begin() const { return headers.begin(); }
 
  header_iterator header_end() { return headers.end(); }
 
  const_header_iterator header_end() const { return headers.end(); }
 
  size_t num_headers() const { return headers.size(); }
 
  const std::string get_field_name(header_id_t header_index,
                                   int field_offset) const;
 
 private:
  // To  be used only by PHVFactory
  // all headers need to be pushed back in order (according to header_index) !!!
  // TODO(antonin): remove this constraint?
  void push_back_header(const std::string &header_name,
                        header_id_t header_index,
                        const HeaderType &header_type,
                        const std::set<int> &arith_offsets,
                        const bool metadata);
 
  void push_back_header_stack(const std::string &header_stack_name,
                              header_stack_id_t header_stack_index,
                              const HeaderType &header_type,
                              const std::vector<header_id_t> &header_ids);
 
  void push_back_header_union(const std::string &header_union_name,
                              header_union_id_t header_union_index,
                              const std::vector<header_id_t> &header_ids);
 
  void push_back_header_union_stack(
      const std::string &header_union_stack_name,
      header_union_stack_id_t header_union_stack_index,
      const std::vector<header_union_id_t> &header_union_ids);
 
  // get_field(from) will be equivalent to get_field(to)
  // 'to' needs to be a valid field name (or a previously inserted alias)
  // 'from' (the alias) does not need to adhere to the "hdr.f" naming convention
  void add_field_alias(const std::string &from, const std::string &to);
 
 private:
  std::vector<Header> headers{};
  std::vector<HeaderStack> header_stacks{};
  std::vector<HeaderUnion> header_unions{};
  std::vector<HeaderUnionStack> header_union_stacks{};
  HeaderNamesMap headers_map{};
  FieldNamesMap fields_map{};
  size_t capacity{0};
  size_t capacity_stacks{0};
  size_t capacity_unions{0};
  size_t capacity_union_stacks{0};
  Debugger::PacketId packet_id;
};
 
class PHVFactory {
 private:
  struct HeaderDesc {
    const std::string name;
    header_id_t index;
    const HeaderType &header_type;
    std::set<int> arith_offsets{};
    bool metadata;
 
    HeaderDesc(const std::string &name, const header_id_t index,
               const HeaderType &header_type, const bool metadata)
        : name(name), index(index), header_type(header_type),
          metadata(metadata) {
      for (int offset = 0; offset < header_type.get_num_fields(); offset++) {
        arith_offsets.insert(offset);
      }
    }
  };
 
  struct HeaderStackDesc {
    const std::string name;
    header_stack_id_t index;
    const HeaderType &header_type;
    std::vector<header_id_t> headers;
 
    HeaderStackDesc(const std::string &name, const header_stack_id_t index,
                    const HeaderType &header_type,
                    const std::vector<header_id_t> &headers)
        : name(name), index(index), header_type(header_type),
          headers(headers) { }
  };
 
  struct HeaderUnionDesc {
    const std::string name;
    header_union_id_t index;
    std::vector<header_id_t> headers;
 
    HeaderUnionDesc(const std::string &name, const header_union_id_t index,
                    const std::vector<header_id_t> &headers)
        : name(name), index(index), headers(headers) { }
  };
 
  struct HeaderUnionStackDesc {
    const std::string name;
    header_union_stack_id_t index;
    std::vector<header_union_id_t> header_unions;
 
    HeaderUnionStackDesc(const std::string &name,
                         const header_union_stack_id_t index,
                         const std::vector<header_union_id_t> &header_unions)
        : name(name), index(index), header_unions(header_unions) { }
  };
 
 public:
  void push_back_header(const std::string &header_name,
                        const header_id_t header_index,
                        const HeaderType &header_type,
                        const bool metadata = false);
 
  void push_back_header_stack(const std::string &header_stack_name,
                              const header_stack_id_t header_stack_index,
                              const HeaderType &header_type,
                              const std::vector<header_id_t> &headers);
 
  void push_back_header_union(const std::string &header_union_name,
                              const header_stack_id_t header_union_index,
                              const std::vector<header_id_t> &headers);
 
  void push_back_header_union_stack(
      const std::string &header_union_stack_name,
      const header_union_stack_id_t header_union_stack_index,
      const std::vector<header_union_id_t> &header_unions);
 
  void add_field_alias(const std::string &from, const std::string &to);
 
  const HeaderType &get_header_type(header_id_t header_id) const {
    return header_descs.at(header_id).header_type;
  }
 
  const HeaderType &get_header_stack_type(
      header_stack_id_t header_stack_id) const {
    return header_stack_descs.at(header_stack_id).header_type;
  }
 
  void enable_field_arith(header_id_t header_id, int field_offset);
 
  void enable_all_field_arith(header_id_t header_id);
 
  void disable_field_arith(header_id_t header_id, int field_offset);
 
  void disable_all_field_arith(header_id_t header_id);
 
  void enable_stack_field_arith(header_stack_id_t header_stack_id,
                                int field_offset);
 
  void enable_all_stack_field_arith(header_stack_id_t header_stack_id);
 
  void enable_union_stack_field_arith(
      header_union_stack_id_t header_union_stack_id, size_t header_offset,
      int field_offset);
 
  void enable_all_union_stack_field_arith(
      header_union_stack_id_t header_union_stack_id, size_t header_offset);
 
  void enable_all_union_stack_field_arith(
      header_union_stack_id_t header_union_stack_id);
 
  void enable_all_arith();
 
  std::unique_ptr<PHV> create() const;
 
 private:
  std::map<header_id_t, HeaderDesc> header_descs{};  // sorted by header id
  std::map<header_stack_id_t, HeaderStackDesc> header_stack_descs{};
  std::map<header_union_id_t, HeaderUnionDesc> header_union_descs{};
  std::map<header_union_stack_id_t, HeaderUnionStackDesc>
  header_union_stack_descs{};
  std::map<std::string, std::string> field_aliases{};  // order does not matter
  std::unordered_set<std::string> field_names{};  // just for debugging
};
 
}  // namespace bm
 
#endif  // BM_BM_SIM_PHV_H_