simple_pre.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.
 */
 
/*
 * Srikrishna Gopu (krishna@barefootnetworks.com)
 * Antonin Bas (antonin@barefootnetworks.com)
 *
 */
 
 
#ifndef BM_BM_SIM_SIMPLE_PRE_H_
#define BM_BM_SIM_SIMPLE_PRE_H_
 
#include <string>
#include <unordered_map>
#include <vector>
 
#include <boost/thread/shared_mutex.hpp>
 
#include "handle_mgr.h"
#include "pre.h"
 
// forward declaration of Json::Value
namespace Json {
 
class Value;
 
}  // namespace Json
 
namespace bm {
 
class McSimplePre {
 public:
  using mgrp_t = unsigned int;
  using rid_t = unsigned int;
  using egress_port_t = unsigned int;
 
  using mgrp_hdl_t = uintptr_t;
  using l1_hdl_t = uintptr_t;
  using l2_hdl_t = uintptr_t;
 
 public:
  enum McReturnCode {
    SUCCESS = 0,
    TABLE_FULL,
    INVALID_MGID,
    INVALID_MGRP_HANDLE,
    INVALID_L1_HANDLE,
    ERROR
  };
 
  struct McIn {
    mgrp_t mgid;
  };
 
  struct McOut {
    rid_t rid;
    egress_port_t egress_port;
  };
 
 public:
  static constexpr int DEFAULT_MGID_TABLE_SIZE = 4096;
  static constexpr int DEFAULT_L1_MAX_ENTRIES = 4096;
  static constexpr int DEFAULT_L2_MAX_ENTRIES = 8192;
 
  static constexpr size_t PORT_MAP_SIZE = 512;
  using PortMap = McPre::Set<PORT_MAP_SIZE>;
 
  static constexpr size_t LAG_MAP_SIZE = 512;
  using LagMap = McPre::Set<LAG_MAP_SIZE>;
 
  explicit McSimplePre(
      int mgid_table_size = DEFAULT_MGID_TABLE_SIZE,
      int l1_max_entries = DEFAULT_L1_MAX_ENTRIES,
      int l2_max_entries = DEFAULT_L2_MAX_ENTRIES)
      : mgid_table_size(mgid_table_size),
        l1_max_entries(l1_max_entries),
        l2_max_entries(l2_max_entries) {}
  McReturnCode mc_mgrp_create(const mgrp_t, mgrp_hdl_t *);
  McReturnCode mc_mgrp_destroy(const mgrp_hdl_t);
  McReturnCode mc_node_create(const rid_t,
                              const PortMap &port_map,
                              l1_hdl_t *l1_hdl);
  McReturnCode mc_node_associate(const mgrp_hdl_t, const l1_hdl_t);
  McReturnCode mc_node_dissociate(const mgrp_hdl_t, const l1_hdl_t);
  McReturnCode mc_node_destroy(const l1_hdl_t);
  McReturnCode mc_node_update(const l1_hdl_t l1_hdl,
                              const PortMap &port_map);
 
  std::string mc_get_entries() const;
 
  void reset_state();
 
  std::vector<McOut> replicate(const McIn) const;
 
  McSimplePre(const McSimplePre &other) = delete;
  McSimplePre &operator=(const McSimplePre &other) = delete;
 
  McSimplePre(McSimplePre &&other) = delete;
  McSimplePre &operator=(McSimplePre &&other) = delete;
 
 protected:
  int mgid_table_size;
  int l1_max_entries;
  int l2_max_entries;
 
  struct MgidEntry {
    mgrp_t mgid{};
    std::vector<l1_hdl_t> l1_list{};
 
    MgidEntry() {}
    explicit MgidEntry(mgrp_t mgid)
        : mgid(mgid) {}
  };
 
  struct L1Entry {
    mgrp_hdl_t mgrp_hdl{};
    rid_t rid{};
    l2_hdl_t l2_hdl{};
    bool is_associated{false};
 
    L1Entry() {}
    explicit L1Entry(rid_t rid)
        : rid(rid) {}
  };
 
  struct L2Entry {
    l1_hdl_t l1_hdl{};
    PortMap port_map{};
    LagMap lag_map{};
 
    L2Entry() {}
    L2Entry(l1_hdl_t l1_hdl, const PortMap &port_map)
        : l1_hdl(l1_hdl), port_map(port_map) {}
 
    L2Entry(l1_hdl_t l1_hdl, const PortMap &port_map, const LagMap &lag_map)
        : l1_hdl(l1_hdl), port_map(port_map), lag_map(lag_map) {}
  };
 
  // internal version, which does not acquire the lock
  void reset_state_();
 
  // does not acquire lock
  void get_entries_common(Json::Value *root) const;
 
  // does not acquire lock
  void node_dissociate(MgidEntry *mgid_entry, l1_hdl_t l1_hdl);
 
  std::unordered_map<mgrp_hdl_t, MgidEntry> mgid_entries{};
  std::unordered_map<l1_hdl_t, L1Entry> l1_entries{};
  std::unordered_map<l2_hdl_t, L2Entry> l2_entries{};
  HandleMgr l1_handles{};
  HandleMgr l2_handles{};
  mutable boost::shared_mutex mutex{};
};
 
}  // namespace bm
 
#endif  // BM_BM_SIM_SIMPLE_PRE_H_