stacks.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_STACKS_H_
#define BM_BM_SIM_STACKS_H_
 
#include <string>
#include <vector>
 
#include "headers.h"
#include "header_unions.h"
#include "named_p4object.h"
 
namespace bm {
 
using header_stack_id_t = p4object_id_t;
 
class StackIface {
 public:
  virtual ~StackIface() { }
 
  virtual size_t pop_front() = 0;
 
  virtual size_t pop_front(size_t num) = 0;
 
  virtual size_t push_front() = 0;
 
  virtual size_t push_front(size_t num) = 0;
 
  virtual size_t pop_back() = 0;
 
  // basically, meant to be called by the parser
  virtual size_t push_back() = 0;
 
  virtual size_t get_depth() const = 0;
 
  virtual size_t get_count() const = 0;
 
  virtual bool is_full() const = 0;
 
  virtual void reset() = 0;
};
 
// Forward declarations for core action primitives which need to have access to
// the stack's internal state (i.e. "next"). These are declared as friends in
// the Stack class definition.
namespace core {
 
struct assign_header_stack;
struct assign_union_stack;
 
}  // namespace core
 
// We use CRTP for Stack class to implement either legacy behavior or strict
// P4_16 behavior by providing different implementations of push_front and
// pop_front.
 
template <typename T, typename ShiftImpl>
class Stack : public StackIface, public NamedP4Object {
 public:
  friend class PHV;
  // These core action primitives are friends as they need to have access to the
  // stack's internal state.
  friend struct core::assign_header_stack;
  friend struct core::assign_union_stack;
 
  Stack(const std::string &name, p4object_id_t id);
 
  size_t pop_front() override;
  size_t pop_front(size_t num) override;
 
  size_t push_front() override;
  size_t push_front(size_t num) override;
 
  size_t pop_back() override;
 
  size_t push_back() override;
 
  size_t get_depth() const override;
  size_t get_count() const override;
  bool is_full() const override;
 
  void reset() override;
 
  T &get_last();
  const T &get_last() const;
 
  T &get_next();
  const T &get_next() const;
 
  T &at(size_t idx);
  const T &at(size_t idx) const;
 
 protected:
  using TRef = std::reference_wrapper<T>;
 
  // To be called by PHV class
  // This is a special case, as I want to store a reference
  // NOLINTNEXTLINE
  void set_next_element(T &e);
 
  std::vector<TRef> elements{};
  // first empty index; if next == headers.size(), stack is full
  size_t next{0};
};
 
namespace detail {
 
// Implements legacy behavior for stacks. push_front and pop_front only shift
// the portion of the stack up to the next index. Pushed elements are marked as
// valid.
template <typename T>
class StackLegacy : public Stack<T, StackLegacy<T> > {
 public:
  StackLegacy(const std::string &name, p4object_id_t id);
 
  size_t pop_front();
  size_t pop_front(size_t num);
 
  size_t push_front();
  size_t push_front(size_t num);
};
 
// Implements strict P4_16 behavior for stacks. push_front and pop_front shift
// the entire stack. Pushed elements are marked as invalid.
template <typename T>
class StackP4_16 : public Stack<T, StackP4_16<T> > {
 public:
  StackP4_16(const std::string &name, p4object_id_t id);
 
  size_t pop_front();
  size_t pop_front(size_t num);
 
  size_t push_front();
  size_t push_front(size_t num);
};
 
#ifdef BM_WP4_16_STACKS
template <typename T>
// using MyStack = StackP4_16<T>;
using MyStack = StackP4_16<T>;
#else
template <typename T>
using MyStack = StackLegacy<T>;
#endif  // BM_WP4_16_STACKS
 
}  // namespace detail
 
using header_stack_id_t = p4object_id_t;
using header_union_stack_id_t = p4object_id_t;
 
using HeaderStack = detail::MyStack<Header>;
using HeaderUnionStack = detail::MyStack<HeaderUnion>;
 
#undef _P4_16_STACKS
 
}  // namespace bm
 
#endif  // BM_BM_SIM_STACKS_H_